关于request.ts问题

[Verdant-Grassland]

我这request.ts我这写的是哪里不对呢？请各位帮忙解决这种问题

我后端没问题，只有前端的

import type { HttpResponse } from './types';

import { useAppConfig } from '@vben/hooks';
import { $t } from '@vben/locales';
import { preferences } from '@vben/preferences';
import { useAccessStore } from '@vben/stores';
import {
  decodeBase64,
  decryptWithAes,
  encodeBase64,
  encryptWithAes,
  generateAesKey,
  objectToQuerys,
  sessionCache,
  showConfirm,
  showMsgError,
  showNotifyError,
} from '@vben/utils';

import * as encryptUtil from '@vben/utils';

import { useUserStore } from '@app/store';
import { message, Modal } from 'ant-design-vue';
import { isEmpty, isNull } from 'lodash-es';

import {
  authenticateResponseInterceptor,
  errorMessageResponseInterceptor,
} from './preset-interceptors';
import { stringify } from 'qs';
import { RequestClient } from './request-client';

/** HTTP状态码 - 仅定义使用到的 */
const HttpCode = {
  SUCCESS: 200,
  UNAUTHORIZED: 401,
  INTERNAL_SERVER_ERROR: 500,
  WARN: 601,
} as const;

/** 错误消息 - 仅用于前端固定场景 */
const ErrorMsg = {
  NETWORK: '接口连接异常',
  TIMEOUT: '接口请求超时',
  REPEAT_SUBMIT: '数据正在处理，请勿重复提交',
  DECRYPT_FAILED: '响应数据解密失败',
  SESSION_EXPIRED: '无效的会话，或者会话已过期，请重新登录。',
  UNKNOWN: '网络错误',
} as const;

export class UnauthorizedException extends Error {}

/** 是否显示重新登录*/
const isReLogin = { show: false };

let isLogoutProcessing = false;

const { apiURL, enableEncrypt } = useAppConfig(
  import.meta.env,
  import.meta.env.PROD,
);

