generator-mico-cli 0.1.18

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

@@ -0,0 +1,45 @@
+/**
+ * 日志工具
+ * 仅在开发环境下输出日志，生产环境自动静默
+ *
+ * 使用 bind 保持原始调用位置，避免错误栈指向 logger 内部
+ */
+
+const isDev = process.env.NODE_ENV === 'development';
+
+// 空操作函数（生产环境使用）
+const noop = (): void => {};
+
+/**
+ * 创建带前缀的日志函数
+ * 使用 bind 绑定前缀，保持控制台显示正确的调用位置
+ */
+const createLogger = (prefix: string) => {
+  if (!isDev) {
+    // 生产环境返回空操作
+    return {
+      log: noop,
+      info: noop,
+      warn: noop,
+      error: noop,
+    };
+  }
+
+  const formattedPrefix = `[${prefix}]`;
+
+  return {
+    log: console.log.bind(console, formattedPrefix),
+    info: console.info.bind(console, formattedPrefix),
+    warn: console.warn.bind(console, formattedPrefix),
+    error: console.error.bind(console, formattedPrefix),
+  };
+};
+
+// 预定义的日志实例
+export const layoutLogger = createLogger('Layout');
+export const microAppLogger = createLogger('MicroAppLoader');
+export const authLogger = createLogger('Auth');
+export const requestLogger = createLogger('Request');
+
+// 导出创建器供自定义使用
+export { createLogger };

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

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

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

@@ -0,0 +1,143 @@
+import type { MenuItem, ParsedMenuItem, ParsedRoute } from './types';
+
+/**
+ * 获取 window 上挂载的菜单数据
+ */
+export const getWindowMenus = (): MenuItem[] => {
+  return window.__MICO_MENUS__ || [];
+};
+
+/**
+ * 判断页面的加载类型
+ * 有 htmlUrl 或 jsUrls 时使用 qiankun 微应用加载
+ */
+const getLoadType = (page: MenuItem['page']): 'internal' | 'microapp' => {
+  if (!page) return 'internal';
+
+  // 有 htmlUrl 或 jsUrls 使用 qiankun 微应用加载
+  if (page.htmlUrl || (page.jsUrls && page.jsUrls.length > 0)) {
+    return 'microapp';
+  }
+
+  // 否则使用内部路由
+  return 'internal';
+};
+
+/**
+ * 获取微应用入口 URL
+ * 优先使用 htmlUrl，其次使用 jsUrls[0]
+ */
+const getEntry = (page: MenuItem['page']): string | undefined => {
+  if (!page) return undefined;
+  return page.htmlUrl || page.jsUrls?.[0] || undefined;
+};
+
+/**
+ * 递归提取所有路由配置
+ */
+export const extractRoutes = (
+  items: MenuItem[],
+  routes: ParsedRoute[] = [],
+): ParsedRoute[] => {
+  for (const item of items) {
+    if (!item.enabled) continue;
+
+    if (item.type === 'page' && item.page && item.page.enabled) {
+      const loadType = getLoadType(item.page);
+      routes.push({
+        path: item.page.route,
+        name: item.name,
+        icon: item.icon,
+        loadType,
+        entry: getEntry(item.page),
+        pageConfig: item.page,
+      });
+    }
+
+    if (item.children && item.children.length > 0) {
+      extractRoutes(item.children, routes);
+    }
+  }
+
+  return routes;
+};
+
+/**
+ * 将菜单数据转换为菜单组件需要的格式
+ */
+export const parseMenuItems = (items: MenuItem[]): ParsedMenuItem[] => {
+  return items
+    .filter((item) => item.enabled)
+    .sort((a, b) => a.sortOrder - b.sortOrder)
+    .map((item) => {
+      const parsed: ParsedMenuItem = {
+        key: String(item.id),
+        label: item.name,
+        icon: item.icon,
+        type: item.type,
+      };
+
+      if (item.type === 'link' && item.path) {
+        parsed.path = item.path;
+      } else if (item.type === 'page' && item.page) {
+        parsed.path = item.page.route;
+      }
+
+      if (item.children && item.children.length > 0) {
+        parsed.children = parseMenuItems(item.children);
+      }
+
+      return parsed;
+    });
+};
+
+/**
+ * 根据路径查找对应的路由配置
+ */
+export const findRouteByPath = (
+  routes: ParsedRoute[],
+  pathname: string,
+): ParsedRoute | undefined => {
+  return routes.find((route) => {
+    // 处理通配符路由 /test/*
+    if (route.path.endsWith('/*')) {
+      const basePath = route.path.slice(0, -2);
+      return pathname.startsWith(basePath);
+    }
+    // 精确匹配
+    return route.path === pathname;
+  });
+};
+
+/**
+ * 根据路径查找对应的菜单项 key
+ */
+export const findMenuKeyByPath = (
+  items: ParsedMenuItem[],
+  pathname: string,
+  parentKeys: string[] = [],
+): { key: string; openKeys: string[] } | null => {
+  for (const item of items) {
+    if (item.path) {
+      // 处理通配符路由
+      if (item.path.endsWith('/*')) {
+        const basePath = item.path.slice(0, -2);
+        if (pathname.startsWith(basePath)) {
+          return { key: item.key, openKeys: parentKeys };
+        }
+      } else if (item.path === pathname) {
+        return { key: item.key, openKeys: parentKeys };
+      }
+    }
+
+    if (item.children && item.children.length > 0) {
+      const result = findMenuKeyByPath(item.children, pathname, [
+        ...parentKeys,
+        item.key,
+      ]);
+      if (result) return result;
+    }
+  }
+
+  return null;
+};

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

