befly 3.5.0 → 3.5.2

package/commands/syncApi.ts

@@ -32,6 +32,13 @@ interface ApiInfo {
     addonTitle: string;
 }
 
+export interface SyncApiStats {
+    totalApis: number;
+    created: number;
+    updated: number;
+    deleted: number;
+}
+
 /**
  * 递归扫描目录下的所有 .ts 文件
  */
@@ -111,36 +118,29 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
     const apis: ApiInfo[] = [];
 
     // 1. 扫描 Core 框架 API
-    Logger.info('=== 扫描 Core 框架 API (core/apis) ===');
     const coreApisDir = join(dirname(projectRoot), 'core', 'apis');
     try {
         const coreApiFiles = scanTsFiles(coreApisDir);
-        Logger.info(`  找到 ${coreApiFiles.length} 个核心 API 文件`);
 
         for (const filePath of coreApiFiles) {
             const apiInfo = await extractApiInfo(filePath, coreApisDir, 'core', '', '核心接口');
             if (apiInfo) {
                 apis.push(apiInfo);
-                Logger.info(`  └ ${apiInfo.path} - ${apiInfo.name}`);
             }
         }
 
         // 2. 扫描项目 API
-        Logger.info('\n=== 扫描项目 API (apis) ===');
         const projectApisDir = join(projectRoot, 'apis');
         const projectApiFiles = scanTsFiles(projectApisDir);
-        Logger.info(`  找到 ${projectApiFiles.length} 个项目 API 文件`);
 
         for (const filePath of projectApiFiles) {
             const apiInfo = await extractApiInfo(filePath, projectApisDir, 'app', '', '项目接口');
             if (apiInfo) {
                 apis.push(apiInfo);
-                Logger.info(`  └ ${apiInfo.path} - ${apiInfo.name}`);
             }
         }
 
         // 3. 扫描组件 API (node_modules/@befly-addon/*)
-        Logger.info('\n=== 扫描组件 API (node_modules/@befly-addon/*) ===');
         const addonNames = scanAddons();
 
         for (const addonName of addonNames) {
@@ -148,7 +148,6 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
 
             // 检查 apis 子目录是否存在
             if (!addonDirExists(addonName, 'apis')) {
-                Logger.info(`  [${addonName}] 无 apis 目录，跳过`);
                 continue;
             }
 
@@ -162,17 +161,15 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
                 const config = await configFile.json();
                 addonTitle = config.title || addonName;
             } catch (error) {
-                Logger.debug(`  [${addonName}] 无法读取配置文件，使用默认标题`);
+                // 忽略配置读取错误
             }
 
             const addonApiFiles = scanTsFiles(addonApisDir);
-            Logger.info(`  [${addonName}] 找到 ${addonApiFiles.length} 个 API 文件`);
 
             for (const filePath of addonApiFiles) {
                 const apiInfo = await extractApiInfo(filePath, addonApisDir, 'addon', addonName, addonTitle);
                 if (apiInfo) {
                     apis.push(apiInfo);
-                    Logger.info(`    └ ${apiInfo.path} - ${apiInfo.name}`);
                 }
             }
         }
@@ -180,6 +177,7 @@ async function scanAllApis(projectRoot: string): Promise<ApiInfo[]> {
         return apis;
     } catch (error: any) {
         Logger.error(`接口扫描失败:`, error);
+        return apis;
     }
 }
 
