generator-mico-cli 0.2.28 → 0.2.30

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

@@ -0,0 +1,25 @@
+import { getFromStorage, removeStorage, setStorage } from '@/common/helpers';
+import { STORAGE_KEYS } from '@/constants';
+
+/**
+ * 当前租户 code 存储工具
+ *
+ * 多租户模式下，当前选中的租户会被持久化到 localStorage，
+ * 在调用 `fetchUserInfo` 时作为 `tenant` 参数传给后端，
+ * 以获取对应租户的 menu_perms / button_perms / region_perms。
+ */
+
+export const getStoredTenantCode = (): string | null => {
+  return getFromStorage(STORAGE_KEYS.CURRENT_TENANT);
+};
+
+export const setStoredTenantCode = (code: string): void => {
+  if (!code) {
+    return;
+  }
+  setStorage(STORAGE_KEYS.CURRENT_TENANT, code);
+};
+
+export const clearStoredTenantCode = (): void => {
+  removeStorage(STORAGE_KEYS.CURRENT_TENANT);
+};

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

@@ -8,40 +8,54 @@ export const UID = 'uid';
 /** 微应用模式下主应用传递的环境标识 */
 export const MICRO_ENV_KEY = 'micro_env';
 
+export interface IAppPerms {
+  key: string;
+  value: string;
+}
+
+export interface ITenantItem {
+  /** 租户名 */
+  name: string;
+  /** 租户 code */
+  code: string;
+}
+
+/** 租户模式枚举 */
+export enum ETenantModel {
+  Single = 1,
+  Multi = 2,
+}
+
 /**
- * 权限树节点
+ * OpenAPI — GET /user/info/ 响应 `data`
  */