function createRequestClient(baseURL: string) {
  const client = new RequestClient({
    // 后端地址
    baseURL,
    // 消息提示类型
    errorMessageMode: 'message',
    // 是否返回原生响应 比如：需要获取响应头时使用该属性
    isReturnNativeResponse: false,
    // 需要对返回数据进行处理
    isTransformResponse: true,
  });

  /**
   * 重新认证逻辑
   */
  async function doReAuthenticate(): Promise<void> {
    const authStore = useUserStore();
    const accessStore = useAccessStore();
    console.warn('Access token expired, redirecting to login...');

    if (
      preferences.app.loginExpiredMode === 'modal' &&
      accessStore.isAccessChecked
    ) {
      accessStore.setLoginExpired(true);
    } else {
      await authStore.logoutUser();
    }
  }

  /**
   * 刷新token逻辑
   */
  async function doRefreshToken(): Promise<string> {
    return '';
  }

  const formatToken = (token: null | string): any => {
    return token ? `Bearer ${token}` : null;
  };

  client.addRequestInterceptor({
    fulfilled: (config) => {
      const accessStore = useAccessStore();
      config.headers.Authorization = formatToken(accessStore.accessToken);

      const language = preferences.app.locale.replace('-', '_');

      // 设置国际化
      config.headers['Accept-Language'] = language;
      config.headers['Content-Language'] = language;

      // get请求映射params参数
      if (config.method === 'get' && config.params) {
        const queryString = objectToQuerys(config.params);
        if (queryString) {
          config.url = `${config.url}?${queryString}`;
        }
        config.params = {};
      }

      if (
        ['DELETE', 'GET'].includes(config.method?.toUpperCase() || '') &&
        config.params &&
        !config.paramsSerializer
      ) {
        /**
         * 1. 格式化参数 微服务在传递区间时间选择(后端的params Map类型参数)需要格式化key 否则接收不到
         * 2. 数组参数需要格式化 后端才能正常接收 会变成arr=1&arr=2&arr=3的格式来接收
         */
        config.paramsSerializer = (params) =>
          stringify(params, { arrayFormat: 'repeat' });
      }

      // 防止重复提交
      if (
        config.headers?.repeatSubmit !== false &&
        ['POST', 'PUT'].includes(config.method?.toUpperCase() || '')
      ) {
        const requestObj = {
          url: config.url,
          data:
            typeof config.data === 'object'
              ? JSON.stringify(config.data)
              : config.data,
          time: Date.now(),
        };

        const repeatSubmitCache = sessionCache.getJSON('repeatSubmitCache');
        if (repeatSubmitCache) {
          const { url: s_url, data: s_data, time: s_time } = repeatSubmitCache;
          const interval = 5000;

          if (
            s_data === requestObj.data &&
            requestObj.time - s_time < interval &&
            s_url === requestObj.url
          ) {
            console.warn(`[${s_url}]: ${ErrorMsg.REPEAT_SUBMIT}`);
            return Promise.reject(new Error(ErrorMsg.REPEAT_SUBMIT));
          } else {
            sessionCache.setJSON('repeatSubmitCache', requestObj);
          }
        } else {
          sessionCache.setJSON('repeatSubmitCache', requestObj);
        }
      }

      // 参数加密处理 
      const { encrypt } = config;
      if (
       enableEncrypt &&
        encrypt &&
        ['POST', 'PUT'].includes(config.method?.toUpperCase() || '')
      ) {
        const aesKey = generateAesKey();
        config.headers['encrypt-key'] = encryptUtil.encrypt(encodeBase64(aesKey));
        config.data =
          typeof config.data === 'object'
            ? encryptWithAes(JSON.stringify(config.data), aesKey)
            : encryptWithAes(config.data, aesKey);
      }

      // FormData数据去请求头Content-Type
      if (config.data instanceof FormData) {
        delete config.headers['Content-Type'];
      }

      return config;
    },
  });

  // 添加错误消息响应拦截器
  client.addResponseInterceptor(
    errorMessageResponseInterceptor((msg: string, error: any) => {
      console.error('Request error:', msg, error);
    }),
  );

  client.addResponseInterceptor<HttpResponse>({
    fulfilled: async (response) => {
      const keyStr = (response.headers ?? {})['encrypt-key'];
      if (keyStr) {
        const base64Str = encryptUtil.decrypt(keyStr);
        const aesKey = decodeBase64(base64Str.toString());
        const decryptData = decryptWithAes(
          response.data as unknown as string,
          aesKey,
        );
        response.data = JSON.parse(decryptData);
      } else {
        return response.data
      }

      let timeoutMsg = '';

      const { isReturnNativeResponse, isTransformResponse } = response.config;
      if (isReturnNativeResponse) {
        return response;
      }
      if (!isTransformResponse) {
        // 修复条件判断逻辑
        if (
          response.config.responseType === 'arraybuffer' ||
          (response.config.responseType === 'blob' &&
            response.headers?.['content-type']?.includes('application/json'))
        ) {
          const blob = response.data as unknown as Blob;
          response.data = JSON.parse(await blob.text());
        } else {
          return response.data;
        }

        const axiosResponseData = response.data;
        if (!axiosResponseData) {
          throw new Error($t('http.apiRequestFailed'));
        }

        const { code, msg, data, ...other } = axiosResponseData;

        const hasSuccess =
          Reflect.has(axiosResponseData, 'code') && code === HttpCode.SUCCESS;
        if (hasSuccess) {
          let successMsg = msg;
          if (isNull(successMsg) || isEmpty(successMsg)) {
            successMsg = $t(`http.operationSuccess`);
          }
          if (response.config?.successMessageMode === 'modal') {
            Modal.success({
              content: successMsg,
              title: $t('http.successTip'),
            });
          } else if (response.config?.successMessageMode === 'message') {
            message.success(successMsg);
          }
          if (data !== undefined) {
            return data;
          }
          return other;
        }

        switch (code) {
          case HttpCode.INTERNAL_SERVER_ERROR: {
            const errorMsg = msg || ErrorMsg.UNKNOWN;
            showMsgError(errorMsg);
            throw new Error(errorMsg);
          }
          case HttpCode.UNAUTHORIZED: {
            if (isLogoutProcessing) {
              throw new UnauthorizedException(timeoutMsg);
            }
            isLogoutProcessing = true;
            const _msg = $t('http.loginTimeout');
            const userStore = useUserStore();
            userStore.logout().finally(() => {
              message.error(_msg);
              isLogoutProcessing = false;
            });
            handleUnauthorized();
            throw new Error(ErrorMsg.SESSION_EXPIRED);
          }
          case HttpCode.WARN: {
            const warnMsg = msg || ErrorMsg.UNKNOWN;
            showMsgError({ message: warnMsg, type: 'warning' });
            throw new Error(warnMsg);
          }
          default: {
            if (msg) {
              timeoutMsg = msg;
            }
            const errorMsg = msg || ErrorMsg.UNKNOWN;
            showNotifyError(errorMsg);
            throw new Error(errorMsg);
          }
        }
      }
      if (response.config.errorMessageMode === 'modal') {
        Modal.error({
          content: timeoutMsg,
          title: $t('http.errorTip'),
        });
      } else if (response.config.errorMessageMode === 'message') {
        message.error(timeoutMsg);
      }

      throw new Error(timeoutMsg || $t('http.apiRequestFailed'));
    },
  });

  const handleUnauthorized = async () => {
    if (isReLogin.show) return;

    isReLogin.show = true;
    try {
      const [err] = await showConfirm(
        '登录状态已过期，您可以继续留在该页面，或者重新登录',
        '系统提示',
        {
          confirmButtonText: '重新登录',
          cancelButtonText: '取消',
          type: 'warning',
        },
      );

      if (!err) {
        // 跳转到登录页
        window.location.href = `/login?redirect=${encodeURIComponent(window.location.href)}`;
      }
    } finally {
      isReLogin.show = false;
    }
  };

  // token过期的处理 - 添加认证响应拦截器
  client.addResponseInterceptor(
    authenticateResponseInterceptor({
      client,
      doReAuthenticate,
      doRefreshToken,
      enableRefreshToken: preferences.app.enableRefreshToken || false,
      formatToken,
    }),
  );

  return client;
}

export const http = createRequestClient(apiURL);

export const baseHttp = new RequestClient({ baseURL: apiURL });