befly 3.5.0 → 3.5.2

package/commands/syncMenu.ts

@@ -34,6 +34,15 @@ interface MenuConfig {
     children?: MenuConfig[];
 }
 
+export interface SyncMenuStats {
+    totalMenus: number;
+    parentMenus: number;
+    childMenus: number;
+    created: number;
+    updated: number;
+    deleted: number;
+}
+
 /**
  * 读取菜单配置文件
  * 如果文件不存在或不是数组格式，返回空数组
@@ -41,7 +50,6 @@ interface MenuConfig {
 async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
     try {
         if (!existsSync(filePath)) {
-            Logger.warn(`菜单配置文件不存在: ${filePath}，使用空数组`);
             return [];
         }
 
@@ -50,13 +58,11 @@ async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
 
         // 验证是否为数组
         if (!Array.isArray(content)) {
-            Logger.warn(`菜单配置文件格式错误（非数组）: ${filePath}，使用空数组`);
             return [];
         }
 
         return content;
     } catch (error: any) {
-        Logger.warn(`读取菜单配置失败: ${filePath}，使用空数组`, error.message);
         return [];
     }
 }
@@ -176,7 +182,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                 });
                 parentId = existingParent.id;
                 stats.updated++;
-                Logger.info(`  └ 更新父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
             } else {
                 parentId = await helper.insData({
                     table: 'core_menu',
@@ -190,7 +195,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                     }
                 });
                 stats.created++;
-                Logger.info(`  └ 新增父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
             }
 
             // 2. 同步子级菜单（自动追加父级路径前缀）
@@ -217,9 +221,8 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                             }
                         });
                         stats.updated++;
-                        Logger.info(`    └ 更新子级菜单: ${child.name} (ID: ${existingChild.id}, PID: ${parentId}, Path: ${childFullPath})`);
                     } else {
-                        const childId = await helper.insData({
+                        await helper.insData({
                             table: 'core_menu',
                             data: {
                                 pid: parentId,
@@ -231,7 +234,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                             }
                         });
                         stats.created++;
-                        Logger.info(`    └ 新增子级菜单: ${child.name} (ID: ${childId}, PID: ${parentId}, Path: ${childFullPath})`);
                     }
                 }
             }
@@ -248,8 +250,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
  * 删除配置中不存在的菜单（强制删除）
  */
 async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Promise<number> {
-    Logger.info(`\n=== 删除配置中不存在的记录 ===`);
-
     const allRecords = await helper.getAll({
         table: 'core_menu',
         fields: ['id', 'path', 'name'],
@@ -264,60 +264,31 @@ async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Pro
                 where: { id: record.id }
             });
             deletedCount++;
-            Logger.info(`  └ 删除记录: ${record.name} (ID: ${record.id}, path: ${record.path})`);
         }
     }
 
-    if (deletedCount === 0) {
-        Logger.info('  ✅ 无需删除的记录');
-    }
-
     return deletedCount;
 }
 
 /**
  * SyncMenu 命令主函数
  */