-export interface IPermissionNode {
+export interface IUserInfoApiData {
   id: number;
+  avatar: string;
+  email: string;
   name: string;
-  sort: number;
-  level: number;
-  parent: number | null;
-  codename: string;
-  sub_menu?: IPermissionNode[];
+  app_perms: IAppPerms[];
+  region_perms: string[];
+  menu_perms: string[];
+  button_perms: string[];
+  is_superuser: boolean;
+  /** 租户模式：1 单租户，2 多租户 */
+  tenant_model: number;
+  /** 用户所属租户列表 */
+  tenant: ITenantItem[];
+  /** 当前租户 code，对应 ITenantItem.code */
+  current_tenant: string;
 }
 
 /**
- * 完整用户信息（/api/user/info 接口返回的 data 字段）
+ * 应用内用户信息（initialState.currentUser）
+ * 在 `IUserInfoApiData` 基础上补充展示用字段（由 fetchUserInfo normalize）
  */
-export interface IUserInfo {
-  id: number;
-  username: string;
-  email: string;
+export interface IUserInfo extends IUserInfoApiData {
+  /** 展示名，通常来自接口 `name` */
   user_name: string;
-  avatar: string;
-  phone: string;
-  first_name: string;
-  last_name: string;
-  is_superuser: boolean;
-  is_staff: boolean;
-  is_active: boolean;
-  type: number;
-  agency_id: number;
-  last_login: string;
-  permission_tree: IPermissionNode[];
-  miss_permissions: string[];
-  side_menus: string[];
-  app_permissions: string[];
-  groups: string[];
+  /** 登录名/账号展示，可与 `name` 或 `email` 一致 */
+  username: string;
+  /** 是否多租户模式（tenant_model === 2 的语义化快捷字段） */
+  isMultiTenant: boolean;
 }

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

@@ -0,0 +1,30 @@
+import { i18n } from '<%= packageScope %>/common-intl';
+import { getIntl } from '@umijs/max';
+import { isCommonIntlEnabled } from './intlRuntime';
+
+/**
+ * 非组件上下文（如 request 拦截器、工具函数）的国际化方法。
+ *
+ * 与 useLayoutIntl.formatMessage 逻辑一致：
+ * - commonIntl 未启用 → 直接走 Umi getIntl()
+ * - commonIntl 启用 → 远程 i18n() 优先，返回 defaultMessage 时回退到 Umi
+ */
+export function formatLayoutMessage(
+  descriptor: { id: string; defaultMessage?: string },
+  values?: Record<string, string | number | boolean | Date | null | undefined>,
+): string {
+  const umiIntl = getIntl();
+  const dm = descriptor.defaultMessage ?? descriptor.id;
+
+  if (!isCommonIntlEnabled()) {
+    return umiIntl.formatMessage(descriptor, values);
+  }
+
+  const fromIntl = i18n({ key: descriptor.id, defaultMessage: dm });
+  const fromUmi = umiIntl.formatMessage(descriptor, values);
+
+  if (fromIntl === dm && fromUmi !== fromIntl) {
+    return fromUmi || dm;
+  }
+  return fromIntl;
+}

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

@@ -0,0 +1,6 @@
+export { intl } from '<%= packageScope %>/common-intl';
+export { getCommonIntlConfig, isCommonIntlEnabled } from './intlRuntime';
+export { ilangToUmiLocale, umiLocaleToILang } from './localeMapping';
+export type { IMicoConfigCommonIntl } from './types';
+export { useLayoutIntl } from './useLayoutIntl';
+export { formatLayoutMessage } from './formatLayoutMessage';

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

@@ -0,0 +1,14 @@
+import type { IMicoConfigCommonIntl } from './types';
+
+/**
+ * 是否启用多语言中台拉取：以 __MICO_CONFIG__.intl 或 commonIntl 含有效 tag、app_name 为准
+ */
+export function isCommonIntlEnabled(): boolean {
+  const c = getCommonIntlConfig();
+  return !!(c?.tag && c?.app_name);
+}
+
+export function getCommonIntlConfig(): IMicoConfigCommonIntl | undefined {
+  const w = window.__MICO_CONFIG__;
+  return w?.intl ?? w?.commonIntl;
+}

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

@@ -0,0 +1,30 @@
+import { LANG, type ILang } from '<%= packageScope %>/common-intl';
+import type { SupportedLocale } from '@/common/locale';
+import { LOCALE } from '@/common/locale';
+
+/** 与 packages/common-intl/src/umiLocaleBridge.ts 保持一致 */
+const UMI_TO_ILANG: Record<SupportedLocale, ILang> = {
+  [LOCALE.ZH_CN]: LANG.ZH_CN,
+  [LOCALE.EN_US]: LANG.EN,
+};
+
+/**
+ * Umi 权威 locale → common-intl 中台 / 缓存键（ILang）
+ */
+export function umiLocaleToILang(locale: SupportedLocale): ILang {
+  return UMI_TO_ILANG[locale] ?? LANG.EN;
+}
+
+const ILANG_TO_UMI: Partial<Record<ILang, SupportedLocale>> = {
+  [LANG.ZH_CN]: LOCALE.ZH_CN,
+  [LANG.EN]: LOCALE.EN_US,
+  [LANG.AR]: LOCALE.EN_US,
+  [LANG.TR]: LOCALE.EN_US,
+};
+
+/**
+ * ILang → Umi 存储用 locale（layout 仅支持 zh-CN / en-US 时，其余语系落到 en-US）
+ */
+export function ilangToUmiLocale(lang: ILang): SupportedLocale {
+  return ILANG_TO_UMI[lang] ?? LOCALE.EN_US;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * layout 运行时 common-intl 配置（见 window.__MICO_CONFIG__.intl，兼容 commonIntl）
+ */
+export interface IMicoConfigCommonIntl {
+  /** 多语言中台 tag */
+  tag: string;
+  app_name: string;
+  indexedDBParams?: {
+    dbName?: string;
+    dbVersion?: number;
+    storeName?: string;
+    keyPathKey?: string;
+  };
+}

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

@@ -0,0 +1,40 @@
+import { i18n, intl } from '<%= packageScope %>/common-intl';
+import { useIntl } from '@umijs/max';
+import { getCurrentLocale } from '@/common/locale';
+import { isCommonIntlEnabled } from './intlRuntime';
+
+/**
+ * layout 统一国际化 Hook：未配置 commonIntl 时仅 Umi；配置后 common-intl 优先，无命中时 Umi 兜底。
+ */
+export function useLayoutIntl() {
+  const umiIntl = useIntl();
+  const commonIntlEnabled = isCommonIntlEnabled();
+  const locale = getCurrentLocale();
+
+  const formatMessage = (
+    descriptor: { id: string; defaultMessage?: string },
+    values?: Record<string, string | number | boolean | Date | null | undefined>,
+  ): string => {
+    if (!commonIntlEnabled) {
+      return umiIntl.formatMessage(descriptor, values);
+    }
+    const dm = descriptor.defaultMessage ?? descriptor.id;
+    const fromIntl = i18n({
+      key: descriptor.id,
+      defaultMessage: dm,
+    });
+    const fromUmi = umiIntl.formatMessage(descriptor, values);
+    if (fromIntl === dm && fromUmi !== fromIntl) {
+      return fromUmi;
+    }
+    return fromIntl;
+  };
+
+  return {
+    commonIntlEnabled,
+    locale,
+    formatMessage,
+    /** 仅 common-intl 启用时有值 */
+    intl: commonIntlEnabled ? intl : undefined,
+  };
+}

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

@@ -15,18 +15,17 @@ const noop = (): void => {};
  * 使用 bind 绑定前缀，保持控制台显示正确的调用位置
  */
 const createLogger = (prefix: string) => {
+  const formattedPrefix = `[${prefix}]`;
   if (!isDev) {
-    // 生产环境返回空操作
+    // 生产环境返回空操作，但 error 仍然输出（便于生产排查）
     return {
       log: noop,
       info: noop,
       warn: noop,
-      error: noop,
+      error: console.error.bind(console, new Error(formattedPrefix)),
     };
   }
 
-  const formattedPrefix = `[${prefix}]`;
-
   return {
     log: console.log.bind(console, formattedPrefix),
     info: console.info.bind(console, formattedPrefix),

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

@@ -1,5 +1,12 @@
+import { layoutLogger } from '@/common/logger';
 import { getCurrentLocale, LOCALE } from '@/common/locale';
-import { getMenuPage, getPages } from '@/common/portal-data';
+import {
+  findPageByPath,
+  getMenuPage,
+  getPages,
+} from '@/common/portal-data';
+
+export { findPageByPath };
 import { isAuthDisabled, isNoPermissionRoute } from '@/constants';
 import { getIntl } from '@umijs/max';
 import type {
@@ -28,6 +35,7 @@ export const extractRoutesFromPages = (
           | 'internal'
           | 'microapp',
         entry: page.htmlUrl || page.jsUrls?.[0] || undefined,
+        pageConfig: page,
       };
     });
 };
@@ -39,54 +47,54 @@ export const getDynamicRoutes = (): ParsedRoute[] => {
   return extractRoutesFromPages(getPages());
 };
 
-/**
- * 根据路径查找对应的页面配置
- * 匹配逻辑与 findRouteByPath 一致（精确匹配 + 通配符匹配）
- */
 /**
  * 判断指定路径的页面是否为免认证页面
  * 当 accessControlEnabled === false 时，跳过 SSO 认证和权限校验
+ * （页面解析与 `findPageByPath` 一致：精确匹配 + `/*` 通配）
  */
 export const isPageAuthFree = (pathname: string): boolean => {
   const page = findPageByPath(getPages(), pathname);
   return page?.accessControlEnabled === false;
 };
 
-export const findPageByPath = (
-  pages: PublicPageItem[],
-  pathname: string,
-): PublicPageItem | undefined => {
-  let exact: PublicPageItem | undefined;
-  let bestWildcard: { page: PublicPageItem; basePath: string } | undefined;
-
-  for (const page of pages) {
-    if (!page.enabled) continue;
-
-    if (page.route === pathname) {
-      exact = page;
-      continue;
-    }
-
-    if (page.route.endsWith('/*')) {
-      const basePath = page.route.slice(0, -2);
-      if (pathname === basePath || pathname.startsWith(`${basePath}/`)) {
-        if (!bestWildcard || basePath.length > bestWildcard.basePath.length) {
-          bestWildcard = { page, basePath };
-        }
-      }
-    }
-  }
-
-  return exact || bestWildcard?.page;
-};
-
 export interface MenuFilterOptions {
   /** 是否是超级用户 */
   isSuperuser?: boolean | number;
-  /** 允许访问的菜单路径列表（白名单） */
-  sideMenus?: string[];
+  /** 用户拥有的菜单权限 code（与页面 `routeKey`、菜单项一致） */
+  menuPerms?: string[];
 }
 
+/**
+ * 菜单关联页是否需要走 `menu_perms` 校验
+ * - 未开启访问控制：否（菜单始终可展示，由路由侧处理公开页）
+ * - 已开启访问控制但未配置 `routeKey`：否（无 code 可验，菜单展示）
+ * - 已开启访问控制且配置了 `routeKey`：是
+ */
+export const isMenuPageRequiringPermCode = (
+  page: PublicPageItem | undefined,
+): boolean => {
+  if (!page) return false;
+  if (page.accessControlEnabled === false) return false;
+  const rk = page.routeKey;
+  if (rk === null || rk === undefined || rk === '') return false;
+  return true;
+};
+
+/**
+ * 用于 `menu_perms` 匹配的权限 code（仅当 `isMenuPageRequiringPermCode(page)` 为真时有效）
+ */
+export const getMenuItemPermCode = (item: MenuItem): string | null => {
+  if (item.type === 'page') {
+    const page = getMenuPage(item);
+    if (!page || !isMenuPageRequiringPermCode(page)) return null;
+    return page.routeKey;
+  }
+  if (item.type === 'link') {
+    return item.nameKey || null;
+  }
+  return null;
+};
+
 export const isSuperuserUser = (value?: boolean | number): boolean => {
   return value === true || value === 1;
 };
@@ -107,11 +115,9 @@ export const isChineseLocale = (): boolean => {
 };
 
 /**
- * 获取菜单标识符（用于构建权限路径）
- * - 中文格式：优先使用 name，兜底使用 nameKey
- * - 英文格式：优先使用 nameEn，兜底使用 nameKey
- * @param item 菜单项
- * @param isChinese 是否中文格式
+ * 获取菜单标识符（用于内部路径拼接等，非侧栏展示）
+ * - 中文：优先 `name`，兜底 `nameKey`
+ * - 英文：优先 `nameEn`，兜底 `nameKey`
  */
 export const getMenuIdentifier = (
   item: MenuItem,
@@ -123,45 +129,96 @@ export const getMenuIdentifier = (
   return item.nameEn || item.nameKey || '';
 };
 
+/** 菜单项被过滤时的原因（用于开发日志） */
+export type MenuFilterDenyReason =
+  | 'adminOnly'
+  | 'groupContainer'
+  | 'missingPermCode'
+  | 'menuPermsEmpty'
+  | 'permCodeNotInMenuPerms'
+  | 'groupNoVisibleChildren'
+  | 'allChildrenFilteredOut';
+
+export interface IMenuFilterOutcome {
+  allowed: boolean;
+  /** 当 allowed === false 时，单项校验的拒绝原因（不含容器类、子项被滤空等结构原因） */
+  denyReason?: MenuFilterDenyReason;
+}
+
 /**
- * 检查菜单路径是否允许访问（白名单逻辑）
- * - 免权限校验路由，始终允许访问
- * - 超级用户可以访问所有菜单
- * - 非超级用户不能访问 adminOnly 菜单
- * - 菜单路径在 sideMenus 中，或是 sideMenus 中某项的前缀（父级菜单）
+ * 单项是否允许展示（不含「子项全被过滤」等结构判断）
+ * - 免权限校验路由、超管、关闭权限：允许
+ * - `group`：自身不作为叶子展示，allowed 恒为 false，`denyReason` 为 `groupContainer`
+ * - `page` 且关联页未要求 `menu_perms`（`accessControlEnabled === false`，或已开启但未配置 `routeKey`）：允许
+ * - `page` / `link` 需 code 时：权限 code 须在 `menu_perms` 中
  */
-const isMenuAllowed = (
-  menuPath: string,
+export const getMenuItemFilterOutcome = (
   item: MenuItem,
   options: MenuFilterOptions,
-): boolean => {
-  // 关闭权限控制时，所有菜单都允许访问
-  if (isAuthDisabled()) return true;
+): IMenuFilterOutcome => {
+  if (isAuthDisabled()) return { allowed: true };
 
-  // 免权限校验路由，始终允许访问
   const itemRoute = item.path ?? getMenuPage(item)?.route;
   if (itemRoute && isNoPermissionRoute(itemRoute)) {
-    return true;
+    return { allowed: true };
   }
 
-  // 超级用户可以访问所有菜单
-  if (isSuperuserUser(options.isSuperuser)) return true;
+  if (isSuperuserUser(options.isSuperuser)) return { allowed: true };
 
-  // 非超级用户不能访问 adminOnly 菜单
-  if (item.adminOnly) return false;
+  if (item.adminOnly) {
+    return { allowed: false, denyReason: 'adminOnly' };
+  }
 
-  const sideMenus = options.sideMenus || [];
+  if (item.type === 'group') {
+    return { allowed: false, denyReason: 'groupContainer' };
+  }
 
-  // 如果没有配置 sideMenus，非超级用户没有任何菜单权限
-  if (sideMenus.length === 0) return false;
+  if (item.type === 'page') {
+    const page = getMenuPage(item);
+    if (page && !isMenuPageRequiringPermCode(page)) {
+      return { allowed: true };
+    }
+  }
 
-  // 检查是否在白名单中（精确匹配或前缀匹配）
-  return sideMenus.some((allowedPath) => {
-    // 精确匹配：菜单路径完全等于白名单中的路径
-    if (menuPath === allowedPath) return true;
-    // 前缀匹配：白名单路径以菜单路径开头（说明菜单是父级）
-    if (allowedPath.startsWith(menuPath + '.')) return true;
-    return false;
+  const menuPerms = options.menuPerms || [];
+  const code = getMenuItemPermCode(item);
+
+  if (!code) {
+    return { allowed: false, denyReason: 'missingPermCode' };
+  }
+  if (menuPerms.length === 0) {
+    return { allowed: false, denyReason: 'menuPermsEmpty' };
+  }
+  if (!menuPerms.includes(code)) {
+    return { allowed: false, denyReason: 'permCodeNotInMenuPerms' };
+  }
+  return { allowed: true };
+};
+
+const shouldLogMenuFilter = (options: MenuFilterOptions): boolean => {
+  if (isAuthDisabled()) return false;
+  if (isSuperuserUser(options.isSuperuser)) return false;
+  return true;
+};
+
+const logMenuItemHidden = (
+  item: MenuItem,
+  options: MenuFilterOptions,
+  reason: MenuFilterDenyReason,
+): void => {
+  if (!shouldLogMenuFilter(options)) return;
+
+  const permCode = getMenuItemPermCode(item);
+  layoutLogger.log('menuFilter', {
+    verdict: 'hidden',
+    reason,
+    menuId: item.id,
+    menuType: item.type,
+    name: item.name,
+    nameKey: item.nameKey,
+    permCode,
+    menuPermsCount: options.menuPerms?.length ?? 0,
+    path: item.path ?? getMenuPage(item)?.route ?? null,
   });
 };
 
@@ -171,26 +228,20 @@ const isMenuAllowed = (
 export const filterMenuItems = (
   items: MenuItem[],
   options: MenuFilterOptions = {},
-  parentPath = '',
 ): MenuItem[] => {
-  // 根据当前语言环境判断菜单标识符格式
-  const isChinese = isChineseLocale();
   return items
     .filter((item) => item.enabled)
     .map((item) => {
-      const menuPath = buildMenuPath(
-        parentPath,
-        getMenuIdentifier(item, isChinese),
-      );
-      const isAllowed = isMenuAllowed(menuPath, item, options);
+      const outcome = getMenuItemFilterOutcome(item, options);
+      const isAllowed = outcome.allowed;
 
-      // 递归处理子菜单
       const nextChildren = item.children?.length
-        ? filterMenuItems(item.children, options, menuPath)
+        ? filterMenuItems(item.children, options)
         : [];
 
       // 分组类型：如果没有子菜单，不显示
       if (item.type === 'group' && nextChildren.length === 0) {
+        logMenuItemHidden(item, options, 'groupNoVisibleChildren');
         return null;
       }
 
@@ -200,6 +251,9 @@ export const filterMenuItems = (
         if (nextChildren.length > 0) {
           return { ...item, children: nextChildren };
         }
+        if (outcome.denyReason) {
+          logMenuItemHidden(item, options, outcome.denyReason);
+        }
         return null;
       }
 
@@ -211,6 +265,7 @@ export const filterMenuItems = (
 
       // 有子菜单但过滤后为空，不显示
       if (nextChildren.length === 0) {
+        logMenuItemHidden(item, options, 'allChildrenFilteredOut');
         return null;
       }
 
@@ -265,7 +320,7 @@ export const extractRoutes = (
 
     const menuPath = buildMenuPath(parentPath, getMenuIdentifierDefault(item));
 
-    if (item.type === 'page' && item.pageId) {
+    if (item.type === 'page') {
       const page = getMenuPage(item);
       if (page && page.enabled) {
         routes.push({
@@ -273,6 +328,7 @@ export const extractRoutes = (
           base: page.base || '/',
           name: item.name,
           nameEn: item.nameEn,
+          nameKey: item.nameKey,
           icon: item.icon,
           loadType: getLoadType(page),
           entry: getEntry(page),
@@ -290,24 +346,28 @@ export const extractRoutes = (
 };
 
 /**
- * 获取菜单项的显示名称
- * 优先级：name/nameEn > nameKey（走 intl 国际化） > 兜底 name
+ * 获取菜单项的显示名称（侧栏、Tab 等）
+ * - 有 `nameKey` 时优先走 intl，**`defaultMessage` 使用 `name`（中文）或 `nameEn`/`name`（英文）作为兜底文案**
+ * - 无 `nameKey` 时直接使用 `name` / `nameEn`
  */
 export const getMenuLabel = (
   fields: { name?: string; nameEn?: string; nameKey?: string },
   isChinese: boolean,
 ): string => {
-  const directName = isChinese ? fields.name : fields.nameEn;
-  if (directName) return directName;
-
   if (fields.nameKey) {
     const intl = getIntl();
+    const defaultMessage = isChinese
+      ? fields.name || fields.nameKey
+      : fields.nameEn || fields.name || fields.nameKey;
     return intl.formatMessage({
       id: fields.nameKey,
-      defaultMessage: fields.nameKey,
+      defaultMessage,
     });
   }
 
+  const directName = isChinese ? fields.name : fields.nameEn;
+  if (directName) return directName;
+
   return fields.name || '';
 };
 
@@ -354,8 +414,8 @@ export const findRouteByPath = (
   routes: ParsedRoute[],
   pathname: string,
 ): ParsedRoute | undefined => {
-  const normalizedPathname = stripTrailingSlash(pathname);
   let exact: ParsedRoute | undefined;
+  const normalizedPathname = stripTrailingSlash(pathname);
   let bestWildcard: { route: ParsedRoute; basePath: string } | undefined;
 
   for (const route of routes) {
@@ -366,7 +426,10 @@ export const findRouteByPath = (
 
     if (route.path.endsWith('/*')) {
       const basePath = route.path.slice(0, -2);
-      if (normalizedPathname === basePath || normalizedPathname.startsWith(`${basePath}/`)) {
+      if (
+        normalizedPathname === basePath ||
+        normalizedPathname.startsWith(`${basePath}/`)
+      ) {
         if (!bestWildcard || basePath.length > bestWildcard.basePath.length) {
           bestWildcard = { route, basePath };
         }