ykt-team-wxapp/utils/http.js

import { loading, hideLoading } from "./widget";
import { buildApiUrl, getDefaultUploadUrl, isSh6CorpId, normalizeCorpId, resolveApiContext } from "./api-base-config";

const defaultOptions = {
  header: {
    "Content-Type": "application/json",
  },
  method: "POST",
  timeout: 1000 * 60, // 请求超时设置为60秒
};
const tasks = [];
let miniappSessionRefresher = null;
let miniappSessionRefreshPromise = null;

export function setMiniappSessionRefresher(refresher) {
  miniappSessionRefresher = typeof refresher === "function" ? refresher : null;
}

async function refreshMiniappSession() {
  if (!miniappSessionRefresher) return false;
  if (!miniappSessionRefreshPromise) {
    miniappSessionRefreshPromise = Promise.resolve()
      .then(() => miniappSessionRefresher())
      .finally(() => {
        miniappSessionRefreshPromise = null;
      });
  }
  await miniappSessionRefreshPromise;
  return Boolean(uni.getStorageSync("miniappSessionToken"));
}

// 是否正在刷新 token
let isRefreshing = false;
// 重试队列
let retryQueue = [];

/**
 * 处理重试队列
 * @param {String} token - 新的 token
 */
function processQueue(token) {
	retryQueue.forEach(({ resolve, reject, config }) => {
		if (token) {
			// 更新 token 并重试请求
			if (!config.header) config.header = {};
			config.header.Authorization = `Bearer ${token}`;
			uni.request({
				...config,
				success: (res) => resolve(res),
				fail: (err) => reject(err),
			});
		} else {
			reject(new Error("Token 刷新失败"));
		}
	});
	retryQueue = [];
}

/**
 * 刷新 token
 * @returns {Promise<String|null>}
 */
async function refreshAccessToken() {
	const refreshToken = uni.getStorageSync("refreshToken");
	if (!refreshToken) {
		return null;
	}

	if (isRefreshing) {
		// 等待刷新完成
		await new Promise((resolve) => setTimeout(resolve, 100));
		return uni.getStorageSync("accessToken");
	}

	isRefreshing = true;

	try {
		const res = await uni.request({
			url: buildApiUrl("/auth/refresh"),
			method: "POST",
			header: {
				"Content-Type": "application/json",
			},
			data: {
				refreshToken,
			},
		});

		if (res && res.data && res.data.success && res.data.data) {
			const newToken = res.data.data.accessToken;
			uni.setStorageSync("accessToken", newToken);
			processQueue(newToken);
			return newToken;
		} else {
			// 刷新失败，清空队列
			processQueue(null);
			// 清除登录状态
			uni.removeStorageSync("accessToken");
			uni.removeStorageSync("refreshToken");
			uni.removeStorageSync("jwtUserInfo");
			return null;
		}
	} catch (error) {
		console.error("Token 刷新异常:", error);
		processQueue(null);
		uni.removeStorageSync("accessToken");
		uni.removeStorageSync("refreshToken");
		uni.removeStorageSync("jwtUserInfo");
		return null;
	} finally {
		isRefreshing = false;
	}
}

