befly 3.8.29 → 3.8.31

package/sync/syncMenu.ts

@@ -1,79 +1,129 @@
 /**
  * SyncMenu 命令 - 同步菜单数据到数据库
- * 说明：根据配置文件增量同步菜单数据（最多3级：父级、子级、孙级）
+ * 说明：扫描 addon 的 views 目录和项目的 menus.json，同步菜单数据
  *
  * 流程：
- * 1. 扫描所有 addon 的 addon.config.js/ts 配置文件
- * 2. 扫描项目根目录的 app.config.js/ts 配置文件
- * 3. 项目的 app.config 优先级最高，可以覆盖 addon 的菜单配置
- * 4. 文件不存在或格式错误时默认为空数组
- * 5. 根据菜单的 path 字段检查是否存在
- * 6. 存在则更新其他字段（name、sort、type、pid）
- * 7. 不存在则新增菜单记录
- * 8. 强制删除配置中不存在的菜单记录
+ * 1. 扫描所有 addon 的 views 目录下的 meta.json 文件
+ * 2. 根据目录层级构建菜单树（无层级限制）
+ * 3. 读取项目的 menus.json 文件（手动配置的菜单）
+ * 4. 根据菜单的 path 字段检查是否存在
+ * 5. 存在则更新其他字段（name、sort、pid）
+ * 6. 不存在则新增菜单记录
+ * 7. 强制删除配置中不存在的菜单记录
  * 注：state 字段由框架自动管理（1=正常，2=禁用，0=删除）
  */
 
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'pathe';
-import { cloneDeep } from 'es-toolkit';
+
 import { Connect } from '../lib/connect.js';
+import { DbHelper } from '../lib/dbHelper.js';
 import { RedisHelper } from '../lib/redisHelper.js';
-import { scanAddons, getAddonDir, scanConfig } from 'befly-util';
+import { RedisKeys } from 'befly-shared/redisKeys';
+import { scanAddons, getAddonDir } from 'befly-shared/addonHelper';
 import { Logger } from '../lib/logger.js';
 import { projectDir } from '../paths.js';
+import { beflyConfig } from '../befly.config.js';
 
-import type { SyncMenuOptions, MenuConfig, BeflyOptions } from '../types/index.js';
+import type { SyncMenuOptions, MenuConfig } from '../types/index.js';
 
 /**
- * 递归转换菜单路径
- * @param menu 菜单对象（会被修改）
- * @param transform 路径转换函数
+ * 清理目录名中的数字后缀
+ * 如：login_1 → login, index_2 → index
  */
