generator-mico-cli 0.1.18

package/generators/micro-react/templates/apps/layout/src/common/request/interceptors.ts

@@ -0,0 +1,186 @@
+/**
+ * 请求/响应拦截器管理
+ */
+
+import { getFromStorage, safeParseJSON } from '@/common/helpers';
+import { Message } from '@arco-design/web-react';
+import { maybePersistTokens } from '../auth/cs-auth-manager';
+import { UID } from '../auth/type';
+import { getClientOptions, resolveAuthToken } from './config';
+import type {
+  RequestContext,
+  RequestInterceptor,
+  ResponseInterceptor,
+} from './types';
+
+const APP_INFO_KEY = 'appInfo';
+const IS_SUPERUSER_KEY = 'is_superuser';
+const GROUPS_KEY = 'groups';
+
+const requestInterceptors: Array<{ id: number; handler: RequestInterceptor }> =
+  [];
+const responseInterceptors: Array<{
+  id: number;
+  handler: ResponseInterceptor;
+}> = [];
+
+let interceptorSeed = 0;
+
+export const addRequestInterceptor = (
+  handler: RequestInterceptor,
+): (() => void) => {
+  const id = ++interceptorSeed;
+  requestInterceptors.push({ id, handler });
+  return () => {
+    const index = requestInterceptors.findIndex((item) => item.id === id);
+    if (index >= 0) {
+      requestInterceptors.splice(index, 1);
+    }
+  };
+};
+
+export const addResponseInterceptor = (
+  handler: ResponseInterceptor,
+): (() => void) => {
+  const id = ++interceptorSeed;
+  responseInterceptors.push({ id, handler });
+  return () => {
+    const index = responseInterceptors.findIndex((item) => item.id === id);
+    if (index >= 0) {
+      responseInterceptors.splice(index, 1);
+    }
+  };
+};
+
+export const runRequestInterceptors = async (
+  ctx: RequestContext,
+): Promise<RequestContext> => {
+  let current = ctx;
+  for (const { handler } of requestInterceptors) {
+    current = await handler(current);
+  }
+  return current;
+};
+
+export const runResponseInterceptors = async <T>(
+  response: T,
+  ctx: RequestContext,
+): Promise<T> => {
+  let current = response;
+  for (const { handler } of responseInterceptors) {
+    current = await handler(current, ctx);
+  }
+  return current;
+};
+
+/**
+ * 构建默认请求头
+ */
+export const buildDefaultHeaders = (): Record<string, string> => {
+  const headers: Record<string, string> = {};
+  const clientOptions = getClientOptions();
+  const appId = clientOptions.appId;
+
+  if (appId) {
+    headers['custom-header-appid'] = appId;
+    headers['X-Biz-Code'] = appId;
+  }
+
+  const appInfo = safeParseJSON<{ name?: string }>(
+    getFromStorage(APP_INFO_KEY),
+  );
+  if (appInfo?.name) {
+    headers.app = appInfo.name;
+  }
+
+  const isSuperuser = getFromStorage(IS_SUPERUSER_KEY);
+  if (isSuperuser) {
+    headers['is-superuser'] = isSuperuser;
+  }
+
+  const groups = getFromStorage(GROUPS_KEY);
+  if (groups) {
+    headers.groups = encodeURIComponent(groups);
+  }
+
+  const authToken = resolveAuthToken();
+  if (authToken) {
+    headers.authtoken = authToken;
+  }
+
+  const uid = getFromStorage(UID);
+  if (uid) {
+    headers['X-Uid'] = uid;
+  }
+
+  return headers;
+};
+
+/**
+ * 初始化默认拦截器
+ */
+export const initDefaultInterceptors = (
+  isFetchingToken: () => boolean,
+  addToPendingQueue: (
+    ctx: RequestContext,
+    resolve: (ctx: RequestContext) => void,
+    reject: (error: Error) => void,
+  ) => void,
+): void => {
+  // 在 fetchingToken 为 true 时将请求放入等待队列
+  addRequestInterceptor(async (ctx) => {
+    if (isFetchingToken()) {
+      return new Promise<RequestContext>((resolve, reject) => {
+        addToPendingQueue(ctx, resolve, reject);
+      });
+    }
+    return ctx;
+  });
+
+  // 添加默认请求头
+  addRequestInterceptor(async (ctx) => {
+    const defaultHeaders = buildDefaultHeaders();
+    return {
+      url: ctx.url,
+      options: {
+        ...ctx.options,
+        headers: {
+          ...defaultHeaders,
+          ...(ctx.options.headers || {}),
+        },
+      },
+    };
+  });
+
+  // 处理响应中的错误提示
+  addResponseInterceptor(async (data: unknown) => {
+    if (data && typeof data === 'object' && 'success' in data) {
+      const typedData = data as { success: boolean; errorMessage?: string };
+      if (typedData.success === false) {
+        Message.error(typedData.errorMessage ?? '请求失败！');
+      }
+    }
+    maybePersistTokens(data as Parameters<typeof maybePersistTokens>[0]);
+    return data;
+  });
+
+  // 处理业务错误码
+  addResponseInterceptor(async (data: unknown) => {
+    if (data && typeof data === 'object' && 'result' in data) {
+      const typedData = data as { result?: { code?: number; desc?: string } };
+      if (typedData.result) {
+        const { code, desc } = typedData.result;
+        if (typeof code === 'number' && code !== 0) {
+          const error = new Error(desc || `请求失败 (${code})`) as Error & {
+            code: number;
+            response: unknown;
+          };
+          error.code = code;
+          error.response = data;
+          throw error;
+        }
+      }
+    }
+    return data;
+  });
+};