const request = async (options = {}, showLoading = true) => {
  const sessionRetried = options.__miniappSessionRetried === true;
  const requestOptions = { ...options };
  delete requestOptions.__miniappSessionRetried;
  // 合并用户传入的配置和默认配置
  if (!requestOptions.data) requestOptions.data = {};
  if (requestOptions.data.corpId) {
    requestOptions.data = {
      ...requestOptions.data,
      corpId: normalizeCorpId(requestOptions.data.corpId),
    };
  }
  const requestCorpId = requestOptions.data.corpId || resolveApiContext().corpId;
  const requiresMiniappSession = isSh6CorpId(requestCorpId);
  
  const config = {
    ...defaultOptions,
    ...requestOptions,
    url: buildApiUrl(requestOptions.url, requestOptions.data.corpId),
  };
  const sessionToken = uni.getStorageSync("miniappSessionToken");
  if (requiresMiniappSession && sessionToken) {
    config.header = { ...(config.header || {}), "X-Miniapp-Session": sessionToken };
  }
  
  const key = `${JSON.stringify(config)}_${Date.now()}`;
  if (showLoading) {
    recordTask(key)
  }
  
  try {
    // 发起请求
    const res = await uni.request(config);
    if (showLoading) {
      removeTask(key)
    }
    
    if (requiresMiniappSession && res.statusCode === 401) {
      uni.removeStorageSync("miniappSessionToken");
      uni.removeStorageSync("miniappSessionExpiresAt");
      if (
        !sessionRetried &&
        requestOptions.data.type !== "wxAppLogin" &&
        await refreshMiniappSession()
      ) {
        return request({ ...requestOptions, __miniappSessionRetried: true }, showLoading);
      }
    }
    // 如果返回 401，尝试刷新 token
    // if (res.statusCode === 401) {
    //   if (showLoading) {
    //     removeTask(key)
    //   }
      
    //   // 尝试刷新 token
    //   const newToken = await refreshAccessToken();
      
    //   if (newToken) {
    //     // 刷新成功，重试原请求
    //     if (!config.header) config.header = {};
    //     config.header.Authorization = `Bearer ${newToken}`;
        
    //     if (showLoading) {
    //       recordTask(key)
    //     }
        
    //     const retryRes = await uni.request(config);
        
    //     if (showLoading) {
    //       removeTask(key)
    //     }
        
    //     const success = retryRes && retryRes.data && retryRes.data.success === true;
    //     if (success) {
    //       return retryRes.data;
    //     }
    //     return {
    //       success: false,
    //       message: retryRes.data && retryRes.data.message ? retryRes.data.message : "请求失败",
    //     };
    //   } else {
    //     return {
    //       success: false,
    //       message: "登录已过期，请重新登录",
    //     };
    //   }
    // }
    
    const success = res && res.data && res.data.success === true;
    if (success) {
      return res.data;
    }
    return {
      ...(res && res.data && typeof res.data === "object" ? res.data : {}),
      success: false,
      message: res.data && res.data.message ? res.data.message : "请求失败",
    };
  } catch (error) {
    console.log("error:", error);
    if (showLoading) {
      removeTask(key)
    }
    return Promise.reject(error);
  }
};

function recordTask(task) {
  if (tasks.length === 0) {
    loading("请求中...");
  }
  tasks.push(task);
}

function removeTask(task) {
  const index = tasks.findIndex((i) => i === task);
  if (index > -1) {
    tasks.splice(index, 1);
  }
  if (tasks.length === 0) {
    hideLoading();
  }
}

export default request;

export const uploadUrl = getDefaultUploadUrl();

export function getFullPath(path, corpId) {
  return buildApiUrl(path, normalizeCorpId(corpId));
}


export function upload(path, corpId) {
  const normalizedCorpId = normalizeCorpId(corpId);
  const uploadCorpId = normalizedCorpId || resolveApiContext().corpId;
  const sessionToken = uni.getStorageSync("miniappSessionToken");
  const currentUploadUrl = buildApiUrl("/upload", normalizedCorpId);
  return new Promise((resolve) => {
    uni.uploadFile({
      url: currentUploadUrl,
      header: isSh6CorpId(uploadCorpId) && sessionToken
        ? { "X-Miniapp-Session": sessionToken }
        : {},
      filePath: path,
      name: 'file',
      fileType: 'image',
      success: (res) => {
        try {
          const url = JSON.parse(res.data).filePath;
          resolve(url ? getFullPath(url, normalizedCorpId) : '')
        } catch (e) {
          resolve()
        }
      },
      fail: res => {
        resolve()
      }
    })
  })
}