@4399ywkf/cli 1.0.7 → 1.0.9

package/dist/templates/components/AntdStaticMethods/index.tsx

@@ -0,0 +1,20 @@
+// Entry component
+import { App } from 'antd';
+import type { MessageInstance } from 'antd/es/message/interface';
+import type { ModalStaticFunctions } from 'antd/es/modal/confirm';
+import type { NotificationInstance } from 'antd/es/notification/interface';
+import { memo } from 'react';
+
+let message: MessageInstance;
+let notification: NotificationInstance;
+let modal: Omit<ModalStaticFunctions, 'warn'>;
+
+export default memo(() => {
+  const staticFunction = App.useApp();
+  message = staticFunction.message;
+  modal = staticFunction.modal;
+  notification = staticFunction.notification;
+  return null;
+});
+
+export { message, modal, notification };

package/dist/templates/config/env/.env.public.tpl

@@ -1,5 +1,5 @@
 API_PREFIX="/api"
-API_TIMEOUT=60 * 1000
+API_TIMEOUT=60000
 
 COOKIE_NAME='ywkf_jwt'
 
@@ -9,23 +9,6 @@ OUTPUT_PATH='dist'
 BASENAME='/'
 
 PUBLIC_PATH='/s{{{ name }}}/'
-VERSION_NOTIFY_TIME=30000
-
-
-# Sentry 配置 - (官网)
-# REACT_APP_SENTRY_DSN="https://95add4dc797c22aa2224494e4abd4d71@o4509466151878656.ingest.us.sentry.io/4509466153058304"
-# SENTRY_PROJECT="javascript-react"
-# SENTRY_ORG="test-x6m"
-# SENTRY_AUTH_TOKEN="d477b94cfe375f5b4e4e88ac4fc15a8be8557652cea424710b6f7f19be4f0b3d"
-# SENTRY_URL="https://test-x6m.sentry.io/"
 
 # 帮助中心
-HELP_CENTER_URL="https://im-support.gz4399.com/"
-
-# 是否开启Sentry
-SENTRY_ENABLED='{{SENTRY_ENABLED}}'  
-REACT_APP_SENTRY_DSN='{{SENTRY_DSN}}'
-SENTRY_PROJECT='{{{ name }}}'
-SENTRY_ORG="sentry"
-SENTRY_AUTH_TOKEN="f13c66cd7a3629c8324cceb62fdb65aae1f337abbec4ebbadbe0a22447708994"
-SENTRY_URL="https://sentry.gz4399.com/"
+HELP_CENTER_URL="https://im-support.gz4399.com/"

package/dist/templates/config/env.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+
+/**
+ * 环境变量 Schema 定义
+ */
+const envSchema = z.object({
+  // Node 环境
+  NODE_ENV: z
+    .enum(["development", "test", "testDevelopment", "production"])
+    .default("development"),
+
+  // 应用配置
+  APP_NAME: z.string().min(1, "应用名称不能为空").default("app"),
+  APP_CNAME: z.string().default("应用"),
+  BASENAME: z.string().optional(),
+
+  // API 配置
+  API_PREFIX: z.string().default("/api"),
+  API_TIMEOUT: z
+    .string()
+    .transform(Number)
+    .pipe(z.number().positive())
+    .default(30000),
+
+  // Cookie 配置
+  COOKIE_NAME: z.string().default("access_token"),
+
+  // 其他配置
+  HELP_CENTER_URL: z.string().url().optional(),
+  OUTPUT_PATH: z.string().default("dist"),
+  PUBLIC_PATH: z.string().default("/"),
+});
+
+/**
+ * 安全解析环境变量（开发模式下使用默认值）
+ */
+function safeParseEnv() {
+  const result = envSchema.safeParse(process.env);
+
+  if (!result.success) {
+    if (process.env.NODE_ENV === "production") {
+      // 生产环境严格校验
+      console.error("❌ 环境变量验证失败:");
+      result.error.issues.forEach((err) => {
+        console.error(`  - ${err.path.join(".")}: ${err.message}`);
+      });
+      throw new Error("环境变量配置错误");
+    } else {
+      // 开发环境警告但不中断
+      console.warn("⚠️ 环境变量验证警告:");
+      result.error.issues.forEach((err) => {
+        console.warn(`  - ${err.path.join(".")}: ${err.message}`);
+      });
+    }
+  }
+
+  return result.success ? result.data : envSchema.parse({});
+}
+
+/**
+ * 导出类型安全的环境变量
+ */
+export const env = safeParseEnv();
+
+/**
+ * 环境变量类型
+ */
+export type Env = z.infer<typeof envSchema>;
+
+/**
+ * 工具函数：判断是否为开发环境
+ */
+export const isDev = env.NODE_ENV === "development";
+
+/**
+ * 工具函数：判断是否为生产环境
+ */
+export const isProd = env.NODE_ENV === "production";
+
+/**
+ * 工具函数：判断是否为测试环境
+ */
+export const isTest =
+  env.NODE_ENV === "test" || env.NODE_ENV === "testDevelopment";