package/generators/micro-react/templates/apps/layout/src/common/request/sso.ts

@@ -0,0 +1,132 @@
+/**
+ * SSO 单点登录逻辑
+ */
+
+import { request as rawRequest } from '@umijs/max';
+import {
+  maybePersistTokens,
+  setStoredAuthToken,
+} from '../auth/cs-auth-manager';
+import {
+  getTicketParam,
+  resolveAuthToken,
+  resolveExternalLoginPath,
+  resolveLoginEndpoint,
+} from './config';
+import { buildDefaultHeaders } from './interceptors';
+import {
+  isFetchingToken,
+  processPendingRequests,
+  rejectPendingRequests,
+  setFetchingToken,
+} from './token-refresh';
+import { removeParamFromUrl } from './url-resolver';
+
+let ticketPromise: Promise<void> | null = null;
+
+/**
+ * 处理认证失败后的重定向
+ */
+export const handleAuthFailureRedirect = (): void => {
+  if (typeof window === 'undefined') return;
+
+  // 从 URL 中获取当前 redirect 登录的次数
+  const currentUrl = new URL(window.location.href);
+  const redirectCountParam = currentUrl.searchParams.get('redirect_count');
+  const redirectCount = redirectCountParam
+    ? parseInt(redirectCountParam, 10)
+    : 0;
+
+  // 如果 redirect 次数小于 1 次，则执行 redirect 跳转登录
+  if (redirectCount < 1) {
+    const externalLoginPath = resolveExternalLoginPath();
+    console.log('handleAuthFailureRedirect', externalLoginPath);
+
+    // 构建回跳地址
+    const redirectUrl = new URL(window.location.href);
+    redirectUrl.searchParams.delete('redirect_count');
+    redirectUrl.searchParams.set('redirect_count', '1');
+    const serviceUrl = redirectUrl.toString();
+
+    window.location.href = `${
+      externalLoginPath ?? '/login'
+    }?service=${encodeURIComponent(serviceUrl)}`;
+  } else {
+    console.warn('认证失败，但已达到最大重定向次数，停止重定向');
+  }
+};
+
+/**
+ * 确保 SSO 会话有效
+ */
+export const ensureSsoSession = async (): Promise<void> => {
+  if (typeof window === 'undefined') return;
+
+  if (isFetchingToken()) return;
+
+  const ticketParam = getTicketParam();
+  const ticket = new URLSearchParams(window.location.search).get(ticketParam);
+  if (!ticket) return;
+
+  if (!ticketPromise) {
+    ticketPromise = (async () => {
+      const endpoint = resolveLoginEndpoint();
+      const hasQuery = endpoint.includes('?');
+      const joiner = hasQuery ? '&' : '?';
+      const loginUrl = `${endpoint}${joiner}${ticketParam}=${encodeURIComponent(
+        ticket,
+      )}`;
+
+      setFetchingToken(true);
+
+      try {
+        const result = await rawRequest<unknown>(loginUrl, {
+          method: 'GET',
+          headers: buildDefaultHeaders(),
+          responseInterceptors: [
+            (response) => {
+              const typedResponse = response as {
+                headers?: { authtoken?: string };
+              };
+              if (typedResponse.headers?.authtoken) {
+                setStoredAuthToken(typedResponse.headers.authtoken);
+              }
+              return response;
+            },
+          ],
+        });
+
+        maybePersistTokens(result as Parameters<typeof maybePersistTokens>[0]);
+        setFetchingToken(false);
+
+        if (resolveAuthToken()) {
+          // SSO 认证成功，删除 URL 中的 redirect_count 参数
+          if (typeof window !== 'undefined') {
+            const current = new URL(window.location.href);
+            current.searchParams.delete('redirect_count');
+            const nextUrl = `${current.pathname}${
+              current.search ? `?${current.searchParams}` : ''
+            }${current.hash}`;
+            window.history.replaceState(null, '', nextUrl);
+          }
+
+          processPendingRequests();
+        } else {
+          throw new Error('SSO 认证失败');
+        }
+      } catch (error) {
+        console.error('SSO ticket exchange failed', error);
+        setFetchingToken(false);
+
+        rejectPendingRequests(
+          error instanceof Error ? error : new Error('SSO 认证失败'),
+        );
+      } finally {
+        removeParamFromUrl(ticketParam);
+        ticketPromise = null;
+      }
+    })();
+  }
+
+  await ticketPromise;
+};