-export async function syncMenuCommand(options: SyncMenuOptions = {}) {
+export async function syncMenuCommand(options: SyncMenuOptions = {}): Promise<SyncMenuStats> {
     try {
         if (options.plan) {
             Logger.info('[计划] 同步菜单配置到数据库（plan 模式不执行）');
-            Logger.info('[计划] 1. 读取 core/config/menu.json 和项目根目录 menu.json');
-            Logger.info('[计划] 2. 合并菜单配置（core 优先覆盖项目）');
-            Logger.info('[计划] 3. 子级菜单自动追加父级路径前缀');
-            Logger.info('[计划] 4. 根据 path 检查菜单是否存在');
-            Logger.info('[计划] 5. 存在则更新，不存在则新增');
-            Logger.info('[计划] 6. 强制删除配置中不存在的菜单');
-            Logger.info('[计划] 7. 显示菜单结构预览');
-            return;
+            return { totalMenus: 0, parentMenus: 0, childMenus: 0, created: 0, updated: 0, deleted: 0 };
         }
 
-        Logger.info('开始同步菜单配置到数据库...\n');
-
         // 1. 读取两个配置文件
-        Logger.info('=== 步骤 1: 读取菜单配置文件 ===');
         const projectMenuPath = join(projectDir, 'menu.json');
         const coreMenuPath = join(coreDir, 'menu.json');
 
-        Logger.info(`  项目路径: ${projectMenuPath}`);
-        Logger.info(`  core 路径: ${coreMenuPath}`);
-
         const projectMenus = await readMenuConfig(projectMenuPath);
         const coreMenus = await readMenuConfig(coreMenuPath);
 
-        Logger.info(`✅ 项目配置: ${projectMenus.length} 个父级菜单`);
-        Logger.info(`✅ core 配置: ${coreMenus.length} 个父级菜单`);
-
         // 2. 合并菜单配置
-        Logger.info('\n=== 步骤 2: 合并菜单配置（core 优先覆盖项目） ===');
         const mergedMenus = mergeMenuConfigs(projectMenus, coreMenus);
-        Logger.info(`✅ 合并后共有 ${mergedMenus.length} 个父级菜单`);
-
-        // 打印合并后的菜单结构
-        for (const menu of mergedMenus) {
-            const childCount = menu.children?.length || 0;
-            Logger.info(`  └ ${menu.name} (${menu.path}) - ${childCount} 个子菜单`);
-        }
 
         // 连接数据库（SQL + Redis）
         await Database.connect();
@@ -325,7 +296,6 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
         const helper = Database.getDbHelper();
 
         // 3. 检查表是否存在
-        Logger.info('\n=== 步骤 3: 检查数据表 ===');
         const exists = await helper.tableExists('core_menu');
 
         if (!exists) {
@@ -333,47 +303,23 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
             process.exit(1);
         }
 
-        Logger.info(`✅ 表 core_menu 存在`);
-
         // 4. 收集配置文件中所有菜单的 path
-        Logger.info('\n=== 步骤 4: 收集配置菜单路径 ===');
         const configPaths = collectPaths(mergedMenus);
-        Logger.info(`✅ 配置文件中共有 ${configPaths.size} 个菜单路径`);
 
         // 5. 同步菜单
-        Logger.info('\n=== 步骤 5: 同步菜单数据（新增/更新） ===');
         const stats = await syncMenus(helper, mergedMenus);
 
         // 6. 删除文件中不存在的菜单（强制删除）
         const deletedCount = await deleteObsoleteRecords(helper, configPaths);
 
-        // 7. 构建树形结构预览
-        Logger.info('\n=== 步骤 7: 菜单结构预览 ===');
+        // 7. 获取最终菜单数据
         const allMenus = await helper.getAll({
             table: 'core_menu',
             fields: ['id', 'pid', 'name', 'path', 'type'],
             orderBy: ['pid#ASC', 'sort#ASC', 'id#ASC']
         });
 
-        const parentMenus = allMenus.filter((m: any) => m.pid === 0);
-        for (const parent of parentMenus) {
-            const children = allMenus.filter((m: any) => m.pid === parent.id);
-            Logger.info(`  └ ${parent.name} (${parent.path})`);
-            for (const child of children) {
-                Logger.info(`    └ ${child.name} (${child.path})`);
-            }
-        }
-
-        // 8. 输出统计信息
-        Logger.info(`\n=== 菜单同步完成 ===`);
-        Logger.info(`新增菜单: ${stats.created} 个`);
-        Logger.info(`更新菜单: ${stats.updated} 个`);
-        Logger.info(`删除菜单: ${deletedCount} 个`);
-        Logger.info(`当前父级菜单: ${allMenus.filter((m: any) => m.pid === 0).length} 个`);
-        Logger.info(`当前子级菜单: ${allMenus.filter((m: any) => m.pid !== 0).length} 个`);
-
-        // 9. 缓存菜单数据到 Redis
-        Logger.info('\n=== 步骤 8: 缓存菜单数据到 Redis ===');
+        // 8. 缓存菜单数据到 Redis
         try {
             const menus = await helper.getAll({
                 table: 'core_menu',
@@ -381,16 +327,19 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
                 orderBy: ['sort#ASC', 'id#ASC']
             });
 
-            const result = await RedisHelper.setObject('menus:all', menus);
-
-            if (result === null) {
-                Logger.warn('⚠️ 菜单缓存失败');
-            } else {
-                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: menus:all)`);
-            }
+            await RedisHelper.setObject('menus:all', menus);
         } catch (error: any) {
-            Logger.error('⚠️ 菜单缓存异常:', error);
+            // 忽略缓存错误
         }
+
+        return {
+            totalMenus: allMenus.length,
+            parentMenus: allMenus.filter((m: any) => m.pid === 0).length,
+            childMenus: allMenus.filter((m: any) => m.pid !== 0).length,
+            created: stats.created,
+            updated: stats.updated,
+            deleted: deletedCount
+        };
     } catch (error: any) {
         Logger.error('菜单同步失败:', error);
         process.exit(1);

package/lib/database.ts

@@ -87,8 +87,6 @@ export class Database {
 
             const version = await Promise.race([healthCheckPromise, timeoutPromise]);
 
-            Logger.info(`数据库连接成功，version: ${version}`);
-
             this.sqlClient = sql;
             return sql;
         } catch (error: any) {
@@ -110,7 +108,6 @@ export class Database {
         if (this.sqlClient) {
             try {
                 await this.sqlClient.close();
-                Logger.info('SQL 连接已关闭');
             } catch (error: any) {
                 Logger.warn('关闭 SQL 连接时出错:', error.message);
             }
@@ -186,7 +183,6 @@ export class Database {
             });
 
             await redis.ping();
-            Logger.info('Redis 连接成功');
 
             this.redisClient = redis;
             return redis;
@@ -203,7 +199,6 @@ export class Database {
         if (this.redisClient) {
             try {
                 this.redisClient.close();
-                Logger.info('Redis 连接已关闭');
             } catch (error: any) {
                 Logger.warn('关闭 Redis 连接时出错:', error);
             }
@@ -233,16 +228,12 @@ export class Database {
     static async connect(options?: { sql?: SqlClientOptions; redis?: boolean }): Promise<void> {
         try {
             if (options?.sql !== false) {
-                Logger.info('正在初始化 SQL 连接...');
                 await this.connectSql(options?.sql);
             }
 
             if (options?.redis !== false) {
-                Logger.info('正在初始化 Redis 连接...');
                 await this.connectRedis();
             }
-
-            Logger.info('数据库连接初始化完成');
         } catch (error: any) {
             Logger.error('数据库初始化失败', error);
             await this.disconnect();

package/lib/logger.ts

@@ -217,10 +217,12 @@ export class Logger {
      * 用于命令开始时提示用户当前环境
      */
     static printEnv(): void {
-        const env = process.env.NODE_ENV || 'development';
-        const envColor = env === 'production' ? chalk.red : env === 'test' ? chalk.yellow : chalk.green;
-        console.log(chalk.gray('────────────────────────────────────────'));
-        console.log(chalk.bold('运行环境: ') + envColor.bold(env.toUpperCase()));
-        console.log(chalk.gray('────────────────────────────────────────'));
+        console.log('========================================');
+        console.log('开始执行完整同步流程');
+        console.log(`当前环境: ${process.env.NODE_ENV || 'development'}`);
+        console.log(`项目名称: ${Env.APP_NAME}`);
+        console.log(`数据库地址: ${Env.DB_HOST}`);
+        console.log(`数据库名称: ${Env.DB_NAME}`);
+        console.log('========================================\n');
     }
 }

package/lifecycle/checker.ts

@@ -46,20 +46,15 @@ export class Checker {
                         const conflictCheckTime = calcPerfTime(conflictCheckStart);
 
                         if (typeof conflictResult !== 'boolean') {
-                            Logger.warn(`核心检查 conflict.ts 返回值必须为 true 或 false，当前为 ${typeof conflictResult}，耗时: ${conflictCheckTime}`);
+                            Logger.warn(`核心检查 conflict.ts 返回值必须为 true 或 false，当前为 ${typeof conflictResult}`);
                             stats.failedChecks++;
                         } else if (conflictResult === true) {
                             stats.passedChecks++;
-                            Logger.info(`核心检查 conflict.ts 通过，耗时: ${conflictCheckTime}`);
                         } else {
-                            Logger.warn(`核心检查未通过: conflict.ts，耗时: ${conflictCheckTime}`);
+                            Logger.warn(`核心检查未通过: conflict.ts`);
                             stats.failedChecks++;
                             // 资源冲突检测失败，立即终止
-                            Logger.warn('资源冲突检测失败，无法继续启动', {
-                                totalChecks: stats.totalChecks,
-                                passedChecks: stats.passedChecks,
-                                failedChecks: stats.failedChecks
-                            });
+                            Logger.warn('资源冲突检测失败，无法继续启动');
                             process.exit(1);
                         }
                     }
@@ -88,8 +83,6 @@ export class Checker {
                 const { path: checkDir, type } = checkConfig;
                 const addonName = 'addonName' in checkConfig ? checkConfig.addonName : undefined;
                 const checkTypeLabel = type === 'core' ? '核心' : type === 'project' ? '项目' : `组件${addonName}`;
-                Logger.info(`开始执行${checkTypeLabel}检查，目录: ${checkDir}`);
-
                 for await (const file of glob.scan({
                     cwd: checkDir,
                     onlyFiles: true,
@@ -118,18 +111,16 @@ export class Checker {
 
                             // 检查返回值是否为 boolean
                             if (typeof checkResult !== 'boolean') {
-                                Logger.warn(`${checkTypeLabel}检查 ${fileName} 返回值必须为 true 或 false，当前为 ${typeof checkResult}，耗时: ${singleCheckTime}`);
+                                Logger.warn(`${checkTypeLabel}检查 ${fileName} 返回值必须为 true 或 false，当前为 ${typeof checkResult}`);
                                 stats.failedChecks++;
                             } else if (checkResult === true) {
                                 stats.passedChecks++;
-                                Logger.info(`${checkTypeLabel}检查 ${fileName} 通过，耗时: ${singleCheckTime}`);
                             } else {
-                                Logger.warn(`${checkTypeLabel}检查未通过: ${fileName}，耗时: ${singleCheckTime}`);
+                                Logger.warn(`${checkTypeLabel}检查未通过: ${fileName}`);
                                 stats.failedChecks++;
                             }
                         } else {
-                            const singleCheckTime = calcPerfTime(singleCheckStart);
-                            Logger.warn(`${checkTypeLabel}检查文件 ${fileName} 未找到 default 导出的检查函数，耗时: ${singleCheckTime}`);
+                            Logger.warn(`${checkTypeLabel}检查文件 ${fileName} 未找到 default 导出的检查函数`);
                             stats.failedChecks++;
                         }
                     } catch (error: any) {
@@ -143,19 +134,11 @@ export class Checker {
             const totalCheckTime = calcPerfTime(checkStartTime);
 
             // 输出检查结果统计
-            Logger.info(`系统检查完成! 总耗时: ${totalCheckTime}，总检查数: ${stats.totalChecks}, 通过: ${stats.passedChecks}, 失败: ${stats.failedChecks}`);
-
             if (stats.failedChecks > 0) {
-                Logger.error('统检查失败，无法继续启动', {
-                    totalChecks: stats.totalChecks,
-                    passedChecks: stats.passedChecks,
-                    failedChecks: stats.failedChecks
-                });
+                Logger.error(`✗ 系统检查失败: ${stats.failedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
                 process.exit(1);
             } else if (stats.totalChecks > 0) {
-                Logger.info(`所有系统检查通过!`);
-            } else {
-                Logger.info(`未执行任何检查`);
+                Logger.info(`✓ 系统检查通过: ${stats.passedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
             }
         } catch (error: any) {
             Logger.error('执行系统检查时发生错误', error);

package/lifecycle/lifecycle.ts

@@ -39,7 +39,6 @@ export class Lifecycle {
      */
     async start(appContext: BeflyContext, callback?: (server: Server) => void): Promise<Server> {
         const serverStartTime = Bun.nanoseconds();
-        Logger.info('开始启动 Befly 服务器...');
 
         // 1. 执行系统检查
         await Checker.run();
@@ -52,7 +51,7 @@ export class Lifecycle {
 
         // 4. 启动 HTTP 服务器
         const totalStartupTime = calcPerfTime(serverStartTime);
-        Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime}`);
+        Logger.info(`✓ 服务器启动准备完成，总耗时: ${totalStartupTime}`);
 
         return await Bootstrap.start(
             {
@@ -70,63 +69,35 @@ export class Lifecycle {
      * 包括 core APIs、addon APIs 和 app APIs
      */
     private async loadAllApis(): Promise<void> {
-        Logger.info('========== 开始加载所有 API 路由 ==========');
-        const totalLoadStart = Bun.nanoseconds();
-
         // 1. 加载 Core APIs
-        Logger.info('========== 开始加载核心 APIs ==========');
-        const coreApiLoadStart = Bun.nanoseconds();
         try {
             await Loader.loadApis('core', this.apiRoutes, { where: 'core' });
-            const coreApiLoadTime = calcPerfTime(coreApiLoadStart);
-            Logger.info(`========== 核心 APIs 加载完成，耗时: ${coreApiLoadTime} ==========`);
         } catch (error: any) {
-            const coreApiLoadTime = calcPerfTime(coreApiLoadStart);
-            Logger.error(`核心 APIs 加载失败，耗时: ${coreApiLoadTime}`, error);
+            Logger.error(`核心 APIs 加载失败`, error);
             throw error;
         }
 
         // 2. 加载 addon APIs
         const addons = scanAddons();
-        Logger.info(`扫描到 ${addons.length} 个 addon: ${addons.join(', ')}`);
 
         for (const addon of addons) {
-            const addonLoadStart = Bun.nanoseconds();
             const hasApis = addonDirExists(addon, 'apis');
-            Logger.info(`[组件 ${addon}] APIs 目录存在: ${hasApis}`);
-
             if (hasApis) {
-                Logger.info(`[组件 ${addon}] ===== 开始加载 APIs =====`);
                 try {
                     await Loader.loadApis(addon, this.apiRoutes, { where: 'addon', addonName: addon });
-                    const addonLoadTime = calcPerfTime(addonLoadStart);
-                    Logger.info(`[组件 ${addon}] ===== APIs 加载完成，耗时: ${addonLoadTime} =====`);
                 } catch (error: any) {
-                    const addonLoadTime = calcPerfTime(addonLoadStart);
-                    Logger.error(`[组件 ${addon}] APIs 加载失败，耗时: ${addonLoadTime}`, error);
-                    throw error; // 重新抛出错误，让上层处理
+                    Logger.error(`[组件 ${addon}] APIs 加载失败`, error);
+                    throw error;
                 }
             }
         }
 
-        Logger.info('========== 组件 APIs 全部加载完成 ==========');
-
         // 3. 加载用户 APIs
-        Logger.info('========== 开始加载用户 APIs ==========');
-
-        const userApiLoadStart = Bun.nanoseconds();
         try {
-            // 加载 app APIs
             await Loader.loadApis('app', this.apiRoutes, { where: 'app' });
-            const userApiLoadTime = calcPerfTime(userApiLoadStart);
-            Logger.info(`========== 用户 APIs 加载完成，耗时: ${userApiLoadTime} ==========`);
         } catch (error: any) {
-            const userApiLoadTime = calcPerfTime(userApiLoadStart);
-            Logger.error(`用户 APIs 加载失败，耗时: ${userApiLoadTime}`, error);
+            Logger.error(`用户 APIs 加载失败`, error);
             throw error;
         }
-
-        const totalLoadTime = calcPerfTime(totalLoadStart);
-        Logger.info(`========== 所有 API 路由加载完成！总耗时: ${totalLoadTime} ==========`);
     }
 }