@@ -0,0 +1,92 @@
+/**
+ * 页面配置 - 从统一中台获取
+ */
+export interface PageConfig {
+  id: number;
+  name: string;
+  /** 路由路径 */
+  route: string;
+  enabled: boolean;
+  /** 微应用 HTML 入口 URL (用于 qiankun 加载) */
+  htmlUrl: string | null;
+  /** 微应用 JS 入口 URL 列表 */
+  jsUrls: string[];
+  /** 微应用 CSS URL 列表 */
+  cssUrls: string[];
+}
+
+/**
+ * 菜单项类型
+ */
+export type MenuItemType = 'group' | 'page' | 'link';
+
+/**
+ * 菜单项配置 - 从统一中台获取
+ */
+export interface MenuItem {
+  id: number;
+  name: string;
+  type: MenuItemType;
+  /** 路由路径或外链地址 */
+  path: string | null;
+  /** 图标名称 */
+  icon: string;
+  enabled: boolean;
+  sortOrder: number;
+  pageId: number | null;
+  /** 页面配置（type=page 时存在） */
+  page: PageConfig | null;
+  children: MenuItem[];
+}
+
+/**
+ * 解析后的路由配置
+ */
+export interface ParsedRoute {
+  path: string;
+  /** 菜单显示名称 */
+  name: string;
+  icon: string;
+  /** 加载类型: internal(内部路由) | microapp(qiankun微应用) */
+  loadType: 'internal' | 'microapp';
+  /** 微应用入口 URL (htmlUrl 或 jsUrls[0]) */
+  entry?: string;
+  /** 原始页面配置 */
+  pageConfig?: PageConfig;
+}
+
+/**
+ * 解析后的菜单配置（用于渲染菜单组件）
+ */
+export interface ParsedMenuItem {
+  key: string;
+  label: string;
+  icon: string;
+  type: MenuItemType;
+  path?: string;
+  children?: ParsedMenuItem[];
+}
+
+/**
+ * 主应用传递给子应用的 Props
+ */
+export interface MicroAppProps {
+  /** 主应用标识 */
+  mainApp: '<%= projectName %>';
+  /** 共享的 request 实例，子应用可直接使用 */
+  request: <T = any>(url: string, options?: any) => Promise<T>;
+}
+
+/**
+ * Window 上挂载的菜单数据
+ */
+declare global {
+  interface Window {
+    __MICO_MENUS__?: MenuItem[];
+    __MICO_CONFIG__?: {
+      appName?: string;
+      apiBaseUrl?: string;
+      [key: string]: unknown;
+    };
+  }
+}

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