package/generators/micro-react/templates/apps/layout/src/common/request/token-refresh.ts

@@ -0,0 +1,136 @@
+/**
+ * Token 刷新逻辑
+ */
+
+import { request as rawRequest } from '@umijs/max';
+import {
+  getStoredRefreshToken,
+  maybePersistTokens,
+  setStoredAuthToken,
+  setStoredRefreshToken,
+} from '../auth/cs-auth-manager';
+import { resolveRefreshEndpoint } from './config';
+import type { PendingRequest, RequestContext } from './types';
+
+// 当前是否在请求用ticket换取token
+let fetchingToken = false;
+
+// 等待队列：存储正在获取认证令牌时被拦截的请求
+const pendingRequestsQueue: PendingRequest[] = [];
+
+// Token 刷新 Promise 缓存
+const AUTH_REFRESH_PROMISE: { current?: Promise<string | null> } = {};
+
+export const isFetchingToken = (): boolean => fetchingToken;
+
+export const setFetchingToken = (value: boolean): void => {
+  fetchingToken = value;
+};
+
+export const addToPendingQueue = (
+  ctx: RequestContext,
+  resolve: (ctx: RequestContext) => void,
+  reject: (error: Error) => void,
+): void => {
+  pendingRequestsQueue.push({ ctx, resolve, reject });
+};
+
+/**
+ * 执行等待队列中的请求
+ */
+export const processPendingRequests = (): void => {
+  const queue = [...pendingRequestsQueue];
+  pendingRequestsQueue.length = 0;
+
+  queue.forEach(({ ctx, resolve }) => {
+    resolve(ctx);
+  });
+};
+
+/**
+ * 拒绝等待队列中的请求
+ */
+export const rejectPendingRequests = (error: Error): void => {
+  const queue = [...pendingRequestsQueue];
+  pendingRequestsQueue.length = 0;
+
+  queue.forEach(({ reject }) => {
+    reject(error);
+  });
+};
+
+/**
+ * 刷新认证 Token
+ */
+export const refreshAuthToken = async (): Promise<string | null> => {
+  if (fetchingToken) {
+    return null;
+  }
+
+  const refreshToken = getStoredRefreshToken();
+  if (!refreshToken) {
+    return null;
+  }
+
+  const endpoint = resolveRefreshEndpoint();
+  fetchingToken = true;
+
+  try {
+    const result = await rawRequest<{
+      code?: number;
+      data?: { access?: string };
+    }>(endpoint, {
+      method: 'POST',
+      data: { refresh: refreshToken },
+    });
+
+    maybePersistTokens(result);
+    const success = result?.code === 200;
+    const token = success ? result?.data?.access ?? null : null;
+    fetchingToken = false;
+
+    if (token) {
+      processPendingRequests();
+    } else {
+      rejectPendingRequests(new Error('获取认证令牌失败'));
+    }
+
+    return typeof token === 'string' ? token : null;
+  } catch (err) {
+    console.error('refresh auth token failed', err);
+    fetchingToken = false;
+    setStoredAuthToken(null);
+    setStoredRefreshToken(null);
+
+    rejectPendingRequests(
+      err instanceof Error ? err : new Error('获取认证令牌失败'),
+    );
+
+    return null;
+  }
+};
+
+/**
+ * 获取刷新 Token 的 Promise（防止重复请求）
+ */
+export const getRefreshPromise = (): Promise<string | null> => {
+  if (!AUTH_REFRESH_PROMISE.current) {
+    console.info('try to refresh auth token');
+    AUTH_REFRESH_PROMISE.current = refreshAuthToken().finally(() => {
+      AUTH_REFRESH_PROMISE.current = undefined;
+    });
+  }
+  return AUTH_REFRESH_PROMISE.current;
+};
+
+/**
+ * 判断是否应该尝试刷新 Token
+ */
+export const shouldAttemptRefresh = (error: unknown): boolean => {
+  if (error && typeof error === 'object' && 'response' in error) {
+    const typedError = error as { response?: { status?: number } };
+    const status = typedError.response?.status;
+    return status === 401 || status === 403;
+  }
+  return false;
+};