package/dist/templates/config/jwt/index.ts

@@ -20,12 +20,12 @@ export default class jwt {
   }
 
   // 获取访问令牌
-  static getAccessToken(accessTokenKey: string) {
-    return Cookies.get(accessTokenKey);
+  static getAccessToken(accessTokenKey?: string) {
+    return Cookies.get(accessTokenKey ?? this.key);
   }
 
   // 清空访问令牌
-  static clearAccessToken(accessTokenKey: string) {
-    Cookies.remove(accessTokenKey);
+  static clearAccessToken(accessTokenKey?: string) {
+    Cookies.remove(accessTokenKey ?? this.key);
   }
 }

package/dist/templates/config/request/error-handler.ts

@@ -0,0 +1,67 @@
+import { message as antdMessage } from "antd";
+import type { AxiosError } from "axios";
+import type { RequestConfig, ApiResponse } from "./types";
+
+/**
+ * 错误处理器
+ */
+export class ErrorHandler {
+  /**
+   * 处理请求错误
+   */
+  handle(error: any, config?: RequestConfig): void {
+    const messageConfig = config?.message;
+
+    // 如果明确禁用错误提示
+    if (messageConfig?.showError === false) {
+      return;
+    }
+
+    const axiosError = error as AxiosError<ApiResponse>;
+    let errorMessage = messageConfig?.errorMessage;
+
+    // 如果没有自定义错误消息，使用默认逻辑
+    if (!errorMessage) {
+      if (axiosError.response) {
+        const { status, data } = axiosError.response;
+
+        // 优先使用后端返回的消息
+        errorMessage = data?.message;
+
+        // 如果后端没有返回消息，使用默认消息
+        if (!errorMessage) {
+          errorMessage = this.getDefaultErrorMessage(status);
+        }
+      } else if (axiosError.request) {
+        errorMessage = "网络错误，请检查您的网络连接";
+      } else {
+        errorMessage = axiosError.message || "请求失败";
+      }
+    }
+
+    // 显示错误提示
+    antdMessage.error(errorMessage);
+  }
+
+  /**
+   * 获取默认错误消息
+   */
+  private getDefaultErrorMessage(status: number): string {
+    const errorMessages: Record<number, string> = {
+      400: "请求参数错误",
+      401: "未授权，请重新登录",
+      403: "拒绝访问",
+      404: "请求的资源不存在",
+      405: "请求方法不允许",
+      408: "请求超时",
+      500: "服务器内部错误",
+      502: "网关错误",
+      503: "服务暂时不可用",
+      504: "网关超时",
+    };
+
+    return errorMessages[status] || `请求失败 (${status})`;
+  }
+}
+
+export const errorHandler = new ErrorHandler();

package/dist/templates/config/request/index.ts

@@ -1,174 +1,172 @@
-import jwt from "@config/jwt";
-import axios, {
-  type AxiosInstance,
-  type AxiosRequestConfig,
-  type AxiosResponse,
-} from "axios";
+import axios, { type AxiosInstance } from "axios";
 import qs from "qs";
-
-type Result<T> = {
-  code: number;
-  message: string;
-  data: T;
-  suppressErrorNotification?: boolean;
-};
-
-const baseURL = process.env.API_PREFIX;
-const timeout = process.env.API_TIMEOUT;
-const accessTokenKey = process.env.COOKIE_NAME;
-
-let flag = false; // 设置开关，保证一次只能请求一次刷新token,防止客户端多次操作，多次请求
-let subSequest: any[] = [];
-
-// 把过期请求添加在数组中
-function addRequest(request: () => any) {
-  subSequest.push(request);
-}
-
-// 重新调用过期请求列表
-function retryRequest() {
-  subSequest.forEach((request) => request());
-  subSequest = [];
-}
-
-function getRefreshToken(token: string) {
-  return fetch(`${baseURL}/dns/auth/login/token/refresh`, {
-    headers: {
-      authorization: token,
-    },
-  });
-}
-
-function redirectToLogin() {
-  // 记录当前的url，并且实现跳转
-  if (window.location.pathname === "/login") {
-    return;
-  }
-  jwt.clearAccessToken(accessTokenKey as string);
-  jwt.clearAccessToken("refresh_token");
-  const href = encodeURIComponent(window.location.href);
-  window.location.href = `${window.location.origin}/login?redirect=${href}`;
-}
-
-// 刷新token
-function refreshToken() {
-  if (!flag) {
-    flag = true;
-    // 获取刷新token
-    const r_tk = jwt.getAccessToken("refresh_token");
-    if (r_tk) {
-      // 判断刷新token是否过期
-      getRefreshToken(r_tk)
-        .then((v) => v.json())
-        .then((v) => {
-          flag = false;
-          if (!v?.data?.accessToken) {
-            redirectToLogin();
-            return;
-          }
-          jwt.setAccessToken({
-            token_type: v.data?.tokenType ?? "JWT",
-            access_token: v.data?.accessToken,
-            expires_at: v.data?.expires_at * 1000,
-          });
-          // 重新发送请求
-          retryRequest();
-        })
-        .catch(() => {
-          redirectToLogin();
-        });
-    } else {
-      redirectToLogin();
+import { env } from "@/config/env";
+import type { RequestConfig, ApiResponse, TokenManager } from "./types";
+import { tokenManager as defaultTokenManager } from "./token-manager";
+import {
+  errorHandler as defaultErrorHandler,
+  type ErrorHandler,
+} from "./error-handler";
+import {
+  setupRequestInterceptor,
+  setupResponseInterceptor,
+} from "./interceptors";
+
+/**
+ * 参数序列化器
+ */
+export function paramsSerializer(params: Record<string, any>): string {
+  const result: Record<string, any> = {};
+
+  Object.keys(params).forEach((key) => {
+    const value = params[key];
+    if (value === null || value === undefined) {
+      // 跳过 null 和 undefined
+      return;
     }
-  }
-}
-
-export function paramsSerializer(params) {
-  const result = {};
-  Object.keys(params).forEach((p) => {
-    const value = params[p];
     if (Array.isArray(value)) {
-      result[p] = value;
-    } else if (value === null || value === undefined) {
-      result[p] = value;
+      result[key] = value;
     } else if (typeof value === "object") {
-      result[p] = JSON.stringify(value);
+      result[key] = JSON.stringify(value);
     } else {
-      result[p] = value;
+      result[key] = value;
     }
   });
+
   return qs.stringify(result, { arrayFormat: "repeat", skipNulls: true });
 }
 
-// 导出Request类，可以用来自定义传递配置来创建实例
+/**
+ * Request 配置选项
+ */
+export interface RequestOptions {
+  baseURL?: string;
+  timeout?: number;
+  tokenManager?: TokenManager;
+  errorHandler?: ErrorHandler;
+  onUnauthorized?: () => void;
+}
+
+/**
+ * HTTP 请求类
+ */
 export class Request {
-  // axios 实例
   private instance: AxiosInstance;
-  // 基础配置，url和超时时间
-  private baseConfig: AxiosRequestConfig = {
-    baseURL: baseURL,
-    timeout: Number(timeout),
-    withCredentials: true,
-  };
-
-  constructor(config: AxiosRequestConfig) {
-    // 使用axios.create创建axios实例
-    this.instance = axios.create(Object.assign(this.baseConfig, config));
-
-    this.instance.interceptors.request.use(
-      (config: any) => {
-        // 一般会请求拦截里面加token，用于后端的验证
-        config.headers = config.headers || {};
-        config.headers.Authorization =
-          jwt.getAccessToken(accessTokenKey as string) || "";
-        return config;
-      },
-      (err: any) => {
-        return Promise.reject(err);
-      }
+  public tokenManager: TokenManager;
+  public errorHandler: ErrorHandler;
+
+  constructor(options: RequestOptions = {}) {
+    const {
+      baseURL = env.API_PREFIX,
+      timeout = env.API_TIMEOUT,
+      tokenManager = defaultTokenManager,
+      errorHandler = defaultErrorHandler,
+      onUnauthorized,
+    } = options;
+
+    this.tokenManager = tokenManager;
+    this.errorHandler = errorHandler;
+
+    // 创建 axios 实例
+    this.instance = axios.create({
+      baseURL,
+      timeout,
+      withCredentials: true,
+    });
+
+    // 设置拦截器
+    setupRequestInterceptor(this.instance, tokenManager);
+    setupResponseInterceptor(
+      this.instance,
+      tokenManager,
+      errorHandler,
+      onUnauthorized
     );
   }
 
-  // 定义请求方法
-  public request(config: AxiosRequestConfig): Promise<AxiosResponse> {
+  /**
+   * 通用请求方法
+   */
+  public request<T = any>(config: RequestConfig): Promise<ApiResponse<T>> {
     return this.instance.request(config);
   }
 
+  /**
+   * GET 请求
+   */
   public get<T = any>(
     url: string,
     params?: any,
-    config?: AxiosRequestConfig & { suppressErrorNotification?: boolean }
-  ): Promise<Result<T>> {
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
     return this.instance.get(url, {
       ...config,
-      params: params,
+      params,
       paramsSerializer,
     });
   }
 
+  /**
+   * POST 请求
+   */
   public post<T = any>(
     url: string,
     data?: any,
-    config?: AxiosRequestConfig & { suppressErrorNotification?: boolean }
-  ): Promise<Result<T>> {
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
     return this.instance.post(url, data, config);
   }
 
+  /**
+   * PUT 请求
+   */
   public put<T = any>(
     url: string,
     data?: any,
-    config?: AxiosRequestConfig & { suppressErrorNotification?: boolean }
-  ): Promise<Result<T>> {
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
     return this.instance.put(url, data, config);
   }
 
+  /**
+   * DELETE 请求
+   */
   public delete<T = any>(
     url: string,
-    config?: AxiosRequestConfig & { suppressErrorNotification?: boolean }
-  ): Promise<Result<T>> {
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
     return this.instance.delete(url, config);
   }
+
+  /**
+   * PATCH 请求
+   */
+  public patch<T = any>(
+    url: string,
+    data?: any,
+    config?: RequestConfig
+  ): Promise<ApiResponse<T>> {
+    return this.instance.patch(url, data, config);
+  }
+
+  /**
+   * 获取 axios 实例（用于高级用法）
+   */
+  public getAxiosInstance(): AxiosInstance {
+    return this.instance;
+  }
 }
 
-// 默认导出Request实例
-export default new Request({});
+// 导出默认实例
+export const request = new Request();
+
+// 导出类型
+export type {
+  RequestConfig,
+  ApiResponse,
+  MessageConfig,
+  TokenManager,
+} from "./types";
+
+// 默认导出
+export default request;

package/dist/templates/config/request/interceptors.ts

@@ -0,0 +1,118 @@
+import type {
+  AxiosInstance,
+  InternalAxiosRequestConfig,
+  AxiosResponse,
+} from "axios";
+import { message as antdMessage } from "antd";
+import type { TokenManager, RequestConfig, ApiResponse } from "./types";
+import type { ErrorHandler } from "./error-handler";
+
+/**
+ * 设置请求拦截器
+ */
+export function setupRequestInterceptor(
+  instance: AxiosInstance,
+  tokenManager: TokenManager
+): void {
+  instance.interceptors.request.use(
+    (config: InternalAxiosRequestConfig) => {
+      const requestConfig = config as RequestConfig;
+
+      // 添加 Token（如果需要认证，默认为 true）
+      if (requestConfig.requireAuth !== false) {
+        const token = tokenManager.getToken();
+        if (token && config.headers) {
+          config.headers.Authorization = token;
+        }
+      }
+
+      // 添加自定义 Headers
+      if (requestConfig.customHeaders && config.headers) {
+        Object.entries(requestConfig.customHeaders).forEach(([key, value]) => {
+          config.headers[key] = value;
+        });
+      }
+
+      return config;
+    },
+    (error) => {
+      return Promise.reject(error);
+    }
+  );
+}
+
+/**
+ * 设置响应拦截器
+ */
+export function setupResponseInterceptor(
+  instance: AxiosInstance,
+  tokenManager: TokenManager,
+  errorHandler: ErrorHandler,
+  onUnauthorized?: () => void
+): void {
+  instance.interceptors.response.use(
+    (response: AxiosResponse<ApiResponse>) => {
+      const config = response.config as RequestConfig;
+      const messageConfig = config.message;
+
+      const { code, message: msg, data } = response.data;
+
+      // 业务成功（根据实际后端约定调整）
+      if (code === 0 || code === 200) {
+        // 显示成功消息
+        if (messageConfig?.showSuccess) {
+          const successMsg = messageConfig.successMessage || msg || "操作成功";
+          antdMessage.success(successMsg);
+        }
+
+        // 直接返回 data，简化调用
+        return response.data;
+      }
+
+      // 业务失败
+      const errorMsg = messageConfig?.errorMessage || msg || "操作失败";
+
+      if (messageConfig?.showError !== false) {
+        antdMessage.error(errorMsg);
+      }
+
+      return Promise.reject(new Error(errorMsg));
+    },
+    async (error) => {
+      const config = error.config as RequestConfig;
+
+      // 401 未授权
+      if (error.response?.status === 401) {
+        tokenManager.clearToken();
+
+        // 执行自定义的未授权回调
+        if (onUnauthorized) {
+          onUnauthorized();
+        } else {
+          // 默认跳转到登录页
+          redirectToLogin();
+        }
+
+        return Promise.reject(error);
+      }
+
+      // 其他错误统一处理
+      errorHandler.handle(error, config);
+
+      return Promise.reject(error);
+    }
+  );
+}
+
+/**
+ * 重定向到登录页
+ */
+function redirectToLogin(): void {
+  if (typeof window === "undefined") return;
+
+  const currentPath = window.location.pathname;
+  if (currentPath === "/login") return;
+
+  const redirectUrl = encodeURIComponent(window.location.href);
+  window.location.href = `${window.location.origin}/login?redirect=${redirectUrl}`;
+}

package/dist/templates/config/request/token-manager.ts

@@ -0,0 +1,23 @@
+import jwt from "@config/jwt";
+import type { TokenManager as TokenManagerType } from "./types";
+/**
+ * Token 刷新管理器
+ * 使用 Promise 避免并发刷新问题
+ */
+export class TokenManager implements TokenManagerType {
+  getToken(token?: string): string | undefined {
+    return jwt.getAccessToken(token);
+  }
+  setToken(token: {
+    token_type: any;
+    access_token: any;
+    expires_at: number;
+  }): void {
+    jwt.setAccessToken(token);
+  }
+  clearToken(token?: string): void {
+    jwt.clearAccessToken(token);
+  }
+}
+
+export const tokenManager = new TokenManager();