-function transformMenuPaths(menu: MenuConfig, transform: (path: string) => string): void {
-    if (menu.path && menu.path.startsWith('/')) {
-        menu.path = transform(menu.path);
-    }
-    menu.children?.forEach((child) => transformMenuPaths(child, transform));
+function cleanDirName(name: string): string {
+    return name.replace(/_\d+$/, '');
 }
 
 /**
- * 为 addon 菜单的 path 添加前缀
- * 规则：
- * 1. 所有路径必须以 / 开头
- * 2. 所有路径都添加 /addon/{addonName} 前缀（包括根路径 /）
- * 3. 递归处理所有层级的子菜单
- * 4. 项目菜单不添加前缀
+ * 扫描 views 目录，构建菜单树
+ * @param viewsDir views 目录路径
+ * @param prefix 路径前缀（addon 前缀）
+ * @param parentPath 父级路径
+ * @returns 菜单数组
  */
-function addAddonPrefix(menus: MenuConfig[], addonName: string): MenuConfig[] {
-    return menus.map((menu) => {
-        const cloned = cloneDeep(menu);
-        transformMenuPaths(cloned, (path) => `/addon/${addonName}${path}`);
-        return cloned;
-    });
+async function scanViewsDir(viewsDir: string, prefix: string, parentPath: string = ''): Promise<MenuConfig[]> {
+    if (!existsSync(viewsDir)) {
+        return [];
+    }
+
+    const menus: MenuConfig[] = [];
+    const entries = await readdir(viewsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        // 只处理目录，忽略 components 目录
+        if (!entry.isDirectory() || entry.name === 'components') {
+            continue;
+        }
+
+        const dirPath = join(viewsDir, entry.name);
+        const metaPath = join(dirPath, 'meta.json');
+
+        // 没有 meta.json 的目录不处理
+        if (!existsSync(metaPath)) {
+            continue;
+        }
+
+        // 读取 meta.json
+        let meta: { name: string; order?: number };
+        try {
+            const content = await readFile(metaPath, 'utf-8');
+            meta = JSON.parse(content);
+        } catch (error: any) {
+            Logger.warn({ err: error, path: metaPath }, '读取 meta.json 失败');
+            continue;
+        }
+
+        // 计算路径：清理数字后缀，index 目录特殊处理
+        const cleanName = cleanDirName(entry.name);
+        let menuPath: string;
+        if (cleanName === 'index') {
+            // index 目录路径为父级路径，根级别则为 /
+            menuPath = parentPath || '/';
+        } else {
+            menuPath = parentPath ? `${parentPath}/${cleanName}` : `/${cleanName}`;
+        }
+
+        // 添加 addon 前缀
+        const fullPath = prefix ? `${prefix}${menuPath}` : menuPath;
+
+        const menu: MenuConfig = {
+            name: meta.name,
+            path: fullPath,
+            sort: meta.order || 100
+        };
+
+        // 递归扫描子目录
+        const children = await scanViewsDir(dirPath, prefix, menuPath);
+        if (children.length > 0) {
+            menu.children = children;
+        }
+
+        menus.push(menu);
+    }
+
+    // 按 sort 排序
+    menus.sort((a, b) => (a.sort || 100) - (b.sort || 100));
+
+    return menus;
 }
 
 /**
  * 合并菜单配置
- * 优先级：项目 package.json > addon package.json
- * 支持三级菜单结构：父级、子级、孙级
+ * 支持无限层级菜单结构
  */
-function mergeMenuConfigs(allMenus: Array<{ menus: MenuConfig[]; addonName: string }>): MenuConfig[] {
-    /**
-     * 递归合并指定层级的菜单（限制最多3层）
-     * @param menus 待合并的菜单数组
-     * @param depth 当前深度（1=父级, 2=子级, 3=孙级）
-     * @returns 合并后的菜单数组
-     */
-    function mergeLevel(menus: MenuConfig[], depth: number = 1): MenuConfig[] {
-        const menuMap = new Map<string, MenuConfig>();
+function mergeMenuConfigs(allMenus: Array<{ menus: MenuConfig[]; source: string }>): MenuConfig[] {
+    const menuMap = new Map<string, MenuConfig>();
 
+    for (const { menus } of allMenus) {
         for (const menu of menus) {
             if (!menu.path) continue;
 
             const existing = menuMap.get(menu.path);
             if (existing) {
                 // 合并子菜单
-                if (menu.children?.length > 0) {
+                if (menu.children && menu.children.length > 0) {
                     existing.children = existing.children || [];
                     existing.children.push(...menu.children);
                 }
@@ -81,73 +131,67 @@ function mergeMenuConfigs(allMenus: Array<{ menus: MenuConfig[]; addonName: stri
                 menuMap.set(menu.path, { ...menu });
             }
         }
+    }
 
-        // 递归处理子菜单（限制最多3层）
-        if (depth < 3) {
-            for (const menu of menuMap.values()) {
-                if (menu.children?.length > 0) {
-                    menu.children = mergeLevel(menu.children, depth + 1);
-                }
-            }
+    return Array.from(menuMap.values());
+}
+
+/**
+ * 过滤隐藏的菜单（递归处理子菜单）
+ */
+function filterHiddenMenus(menus: MenuConfig[], hiddenSet: Set<string>): MenuConfig[] {
+    const result: MenuConfig[] = [];
+
+    for (const menu of menus) {
+        // 如果菜单在隐藏列表中，跳过
+        if (menu.path && hiddenSet.has(menu.path)) {
+            continue;
         }
 
-        return Array.from(menuMap.values());
-    }
+        const filtered = { ...menu };
+
+        // 递归过滤子菜单
+        if (filtered.children && filtered.children.length > 0) {
+            filtered.children = filterHiddenMenus(filtered.children, hiddenSet);
+        }
 
-    // 收集所有菜单（扁平化）
-    const allFlatMenus = allMenus.flatMap(({ menus }) => menus);
+        result.push(filtered);
+    }
 
-    return mergeLevel(allFlatMenus, 1);
+    return result;
 }
 
 /**
- * 收集配置文件中所有菜单的 path（最多3级）
- * 子级菜单使用独立路径
+ * 收集所有菜单的 path（递归收集所有层级）
  */
 function collectPaths(menus: MenuConfig[]): Set<string> {
     const paths = new Set<string>();
 
-    for (const menu of menus) {
-        if (menu.path) {
-            paths.add(menu.path);
-        }
-        if (menu.children && menu.children.length > 0) {
-            for (const child of menu.children) {
-                if (child.path) {
-                    paths.add(child.path);
-                }
-                // 第三层菜单
-                if (child.children && child.children.length > 0) {
-                    for (const grandChild of child.children) {
-                        if (grandChild.path) {
-                            paths.add(grandChild.path);
-                        }
-                    }
-                }
+    function collect(items: MenuConfig[]): void {
+        for (const menu of items) {
+            if (menu.path) {
+                paths.add(menu.path);
+            }
+            if (menu.children && menu.children.length > 0) {
+                collect(menu.children);
             }
         }
     }
 
+    collect(menus);
     return paths;
 }
 
 /**
- * 递归同步单个菜单（限制最多3层）
- * @param helper 数据库帮助类
- * @param menu 菜单配置
- * @param pid 父级菜单ID
- * @param existingMenuMap 现有菜单映射
- * @param depth 当前深度（1=父级, 2=子级, 3=孙级）
- * @returns 菜单ID
+ * 递归同步单个菜单（无层级限制）
  */
-async function syncMenuRecursive(helper: any, menu: MenuConfig, pid: number, existingMenuMap: Map<string, any>, depth: number = 1): Promise<number> {
+async function syncMenuRecursive(helper: any, menu: MenuConfig, pid: number, existingMenuMap: Map<string, any>): Promise<number> {
     const existing = existingMenuMap.get(menu.path || '');
     let menuId: number;
 
     if (existing) {
         menuId = existing.id;
 
-        // 检查是否需要更新
         const needUpdate = existing.pid !== pid || existing.name !== menu.name || existing.sort !== (menu.sort || 0);
 
         if (needUpdate) {
@@ -173,10 +217,9 @@ async function syncMenuRecursive(helper: any, menu: MenuConfig, pid: number, exi
         });
     }
 
-    // 递归处理子菜单（限制最多3层）
-    if (depth < 3 && menu.children?.length > 0) {
+    if (menu.children && menu.children.length > 0) {
         for (const child of menu.children) {
-            await syncMenuRecursive(helper, child, menuId, existingMenuMap, depth + 1);
+            await syncMenuRecursive(helper, child, menuId, existingMenuMap);
         }
     }
 
@@ -184,11 +227,9 @@ async function syncMenuRecursive(helper: any, menu: MenuConfig, pid: number, exi
 }
 
 /**
- * 同步菜单（三层结构：父级、子级、孙级）
- * 子级菜单使用独立路径
+ * 同步菜单到数据库
  */
 async function syncMenus(helper: any, menus: MenuConfig[]): Promise<void> {
-    // 批量查询所有现有菜单，建立 path -> menu 的映射
     const allExistingMenus = await helper.getAll({
         table: 'addon_admin_menu',
         fields: ['id', 'pid', 'name', 'path', 'sort']
@@ -204,7 +245,7 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<void> {
         try {
             await syncMenuRecursive(helper, menu, 0, existingMenuMap, 1);
         } catch (error: any) {
-            Logger.error(`同步菜单 "${menu.name}" 失败`, error.message || String(error));
+            Logger.error({ err: error, menu: menu.name }, '同步菜单失败');
             throw error;
         }
     }
@@ -231,52 +272,49 @@ async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Pro
 }
 
 /**
- * 加载所有菜单配置（addon + 项目）
- * @returns 菜单配置数组
+ * 加载所有菜单配置（addon views + 项目 menus.json）
  */
-async function loadMenuConfigs(): Promise<Array<{ menus: MenuConfig[]; addonName: string }>> {
-    const allMenus: Array<{ menus: MenuConfig[]; addonName: string }> = [];
+async function loadMenuConfigs(): Promise<Array<{ menus: MenuConfig[]; source: string }>> {
+    const allMenus: Array<{ menus: MenuConfig[]; source: string }> = [];
 
-    // 1. 加载所有 addon 配置
+    // 1. 扫描所有 addon 的 views 目录
     const addonNames = scanAddons();
 
     for (const addonName of addonNames) {
         try {
             const addonDir = getAddonDir(addonName, '');
-            const addonConfigData = await scanConfig({
-                dirs: [addonDir],
-                files: ['addon.config'],
-                mode: 'first',
-                paths: ['menus']
-            });
-
-            const addonMenus = addonConfigData?.menus || [];
-            if (Array.isArray(addonMenus) && addonMenus.length > 0) {
-                // 为 addon 菜单添加路径前缀
-                const menusWithPrefix = addAddonPrefix(addonMenus, addonName);
-                allMenus.push({ menus: menusWithPrefix, addonName: addonName });
+            const viewsDir = join(addonDir, 'views');
+
+            if (existsSync(viewsDir)) {
+                const prefix = `/addon/${addonName}`;
+                const menus = await scanViewsDir(viewsDir, prefix);
+                if (menus.length > 0) {
+                    allMenus.push({
+                        menus: menus,
+                        source: `addon:${addonName}`
+                    });
+                }
             }
         } catch (error: any) {
-            Logger.warn(`读取 addon 配置失败 ${addonName}: ${error.message}`);
+            Logger.warn({ err: error, addon: addonName }, '扫描 addon views 目录失败');
         }
     }
 
-    // 2. 加载项目配置
-    try {
-        const appConfigData = await scanConfig({
-            dirs: [projectDir],
-            files: ['app.config'],
-            mode: 'first',
-            paths: ['menus']
-        });
-
-        const appMenus = appConfigData?.menus || [];
-        if (Array.isArray(appMenus) && appMenus.length > 0) {
-            // 项目菜单不添加前缀
-            allMenus.push({ menus: appMenus, addonName: 'app' });
+    // 2. 读取项目的 menus.json
+    const menusJsonPath = join(projectDir, 'menus.json');
+    if (existsSync(menusJsonPath)) {
+        try {
+            const content = await readFile(menusJsonPath, 'utf-8');
+            const projectMenus = JSON.parse(content);
+            if (Array.isArray(projectMenus) && projectMenus.length > 0) {
+                allMenus.push({
+                    menus: projectMenus,
+                    source: 'project'
+                });
+            }
+        } catch (error: any) {
+            Logger.warn({ err: error }, '读取项目 menus.json 失败');
         }
-    } catch (error: any) {
-        Logger.warn(`读取项目配置失败: ${error.message}`);
     }
 
     return allMenus;
@@ -285,39 +323,46 @@ async function loadMenuConfigs(): Promise<Array<{ menus: MenuConfig[]; addonName
 /**
  * SyncMenu 命令主函数
  */
-export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOptions = {}): Promise<void> {
+export async function syncMenuCommand(options: SyncMenuOptions = {}): Promise<void> {
     try {
         if (options.plan) {
             Logger.debug('[计划] 同步菜单配置到数据库（plan 模式不执行）');
             return;
         }
 
-        // 1. 加载所有菜单配置（addon + 项目）
+        // 1. 加载所有菜单配置
         const allMenus = await loadMenuConfigs();
 
         // 2. 合并菜单配置
-        const mergedMenus = mergeMenuConfigs(allMenus);
+        let mergedMenus = mergeMenuConfigs(allMenus);
+
+        // 3. 过滤隐藏菜单（根据 hiddenMenus 配置）
+        const hiddenMenus = (beflyConfig as any).hiddenMenus || [];
+        if (Array.isArray(hiddenMenus) && hiddenMenus.length > 0) {
+            const hiddenSet = new Set(hiddenMenus);
+            mergedMenus = filterHiddenMenus(mergedMenus, hiddenSet);
+        }
 
-        // 连接数据库（SQL + Redis）
-        await Connect.connect(config);
+        // 连接数据库
+        await Connect.connect();
 
-        const helper = Connect.getDbHelper();
+        const helper = new DbHelper({ redis: new RedisHelper() } as any, Connect.getSql());
 
-        // 3. 检查表是否存在（addon_admin_menu 来自 addon-admin 组件）
+        // 3. 检查表是否存在
         const exists = await helper.tableExists('addon_admin_menu');
 
         if (!exists) {
-            Logger.debug('表 addon_admin_menu 不存在，跳过菜单同步（需要安装 addon-admin 组件）');
+            Logger.debug('表 addon_admin_menu 不存在，跳过菜单同步');
             return;
         }
 
-        // 4. 收集配置文件中所有菜单的 path
+        // 4. 收集所有菜单的 path
         const configPaths = collectPaths(mergedMenus);
 
         // 5. 同步菜单
         await syncMenus(helper, mergedMenus);
 
-        // 6. 删除文件中不存在的菜单（强制删除）
+        // 6. 删除不存在的菜单
         await deleteObsoleteRecords(helper, configPaths);
 
         // 7. 获取最终菜单数据（用于缓存）
@@ -330,12 +375,12 @@ export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOpt
         // 8. 缓存菜单数据到 Redis
         try {
             const redisHelper = new RedisHelper();
-            await redisHelper.setObject('menus:all', allMenusData);
+            await redisHelper.setObject(RedisKeys.menusAll(), allMenusData);
         } catch (error: any) {
-            Logger.warn(`Redis 缓存菜单数据失败: ${error.message}`);
+            Logger.warn({ err: error }, 'Redis 缓存菜单数据失败');
         }
     } catch (error: any) {
-        Logger.error('菜单同步失败', error);
+        Logger.error({ err: error }, '菜单同步失败');
         throw error;
     } finally {
         await Connect.disconnect();