package/generators/micro-react/templates/apps/layout/src/common/request/types.ts

@@ -0,0 +1,44 @@
+/**
+ * 请求模块类型定义
+ */
+
+export type UnifiedRequestOptions = {
+  headers?: Record<string, string>;
+  proxySuffix?: string;
+  useCache?: boolean;
+  validateCache?: (url: string, options: UnifiedRequestOptions) => boolean;
+  [key: string]: unknown;
+};
+
+export type RequestContext = {
+  url: string;
+  options: UnifiedRequestOptions;
+};
+
+export type RequestInterceptor = (
+  ctx: RequestContext,
+) => Promise<RequestContext> | RequestContext;
+
+export type ResponseInterceptor<T = unknown> = (
+  response: T,
+  ctx: RequestContext,
+) => Promise<T> | T;
+
+export type TokenResolver = () => string | undefined;
+
+export interface RequestClientOptions {
+  appId: string;
+  ticketParam: string;
+  loginEndpoint: string;
+  refreshEndpoint: string;
+  externalLoginPath: string;
+  logoutPath: string;
+  apiBaseUrl: string;
+  proxySuffix: string;
+}
+
+export interface PendingRequest {
+  ctx: RequestContext;
+  resolve: (ctx: RequestContext) => void;
+  reject: (error: Error) => void;
+}

package/generators/micro-react/templates/apps/layout/src/common/request/url-resolver.ts