@@ -0,0 +1,73 @@
+/**
+ * 请求客户端配置管理
+ */
+
+import { getStoredAuthToken } from '../auth/cs-auth-manager';
+import type { RequestClientOptions, TokenResolver } from './types';
+
+const defaultClientOptions: RequestClientOptions = {
+  appId: process.env.APP_ID ?? '',
+  ticketParam: 'ticket',
+  logoutPath: '/logout',
+  apiBaseUrl: process.env.API_BASE_URL ?? '',
+  proxySuffix: process.env.PROXY_SUFFIX ?? '',
+  loginEndpoint: process.env.LOGIN_ENDPOINT ?? '',
+  refreshEndpoint: process.env.REFRESH_ENDPOINT ?? '',
+  externalLoginPath: process.env.EXTERNAL_LOGIN_PATH ?? '',
+};
+
+let clientOptions: RequestClientOptions = { ...defaultClientOptions };
+
+let customAuthResolver: TokenResolver | undefined;
+
+export const setAuthTokenResolver = (resolver: TokenResolver): void => {
+  customAuthResolver = resolver;
+};
+
+export const resolveAuthToken = (): string | undefined => {
+  if (customAuthResolver) {
+    return customAuthResolver();
+  }
+  return getStoredAuthToken();
+};
+
+export const configureRequestClient = (
+  overrides: Partial<RequestClientOptions>,
+): void => {
+  clientOptions = { ...clientOptions, ...overrides };
+};
+
+export const getClientOptions = (): RequestClientOptions => ({
+  ...clientOptions,
+});
+
+/** 解析 API 基础地址 */
+export const resolveApiBaseUrl = (): string => {
+  return clientOptions.apiBaseUrl;
+};
+
+/** 解析登录端点 */
+export const resolveLoginEndpoint = (): string => {
+  return clientOptions.loginEndpoint;
+};
+
+/** 解析刷新令牌端点 */
+export const resolveRefreshEndpoint = (): string => {
+  return clientOptions.refreshEndpoint;
+};
+
+/** 解析外部登录路径 */
+export const resolveExternalLoginPath = (): string => {
+  return clientOptions.externalLoginPath;
+};
+
+/** 获取 ticket 参数名 */
+export const getTicketParam = (): string => {
+  return clientOptions.ticketParam;
+};
+
+/** 解析代理路径后缀 */
+export const resolveProxySuffix = (proxySuffix?: string): string => {
+  if (proxySuffix) return proxySuffix;
+  return clientOptions.proxySuffix;
+};

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