@@ -191,6 +189,7 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<{ created: number
 
     for (const api of apis) {
         try {
+            // 根据 path 查询是否存在
             const existing = await helper.getOne({
                 table: 'core_api',
                 where: { path: api.path }
@@ -209,7 +208,6 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<{ created: number
                     }
                 });
                 stats.updated++;
-                Logger.info(`  └ 更新接口: ${api.name} (ID: ${existing.id}, Path: ${api.path})`);
             } else {
                 const id = await helper.insData({
                     table: 'core_api',
@@ -223,7 +221,6 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<{ created: number
                     }
                 });
                 stats.created++;
-                Logger.info(`  └ 新增接口: ${api.name} (ID: ${id}, Path: ${api.path})`);
             }
         } catch (error: any) {
             Logger.error(`同步接口 "${api.name}" 失败:`, error);
@@ -237,8 +234,6 @@ async function syncApis(helper: any, apis: ApiInfo[]): Promise<{ created: number
  * 删除配置中不存在的记录
  */
 async function deleteObsoleteRecords(helper: any, apiPaths: Set<string>): Promise<number> {
-    Logger.info(`\n=== 删除配置中不存在的记录 ===`);
-
     const allRecords = await helper.getAll({
         table: 'core_api',
         fields: ['id', 'path', 'name'],
@@ -253,34 +248,22 @@ async function deleteObsoleteRecords(helper: any, apiPaths: Set<string>): Promis
                 where: { id: record.id }
             });
             deletedCount++;
-            Logger.info(`  └ 删除记录: ${record.name} (ID: ${record.id}, path: ${record.path})`);
         }
     }
 
-    if (deletedCount === 0) {
-        Logger.info('  ✅ 无需删除的记录');
-    }
-
     return deletedCount;
 }
 
 /**
  * SyncApi 命令主函数
  */
-export async function syncApiCommand(options: SyncApiOptions = {}) {
+export async function syncApiCommand(options: SyncApiOptions = {}): Promise<SyncApiStats> {
     try {
         if (options.plan) {
             Logger.info('[计划] 同步 API 接口到数据库（plan 模式不执行）');
-            Logger.info('[计划] 1. 扫描 apis 和 addons/*/apis 目录');
-            Logger.info('[计划] 2. 提取每个 API 的配置信息');
-            Logger.info('[计划] 3. 根据 path 检查接口是否存在');
-            Logger.info('[计划] 4. 存在则更新，不存在则新增');
-            Logger.info('[计划] 5. 删除文件中不存在的接口记录');
-            return;
+            return { totalApis: 0, created: 0, updated: 0, deleted: 0 };
         }
 
-        Logger.info('开始同步 API 接口到数据库...\n');
-
         const projectRoot = process.cwd();
 
         // 连接数据库（SQL + Redis）
@@ -289,7 +272,6 @@ export async function syncApiCommand(options: SyncApiOptions = {}) {
         const helper = Database.getDbHelper();
 
         // 1. 检查表是否存在
-        Logger.info('=== 检查数据表 ===');
         const exists = await helper.tableExists('core_api');
 
         if (!exists) {
@@ -297,30 +279,17 @@ export async function syncApiCommand(options: SyncApiOptions = {}) {
             process.exit(1);
         }
 
-        Logger.info(`✅ 表 core_api 存在\n`);
-
         // 2. 扫描所有 API 文件
-        Logger.info('=== 步骤 2: 扫描 API 文件 ===');
         const apis = await scanAllApis(projectRoot);
         const apiPaths = new Set(apis.map((api) => api.path));
-        Logger.info(`\n✅ 共扫描到 ${apis.length} 个 API 接口\n`);
 
         // 3. 同步 API 数据
-        Logger.info('=== 步骤 3: 同步 API 数据（新增/更新） ===');
         const stats = await syncApis(helper, apis);
 
         // 4. 删除文件中不存在的接口
         const deletedCount = await deleteObsoleteRecords(helper, apiPaths);
 
-        // 5. 输出统计信息
-        Logger.info(`\n=== 接口同步完成 ===`);
-        Logger.info(`新增接口: ${stats.created} 个`);
-        Logger.info(`更新接口: ${stats.updated} 个`);
-        Logger.info(`删除接口: ${deletedCount} 个`);
-        Logger.info(`当前总接口数: ${apis.length} 个`);
-
-        // 6. 缓存接口数据到 Redis
-        Logger.info('\n=== 步骤 4: 缓存接口数据到 Redis ===');
+        // 5. 缓存接口数据到 Redis
         try {
             const apiList = await helper.getAll({
                 table: 'core_api',
@@ -328,16 +297,17 @@ export async function syncApiCommand(options: SyncApiOptions = {}) {
                 orderBy: ['addonName#ASC', 'path#ASC']
             });
 
-            const result = await RedisHelper.setObject('apis:all', apiList);
-
-            if (result === null) {
-                Logger.warn('⚠️ 接口缓存失败');
-            } else {
-                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: apis:all)`);
-            }
+            await RedisHelper.setObject('apis:all', apiList);
         } catch (error: any) {
-            Logger.error('⚠️ 接口缓存异常:', error);
+            // 忽略缓存错误
         }
+
+        return {
+            totalApis: apis.length,
+            created: stats.created,
+            updated: stats.updated,
+            deleted: deletedCount
+        };
     } catch (error: any) {
         Logger.error('API 同步失败:', error);
         process.exit(1);

package/commands/syncDb/index.ts

@@ -41,6 +41,21 @@ const globalCount: Record<string, number> = {
     indexDrop: 0
 };
 
+// 导出统计接口
+export interface SyncDbStats {
+    processedTables: number;
+    createdTables: number;
+    modifiedTables: number;
+    addFields: number;
+    nameChanges: number;
+    typeChanges: number;
+    minChanges: number;
+    maxChanges: number;
+    defaultChanges: number;
+    indexCreate: number;
+    indexDrop: number;
+}
+
 /**
  * 主同步函数
  *
@@ -49,15 +64,13 @@ const globalCount: Record<string, number> = {
  * 2. 建立数据库连接并检查版本
  * 3. 扫描表定义文件（核心表、项目表、addon表）
  * 4. 对比并应用表结构变更
- * 5. 输出统计信息
+ * 5. 返回统计信息
  */
-export const SyncDb = async (): Promise<void> => {
+export const SyncDb = async (): Promise<SyncDbStats> => {
     const perfTracker = new PerformanceTracker();
     const progressLogger = new ProgressLogger();
 
     try {
-        Logger.info('开始数据库表结构同步...');
-
         // 重置全局统计，避免多次调用累加
         for (const k of Object.keys(globalCount)) {
             if (typeof globalCount[k] === 'number') globalCount[k] = 0;
@@ -68,13 +81,11 @@ export const SyncDb = async (): Promise<void> => {
         if (!(await checkTable())) {
             throw new Error('表定义验证失败');
         }
-        Logger.info(`✓ 表定义验证完成，耗时: ${perfTracker.getPhaseTime('表定义验证')}`);
 
         // 阶段2：建立数据库连接并检查版本
         perfTracker.markPhase('数据库连接');
         sql = await Database.connectSql({ max: 1 });
         await ensureDbVersion(sql);
-        Logger.info(`✓ 数据库连接建立，耗时: ${perfTracker.getPhaseTime('数据库连接')}`);
 
         // 阶段3：扫描表定义文件
         perfTracker.markPhase('扫描表文件');
@@ -113,7 +124,6 @@ export const SyncDb = async (): Promise<void> => {
             }
         }
         perfTracker.finishPhase('扫描表文件');
-        Logger.info(`✓ 扫描完成，发现 ${totalTables} 个表定义文件，耗时: ${perfTracker.getPhaseTime('扫描表文件')}`);
 
         // 阶段4：处理表文件
         perfTracker.markPhase('同步处理');
@@ -132,7 +142,6 @@ export const SyncDb = async (): Promise<void> => {
 
                 // 跳过以下划线开头的文件（这些是公共字段规则，不是表定义）
                 if (fileName.startsWith('_')) {
-                    Logger.info(`跳过非表定义文件: ${fileName}.json`);
                     continue;
                 }
 
@@ -155,7 +164,6 @@ export const SyncDb = async (): Promise<void> => {
                 }
 
                 processedCount++;
-                progressLogger.logTableProgress(processedCount, totalTables, tableName, dirType);
 
                 const tableDefinition = await Bun.file(file).json();
                 const existsTable = await tableExists(sql!, tableName);
@@ -171,29 +179,21 @@ export const SyncDb = async (): Promise<void> => {
         }
 
         perfTracker.finishPhase('同步处理');
-        Logger.info(`✓ 表处理完成，耗时: ${perfTracker.getPhaseTime('同步处理')}`);
-
-        // 阶段5：显示统计信息
-        Logger.info('\n=== 同步统计信息 ===');
-        Logger.info(`总耗时: ${perfTracker.getTotalTime()}`);
-        Logger.info(`处理表总数: ${globalCount.processedTables}`);
-        Logger.info(`创建表: ${globalCount.createdTables}`);
-        Logger.info(`修改表: ${globalCount.modifiedTables}`);
-        Logger.info(`字段新增: ${globalCount.addFields}`);
-        Logger.info(`字段名称变更: ${globalCount.nameChanges}`);
-        Logger.info(`字段类型变更: ${globalCount.typeChanges}`);
-        Logger.info(`字段最小值变更: ${globalCount.minChanges}`);
-        Logger.info(`字段最大值变更: ${globalCount.maxChanges}`);
-        Logger.info(`字段默认值变更: ${globalCount.defaultChanges}`);
-        Logger.info(`索引新增: ${globalCount.indexCreate}`);
-        Logger.info(`索引删除: ${globalCount.indexDrop}`);
-
-        if (globalCount.processedTables === 0) {
-            Logger.warn('没有找到任何表定义文件');
-        }
 
-        // 输出性能统计
-        perfTracker.logStats();
+        // 返回统计信息
+        return {
+            processedTables: globalCount.processedTables,
+            createdTables: globalCount.createdTables,
+            modifiedTables: globalCount.modifiedTables,
+            addFields: globalCount.addFields,
+            nameChanges: globalCount.nameChanges,
+            typeChanges: globalCount.typeChanges,
+            minChanges: globalCount.minChanges,
+            maxChanges: globalCount.maxChanges,
+            defaultChanges: globalCount.defaultChanges,
+            indexCreate: globalCount.indexCreate,
+            indexDrop: globalCount.indexDrop
+        };
     } catch (error: any) {
         Logger.error(`数据库同步失败`, error);
         process.exit(1);

package/commands/syncDb.ts

@@ -6,14 +6,14 @@ import { Command } from 'commander';
 import { join } from 'pathe';
 import { existsSync } from 'node:fs';
 import { Logger } from '../lib/logger.js';
-import { SyncDb } from './syncDb/index.js';
+import { SyncDb, type SyncDbStats } from './syncDb/index.js';
 
 interface SyncDbOptions {
     table?: string;
     dryRun: boolean;
 }
 
-export async function syncDbCommand(options: SyncDbOptions) {
+export async function syncDbCommand(options: SyncDbOptions): Promise<SyncDbStats> {
     try {
         // 设置环境变量
         if (options.dryRun) {
@@ -24,9 +24,9 @@ export async function syncDbCommand(options: SyncDbOptions) {
             process.env.SYNC_TABLE = options.table;
         }
 
-        // 执行同步
-        await SyncDb();
-        Logger.info('数据库表结构同步完成');
+        // 执行同步并返回统计
+        const stats = await SyncDb();
+        return stats;
     } catch (error: any) {
         Logger.error('数据库同步失败:', error);
         process.exit(1);

package/commands/syncDev.ts

@@ -16,23 +16,26 @@ interface SyncDevOptions {
     plan?: boolean;
 }
 
+export interface SyncDevStats {
+    adminCount: number;
+    roleCount: number;
+    cachedRoles: number;
+}
+
 /**
  * SyncDev 命令主函数
  */
-export async function syncDevCommand(options: SyncDevOptions = {}) {
+export async function syncDevCommand(options: SyncDevOptions = {}): Promise<SyncDevStats> {
     try {
         if (options.plan) {
             Logger.info('[计划] 同步完成后将初始化/更新开发管理员账号（plan 模式不执行）');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         if (!Env.DEV_PASSWORD) {
-            Logger.warn('跳过开发管理员初始化：缺少 DEV_PASSWORD 配置');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
-        Logger.info('开始同步开发管理员账号...\n');
-
         // 连接数据库（SQL + Redis）
         await Database.connect();
 
@@ -41,22 +44,19 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
         // 检查 core_admin 表是否存在
         const existAdmin = await helper.tableExists('core_admin');
         if (!existAdmin) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_admin 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 检查 core_role 表是否存在
         const existRole = await helper.tableExists('core_role');
         if (!existRole) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_role 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 检查 core_menu 表是否存在
         const existMenu = await helper.tableExists('core_menu');
         if (!existMenu) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_menu 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 查询所有菜单 ID
@@ -66,12 +66,10 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
         });
 
         if (!allMenus || !Array.isArray(allMenus)) {
-            Logger.warn('查询菜单失败或菜单表为空');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         const menuIds = allMenus.length > 0 ? allMenus.map((m: any) => m.id).join(',') : '';
-        Logger.info(`查询到 ${allMenus.length} 个菜单，ID 列表: ${menuIds || '(空)'}`);
 
         // 查询所有接口 ID
         const existApi = await helper.tableExists('core_api');
@@ -84,12 +82,7 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
 
             if (allApis && Array.isArray(allApis) && allApis.length > 0) {
                 apiIds = allApis.map((a: any) => a.id).join(',');
-                Logger.info(`查询到 ${allApis.length} 个接口，ID 列表: ${apiIds}`);
-            } else {
-                Logger.info('未查询到接口数据');
             }
-        } else {
-            Logger.info('接口表不存在，跳过接口权限配置');
         }
 
         // 查询或创建 dev 角色
@@ -110,7 +103,6 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                     apis: apiIds
                 }
             });
-            Logger.info('dev 角色菜单和接口权限已更新');
         } else {
             // 创建 dev 角色
             const roleId = await helper.insData({
@@ -149,6 +141,7 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
             where: { email: Env.DEV_EMAIL }
         });
 
+        let isNew = false;
         if (existing) {
             // 更新现有账号
             await helper.updData({
@@ -156,26 +149,23 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                 where: { email: Env.DEV_EMAIL },
                 data: devData
             });
-            Logger.info(`✅ 开发管理员已更新：email=${Env.DEV_EMAIL}, username=dev, roleCode=dev, roleType=admin`);
         } else {
             // 插入新账号
             await helper.insData({
                 table: 'core_admin',
                 data: devData
             });
-            Logger.info(`✅ 开发管理员已初始化：email=${Env.DEV_EMAIL}, username=dev, roleCode=dev, roleType=admin`);
+            isNew = true;
         }
 
         // 缓存角色权限数据到 Redis
-        Logger.info('\n=== 缓存角色权限到 Redis ===');
+        let cachedRolesCount = 0;
         try {
             // 检查必要的表是否存在
             const apiTableExists = await helper.tableExists('core_api');
             const roleTableExists = await helper.tableExists('core_role');
 
-            if (!apiTableExists || !roleTableExists) {
-                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
-            } else {
+            if (apiTableExists && roleTableExists) {
                 // 查询所有角色
                 const roles = await helper.getAll({
                     table: 'core_role',
@@ -189,7 +179,6 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                 });
 
                 const redis = Database.getRedis();
-                let cachedRoles = 0;
 
                 // 为每个角色缓存接口权限
                 for (const role of roles) {
@@ -212,20 +201,33 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                     // 先删除旧数据
                     await redis.del(redisKey);
 
-                    // 批量添加到 Set
-                    const result = await redis.sadd(redisKey, roleApiPaths);
+                    // 批量添加到 Set（使用扩展运算符展开数组）
+                    const result = await redis.sadd(redisKey, ...roleApiPaths);
 
                     if (result > 0) {
-                        cachedRoles++;
-                        Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
+                        cachedRolesCount++;
                     }
                 }
-
-                Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
             }
         } catch (error: any) {
-            Logger.error('⚠️ 角色权限缓存异常:', error);
+            // 忽略缓存错误
         }
+
+        // 获取统计数据
+        const allAdmins = await helper.getAll({
+            table: 'core_admin',
+            fields: ['id']
+        });
+        const allRoles = await helper.getAll({
+            table: 'core_role',
+            fields: ['id']
+        });
+
+        return {
+            adminCount: allAdmins.length,
+            roleCount: allRoles.length,
+            cachedRoles: cachedRolesCount
+        };
     } catch (error: any) {
         Logger.error('开发管理员同步失败:', error);
         process.exit(1);