@@ -0,0 +1,75 @@
+/**
+ * URL 解析与拼接工具
+ */
+
+import {
+  resolveProxySuffix as getProxySuffix,
+  resolveApiBaseUrl,
+} from './config';
+import type { UnifiedRequestOptions } from './types';
+
+/**
+ * 拼接 baseUrl 和路径，自动处理多余的斜杠
+ */
+export const joinBaseUrl = (baseUrl: string, url: string): string => {
+  if (
+    url.startsWith('http://') ||
+    url.startsWith('https://') ||
+    url.startsWith('//')
+  ) {
+    return url;
+  }
+  const normalizedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+  const normalizedPath = url.startsWith('/') ? url : `/${url}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+
+/**
+ * 拼接代理路径和 API 路径，避免双斜杠
+ */
+export const joinProxyAndPath = (proxySuffix: string, path: string): string => {
+  if (
+    path.startsWith('http://') ||
+    path.startsWith('https://') ||
+    path.startsWith('//')
+  ) {
+    // 绝对 URL 直接透传，不拼接代理前缀
+    return path;
+  }
+  const normalizedProxy = proxySuffix.endsWith('/')
+    ? proxySuffix.slice(0, -1)
+    : proxySuffix;
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  return `${normalizedProxy}${normalizedPath}`;
+};
+
+/**
+ * 解析最终请求 URL
+ */
+export const resolveRequestUrl = (
+  url: string,
+  options?: UnifiedRequestOptions,
+  isAlwaysRemote = false,
+): string => {
+  const useRelative = process.env.NODE_ENV !== 'production' && !isAlwaysRemote;
+  const proxySuffix = getProxySuffix(options?.proxySuffix);
+
+  if (useRelative) {
+    return url;
+  }
+
+  return joinBaseUrl(resolveApiBaseUrl(), joinProxyAndPath(proxySuffix, url));
+};
+
+/**
+ * 从 URL 中移除指定参数
+ */
+export const removeParamFromUrl = (param: string): void => {
+  if (typeof window === 'undefined') return;
+  const current = new URL(window.location.href);
+  current.searchParams.delete(param);
+  const nextUrl = `${current.pathname}${
+    current.search ? `?${current.searchParams}` : ''
+  }${current.hash}`;
+  window.history.replaceState(null, '', nextUrl);
+};

package/generators/micro-react/templates/apps/layout/src/common/theme.ts

@@ -0,0 +1,107 @@
+/**
+ * 主题管理工具
+ * 支持在 localStorage 中存储主题状态，并在页面加载时动态加载对应的主题
+ */
+
+import { THEME } from './constants';
+
+export type ThemeMode = 'light' | 'dark';
+
+/**
+ * 获取当前主题
+ */
+export function getTheme(): ThemeMode {
+  if (typeof window === 'undefined') {
+    return THEME.DEFAULT;
+  }
+  try {
+    const theme = localStorage.getItem(THEME.STORAGE_KEY) as ThemeMode | null;
+    if (theme === 'light' || theme === 'dark') {
+      return theme;
+    }
+  } catch (error) {
+    console.error('获取主题失败:', error);
+  }
+  return THEME.DEFAULT;
+}
+
+/**
+ * 设置主题
+ */
+export function setTheme(theme: ThemeMode): void {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  try {
+    localStorage.setItem(THEME.STORAGE_KEY, theme);
+    applyTheme(theme);
+    // 触发自定义事件，通知其他组件主题已变化
+    window.dispatchEvent(new CustomEvent('themechange', { detail: theme }));
+  } catch (error) {
+    console.error('设置主题失败:', error);
+  }
+}
+
+/**
+ * 应用主题到 DOM
+ * 通过切换 body 的 data-theme 和 arco-theme 属性来应用不同的主题
+ */
+export function applyTheme(theme: ThemeMode): void {
+  if (typeof document === 'undefined') return;
+
+  if (theme === 'dark') {
+    document.body.setAttribute('arco-theme', 'dark');
+    document.body.setAttribute('data-theme', 'dark');
+  } else {
+    document.body.removeAttribute('arco-theme');
+    document.body.setAttribute('data-theme', 'normal');
+  }
+}
+
+/**
+ * 获取系统主题偏好
+ */
+export function getSystemTheme(): ThemeMode {
+  if (typeof window === 'undefined') return THEME.DEFAULT;
+  return window.matchMedia('(prefers-color-scheme: dark)').matches
+    ? 'dark'
+    : 'light';
+}
+
+/**
+ * 获取存储的主题或系统主题
+ */
+export function getStoredTheme(): ThemeMode {
+  if (typeof window === 'undefined') return THEME.DEFAULT;
+  const stored = localStorage.getItem(THEME.STORAGE_KEY);
+  if (stored === 'light' || stored === 'dark') {
+    return stored;
+  }
+  return getSystemTheme();
+}
+
+/**
+ * 初始化主题
+ * 在页面加载时调用，根据 localStorage 中的主题状态加载对应的主题
+ * 注意：这个函数需要在页面最早期调用，在 React 渲染之前
+ */
+export function initTheme(): void {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  const theme = getStoredTheme();
+
+  // 立即设置 data-theme 属性，避免闪烁
+  if (document.body) {
+    applyTheme(theme);
+  } else {
+    // 如果 body 还没有加载，等待 DOMContentLoaded
+    document.addEventListener('DOMContentLoaded', () => {
+      applyTheme(getStoredTheme());
+    });
+  }
+}
+
+// 导出常量供外部使用
+export { THEME };

package/generators/micro-react/templates/apps/layout/src/common/types.ts

@@ -0,0 +1,7 @@
+/**
+ * 获取对象类型的所有值的联合类型
+ * @example
+ * type User = { name: string; age: number };
+ * type UserValue = GetValueType<User>; // string | number
+ */
+export type GetValueType<T> = T[keyof T];

package/generators/micro-react/templates/apps/layout/src/common/upload/index.ts

@@ -0,0 +1,2 @@
+export * from './oss';
+export * from './types';