feima-shortcuts 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feima-shortcuts",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "快捷指令",
   "main": "index.js",
   "directories": {

package/src/generateApi/index.js

@@ -4,169 +4,7 @@ const fs = require("fs");
 const path = require("path");
 const { deleteFolder } = require("../utils/deleteFolder");
 const { makeDir } = require("../utils/makeDir");
-
-
-const requestStrFun = () => {
-  return `/**
- * 通过 feima generate-api 命令生成
- * 请勿手动修改此文件
- */
-import axios from "axios";
-import type { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from "axios";
-import { ElMessage } from "element-plus";
-import qs from "qs";
-import { useGlobalStore } from "@/store"; // 路径根据实际情况调整
-import { wrapEncryption, encryptRequestParams, decrypt } from "@/utils/crypto";
-import other from "@/utils/other";
-
-import type { ApiRequestOptions } from "./ApiRequestOptions";
-import { CancelablePromise } from "./CancelablePromise";
-import type { OpenAPIConfig } from "./OpenAPI";
-
-// 常用header
-export enum CommonHeaderEnum {
-  "TENANT_ID" = "TENANT-ID",
-  "ENC_FLAG" = "Enc-Flag",
-  "AUTHORIZATION" = "Authorization",
-  "VERSION" = "VERSION",
-}
-
-const service: AxiosInstance = axios.create({
-  baseURL: \`\${import.meta.env.VITE_API_URL}\`,
-  timeout: 50000, // 全局超时时间
-  paramsSerializer: {
-    serialize: (params: any) => {
-      return qs.stringify(params, { arrayFormat: "repeat" });
-    },
-  },
-});
-
-/**
- * Axios请求拦截器，对请求进行处理
- * 1. 序列化get请求参数
- * 2. 统一增加Authorization和TENANT-ID请求头
- * 3. 自动适配单体、微服务架构不同的URL
- * @param config AxiosRequestConfig对象，包含请求配置信息
- */
-service.interceptors.request.use(
-  (config: InternalAxiosRequestConfig) => {
-    // 统一增加Authorization请求头, skipToken 跳过增加token
-    const token = localStorage.getItem("token");
-    if (token && !config.headers?.skipToken) {
-      config.headers![CommonHeaderEnum.AUTHORIZATION] = \`Bearer \${token}\`;
-    }
-
-    // 统一增加TENANT-ID请求头, skipTenant 跳过增加租户ID
-    const tenantId = localStorage.getItem("tenantId");
-    if (tenantId && !config.headers?.skipTenant) {
-      config.headers![CommonHeaderEnum.TENANT_ID] = tenantId;
-    }
-
-    // 增加 gray_version 请求头
-    const version = import.meta.env.VITE_GRAY_VERSION;
-    if (version) {
-      config.headers![CommonHeaderEnum.VERSION] = version;
-    }
-
-    // 请求报文加密 ，如果请求头中不包含 ENC_FLAG ： false 则加密
-    if (config.data && !config.headers![CommonHeaderEnum.ENC_FLAG]) {
-      config.data = wrapEncryption(config.data);
-    }
-
-    // 如果是 GET ，加密 config.param 的每一个参数，并URLencode
-    if (config.method === "get" && config.params) {
-      config.params = encryptRequestParams(config.params);
-    }
-
-    // 自动适配单体和微服务架构不同的URL
-    config.url = other.adaptationUrl(config.url);
-
-    // 处理完毕，返回config对象
-    return config;
-  },
-  (error: any) => {
-    // 对请求错误进行处理
-    return Promise.reject(error);
-  }
-);
-
-/**
- * 响应拦截器处理函数
- * @param response 响应结果
- * @returns 如果响应成功，则返回响应的data属性；否则，抛出错误或者执行其他操作
- */
-const handleResponse = (response: AxiosResponse<any>) => {
-  if (response.data.code === 1) {
-    throw response.data;
-  }
-
-  // 针对密文返回解密
-  if (response.data.encryption) {
-    response.data = decrypt(response.data.encryption);
-    return response.data;
-  }
-
-  return response.data;
-};
-
-/**
- * 添加 Axios 的响应拦截器，用于全局响应结果处理
- */
-service.interceptors.response.use(handleResponse, (error: any) => {
-  const status = Number(error.response.status) || 200;
-
-  if (status === 424) {
-    const { logout } = useGlobalStore();
-    logout();
-    ElMessage.error("令牌状态已过期，请点击重新登录");
-    window.location.replace(\`\${import.meta.env.BASE_URL}login\`);
-  }
-
-  if (status === 426) {
-    const { logout } = useGlobalStore();
-    logout();
-    ElMessage.error("租户状态已过期，请联系管理员");
-    window.location.replace(\`\${import.meta.env.BASE_URL}login\`);
-  }
-
-  // 针对密文返回解密
-  if (error.response?.data?.encryption) {
-    error.response.data = decrypt(error.response?.data.encryption);
-  }
-
-  return Promise.reject(error.response.data);
-});
-
-export const request = <T>(
-  config: OpenAPIConfig,
-  options: ApiRequestOptions
-): CancelablePromise<T> => {
-  const { query, ...rest } = options;
-
-  return new CancelablePromise((resolve, reject, onCancel) => {
-    const url = \`\${config.BASE}\${rest.url}\`;
-
-    const source = axios.CancelToken.source();
-    
-    onCancel(() => source.cancel("The user aborted a request."));
-
-    service
-      .request({
-        ...rest,
-        params: query,
-        url,
-        data: rest?.body,
-        cancelToken: source.token,
-      })
-      .then((data: any) => {
-        resolve(data);
-      })
-      .catch((error: any) => {
-        reject(error);
-      });
-  });
-};`;
-};
+const requestTemplate = require("./requestTemplate");
 
 
 exports.run = () => {
@@ -213,8 +51,9 @@ exports.run = () => {
 
       // 确保 ./tmpRequest.ts 使用内置的 requestStr（放在项目根目录）
       const requestFile = path.resolve(process.cwd(), "tmpRequest.ts");
+
       try {
-        fs.writeFileSync(requestFile, requestStrFun(), "utf8");
+        fs.writeFileSync(requestFile, requestTemplate, "utf8");
         console.log("📝 已写入 ./tmpRequest.ts");
       } catch (e) {
         console.error("❌ 写入 ./tmpRequest.ts 失败:", e.message);

package/src/generateApi/requestTemplate.js

@@ -0,0 +1,370 @@
+const template = `/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import axios from "axios";
+import service from "@/utils/request";
+import type {
+  AxiosError,
+  AxiosRequestConfig,
+  AxiosResponse,
+  AxiosInstance,
+} from "axios";
+import FormData from "form-data";
+
+import { ApiError } from "./ApiError";
+import type { ApiRequestOptions } from "./ApiRequestOptions";
+import type { ApiResult } from "./ApiResult";
+import { CancelablePromise } from "./CancelablePromise";
+import type { OnCancel } from "./CancelablePromise";
+import type { OpenAPIConfig } from "./OpenAPI";
+
+export const isDefined = <T>(
+  value: T | null | undefined
+): value is Exclude<T, null | undefined> => {
+  return value !== undefined && value !== null;
+};
+
+export const isString = (value: any): value is string => {
+  return typeof value === "string";
+};
+
+export const isStringWithValue = (value: any): value is string => {
+  return isString(value) && value !== "";
+};
+
+export const isBlob = (value: any): value is Blob => {
+  return (
+    typeof value === "object" &&
+    typeof value.type === "string" &&
+    typeof value.stream === "function" &&
+    typeof value.arrayBuffer === "function" &&
+    typeof value.constructor === "function" &&
+    typeof value.constructor.name === "string" &&
+    /^(Blob|File)$/.test(value.constructor.name) &&
+    /^(Blob|File)$/.test(value[Symbol.toStringTag])
+  );
+};
+
+export const isFormData = (value: any): value is FormData => {
+  return value instanceof FormData;
+};
+
+export const isSuccess = (status: number): boolean => {
+  return status >= 200 && status < 300;
+};
+
+export const base64 = (str: string): string => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    // @ts-ignore
+    return Buffer.from(str).toString("base64");
+  }
+};
+
+export const getQueryString = (params: Record<string, any>): string => {
+  const qs: string[] = [];
+
+  const append = (key: string, value: any) => {
+    qs.push(\`\${encodeURIComponent(key)}=\${encodeURIComponent(String(value))}\`);
+  };
+
+  const process = (key: string, value: any) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(\`\${key}[\${k}]\`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+
+  if (qs.length > 0) {
+    return \`?\${qs.join("&")}\`;
+  }
+
+  return "";
+};
+
+const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+
+  const path = options.url
+    .replace("{api-version}", config.VERSION)
+    .replace(/{(.*?)}/g, (substring: string, group: string) => {
+      if (options.path?.hasOwnProperty(group)) {
+        return encoder(String(options.path[group]));
+      }
+      return substring;
+    });
+
+  const url = \`\${config.BASE}\${path}\`;
+  if (options.query) {
+    return \`\${url}\${getQueryString(options.query)}\`;
+  }
+  return url;
+};
+
+export const getFormData = (
+  options: ApiRequestOptions
+): FormData | undefined => {
+  if (options.formData) {
+    const formData = new FormData();
+
+    const process = (key: string, value: any) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+
+    Object.entries(options.formData)
+      .filter(([_, value]) => isDefined(value))
+      .forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((v) => process(key, v));
+        } else {
+          process(key, value);
+        }
+      });
+
+    return formData;
+  }
+  return undefined;
+};
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export const resolve = async <T>(
+  options: ApiRequestOptions,
+  resolver?: T | Resolver<T>
+): Promise<T | undefined> => {
+  if (typeof resolver === "function") {
+    return (resolver as Resolver<T>)(options);
+  }
+  return resolver;
+};
+
+export const getHeaders = async (
+  config: OpenAPIConfig,
+  options: ApiRequestOptions,
+  formData?: FormData
+): Promise<Record<string, string>> => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS),
+  ]);
+
+  const formHeaders =
+    (typeof formData?.getHeaders === "function" && formData?.getHeaders()) ||
+    {};
+
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers,
+    ...formHeaders,
+  })
+    .filter(([_, value]) => isDefined(value))
+    .reduce(
+      (headers, [key, value]) => ({
+        ...headers,
+        [key]: String(value),
+      }),
+      {} as Record<string, string>
+    );
+
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = \`Bearer \${token}\`;
+  }
+
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(\`\${username}:\${password}\`);
+    headers["Authorization"] = \`Basic \${credentials}\`;
+  }
+
+  if (options.body !== undefined) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+
+  return headers;
+};
+
+export const getRequestBody = (options: ApiRequestOptions): any => {
+  if (options.body) {
+    return options.body;
+  }
+  return undefined;
+};
+
+export const sendRequest = async <T>(
+  config: OpenAPIConfig,
+  options: ApiRequestOptions,
+  url: string,
+  body: any,
+  formData: FormData | undefined,
+  headers: Record<string, string>,
+  onCancel: OnCancel,
+  axiosClient: AxiosInstance
+): Promise<AxiosResponse<T>> => {
+  const source = axios.CancelToken.source();
+
+  const requestConfig: AxiosRequestConfig = {
+    url,
+    headers,
+    data: body ?? formData,
+    method: options.method,
+    withCredentials: config.WITH_CREDENTIALS,
+    withXSRFToken:
+      config.CREDENTIALS === "include" ? config.WITH_CREDENTIALS : false,
+    cancelToken: source.token,
+  };
+
+  onCancel(() => source.cancel("The user aborted a request."));
+
+  try {
+    return await axiosClient.request(requestConfig);
+  } catch (error) {
+    const axiosError = error as AxiosError<T>;
+    if (axiosError.response) {
+      return axiosError.response;
+    }
+    throw error;
+  }
+};
+
+export const getResponseHeader = (
+  response: AxiosResponse<any>,
+  responseHeader?: string
+): string | undefined => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return undefined;
+};
+
+export const getResponseBody = (response: AxiosResponse<any>): any => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return undefined;
+};
+
+export const catchErrorCodes = (
+  options: ApiRequestOptions,
+  result: ApiResult
+): void => {
+  const errors: Record<number, string> = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors,
+  };
+
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return undefined;
+      }
+    })();
+
+    throw new ApiError(
+      options,
+      result,
+      \`Generic Error: status: \${errorStatus}; status text: \${errorStatusText}; body: \${errorBody}\`
+    );
+  }
+};
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @param axiosClient The axios client instance to use
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export const request = <T>(
+  config: OpenAPIConfig,
+  options: ApiRequestOptions,
+  axiosClient: AxiosInstance = service
+): CancelablePromise<T> => {
+  return new CancelablePromise(async (resolve, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options, formData);
+
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest<T>(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel,
+          axiosClient
+        );
+        const responseBody = getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+
+        const result: ApiResult = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody,
+        };
+
+        catchErrorCodes(options, result);
+
+        resolve(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};`