@@ -0,0 +1,188 @@
+/**
+ * 统一请求模块
+ *
+ * 职责：
+ * - 提供统一的 request 函数
+ * - 导出配置和拦截器相关方法
+ *
+ * 模块拆分：
+ * - types.ts: 类型定义
+ * - config.ts: 配置管理
+ * - interceptors.ts: 拦截器管理
+ * - url-resolver.ts: URL 解析
+ * - token-refresh.ts: Token 刷新逻辑
+ * - sso.ts: SSO 认证逻辑
+ */
+
+import { request as rawRequest } from '@umijs/max';
+import { setStoredAuthToken } from '../auth/cs-auth-manager';
+import { ROUTES } from '../constants';
+
+// 配置相关
+import {
+  configureRequestClient,
+  getClientOptions,
+  resolveAuthToken,
+  setAuthTokenResolver,
+} from './config';
+
+// 拦截器相关
+import {
+  addRequestInterceptor,
+  addResponseInterceptor,
+  initDefaultInterceptors,
+  runRequestInterceptors,
+  runResponseInterceptors,
+} from './interceptors';
+
+// SSO 相关
+import { ensureSsoSession, handleAuthFailureRedirect } from './sso';
+
+// Token 刷新相关
+import {
+  addToPendingQueue,
+  getRefreshPromise,
+  isFetchingToken,
+  shouldAttemptRefresh,
+} from './token-refresh';
+
+// 类型导出
+import type {
+  RequestContext,
+  RequestInterceptor,
+  ResponseInterceptor,
+  UnifiedRequestOptions,
+} from './types';
+
+// URL 解析
+import { resolveRequestUrl } from './url-resolver';
+
+// 始终使用远程地址的路径
+const ALWAYS_REMOTE_PATHS: string[] = [];
+
+// 初始化默认拦截器
+initDefaultInterceptors(isFetchingToken, addToPendingQueue);
+
+/**
+ * 判断当前路由是否跳过认证
+ */
+const shouldSkipAuth = (): boolean => {
+  return ROUTES.NO_AUTH_ROUTES.includes(location.pathname);
+};
+
+/**
+ * 统一请求函数
+ */
+export const request = async <T = unknown>(
+  url: string,
+  options?: UnifiedRequestOptions,
+): Promise<T> => {
+  await ensureSsoSession();
+
+  const isAlwaysRemote = ALWAYS_REMOTE_PATHS.some((path) =>
+    url.startsWith(path),
+  );
+  const resolvedUrl = resolveRequestUrl(url, options, isAlwaysRemote);
+
+  const ctx: RequestContext = {
+    url: resolvedUrl,
+    options: options ?? {},
+  };
+
+  const next = await runRequestInterceptors(ctx);
+
+  const mergedHeaders: Record<string, string> = {
+    ...(next.options.headers || {}),
+  };
+
+  const resolvedToken = resolveAuthToken();
+  if (resolvedToken && !mergedHeaders.authtoken) {
+    mergedHeaders.authtoken = resolvedToken;
+  }
+
+  const normalizedOptions = {
+    ...next.options,
+    headers: mergedHeaders,
+  };
+
+  try {
+    const response = await rawRequest<T>(next.url, normalizedOptions);
+    return runResponseInterceptors(response, {
+      url: next.url,
+      options: normalizedOptions,
+    });
+  } catch (error) {
+    if (shouldAttemptRefresh(error) && !shouldSkipAuth()) {
+      const newToken = await getRefreshPromise();
+      if (newToken) {
+        setStoredAuthToken(newToken);
+        const retryHeaders = {
+          ...normalizedOptions.headers,
+          authtoken: newToken,
+        };
+        const retryOptions = {
+          ...normalizedOptions,
+          headers: retryHeaders,
+        };
+        const retryResponse = await rawRequest<T>(next.url, retryOptions);
+        return runResponseInterceptors(retryResponse, {
+          url: next.url,
+          options: retryOptions,
+        });
+      }
+      handleAuthFailureRedirect();
+    }
+    throw error;
+  }
+};
+
+/**
+ * 使用临时拦截器执行请求
+ */
+export const withTemporaryInterceptors = async <T>(
+  runner: () => Promise<T>,
+  interceptors: {
+    request?: RequestInterceptor;
+    response?: ResponseInterceptor;
+  },
+): Promise<T> => {
+  const ejectors: Array<() => void> = [];
+
+  if (interceptors.request) {
+    ejectors.push(addRequestInterceptor(interceptors.request));
+  }
+  if (interceptors.response) {
+    ejectors.push(addResponseInterceptor(interceptors.response));
+  }
+
+  try {
+    return await runner();
+  } finally {
+    for (const eject of ejectors) {
+      eject();
+    }
+  }
+};
+
+// 导出配置相关方法
+export {
+  configureRequestClient,
+  getClientOptions,
+  resolveAuthToken,
+  setAuthTokenResolver,
+};
+
+// 导出拦截器注册方法
+export const registerRequestInterceptor = addRequestInterceptor;
+export const registerResponseInterceptor = addResponseInterceptor;
+
+// 导出认证相关方法
+export { handleAuthFailureRedirect };
+
+// 导出类型
+export type {
+  RequestContext,
+  RequestInterceptor,
+  ResponseInterceptor,
+  UnifiedRequestOptions,
+};