befly 3.8.25 → 3.8.29

package/sync/syncDev.ts

@@ -7,9 +7,12 @@
  * - 表名: addon_admin_admin
  */
 
-import { Database } from '../lib/database.js';
-import { Cipher } from '../lib/cipher.js';
+import { scanAddons, getAddonDir, normalizeModuleForSync } from 'befly-util';
+
 import { Logger } from '../lib/logger.js';
+import { Cipher } from '../lib/cipher.js';
+import { Connect } from '../lib/connect.js';
+import { DbHelper } from '../lib/dbHelper.js';
 import type { SyncDevOptions, SyncDevStats, BeflyOptions } from '../types/index.js';
 
 /**
@@ -22,33 +25,34 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
             return;
         }
 
-        const devPassword = config.devPassword;
-        const devEmail = config.devEmail || 'dev@qq.com';
-
-        if (!devPassword) {
+        if (!config.devPassword) {
+            // 未配置开发者密码，跳过同步
             return;
         }
 
         // 连接数据库（SQL + Redis）
-        await Database.connect();
+        await Connect.connect(config);
 
-        const helper = Database.getDbHelper();
+        const helper = Connect.getDbHelper();
 
         // 检查 addon_admin_admin 表是否存在
         const existAdmin = await helper.tableExists('addon_admin_admin');
         if (!existAdmin) {
+            Logger.debug('[SyncDev] 表 addon_admin_admin 不存在，跳过开发者账号同步');
             return;
         }
 
         // 检查 addon_admin_role 表是否存在
         const existRole = await helper.tableExists('addon_admin_role');
         if (!existRole) {
+            Logger.debug('[SyncDev] 表 addon_admin_role 不存在，跳过开发者账号同步');
             return;
         }
 
         // 检查 addon_admin_menu 表是否存在
         const existMenu = await helper.tableExists('addon_admin_menu');
         if (!existMenu) {
+            Logger.debug('[SyncDev] 表 addon_admin_menu 不存在，跳过开发者账号同步');
             return;
         }
 
@@ -59,6 +63,7 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
         });
 
         if (!allMenus || !Array.isArray(allMenus)) {
+            Logger.debug('[SyncDev] 菜单数据为空，跳过开发者账号同步');
             return;
         }
 
@@ -113,13 +118,12 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
         }
 
         // 使用 bcrypt 加密密码
-        const hashed = await Cipher.hashPassword(devPassword);
+        const hashed = await Cipher.hashPassword(config.devPassword);
 
         // 准备开发管理员数据
         const devData = {
-            name: '开发者',
             nickname: '开发者',
-            email: devEmail,
+            email: config.devEmail,
             username: 'dev',
             password: hashed,
             roleId: devRole.id,
@@ -130,14 +134,14 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
         // 查询现有账号
         const existing = await helper.getOne({
             table: 'addon_admin_admin',
-            where: { email: devEmail }
+            where: { email: config.devEmail }
         });
 
         if (existing) {
             // 更新现有账号
             await helper.updData({
                 table: 'addon_admin_admin',
-                where: { email: devEmail },
+                where: { email: config.devEmail },
                 data: devData
             });
         } else {
@@ -167,7 +171,7 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
                     fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
                 });
 
-                const redis = Database.getRedis();
+                const redis = Connect.getRedis();
 
                 // 为每个角色缓存接口权限
                 for (const role of roles) {
@@ -201,6 +205,6 @@ export async function syncDevCommand(config: BeflyOptions, options: SyncDevOptio
         Logger.error('同步开发者管理员失败', error);
         throw error;
     } finally {
-        await Database?.disconnect();
+        await Connect.disconnect();
     }
 }

package/sync/syncMenu.ts

@@ -1,50 +1,39 @@
 /**
  * SyncMenu 命令 - 同步菜单数据到数据库
- * 说明：根据 menu.json 配置文件增量同步菜单数据（最多3级：父级、子级、孙级）
+ * 说明：根据配置文件增量同步菜单数据（最多3级：父级、子级、孙级）
  *
  * 流程：
- * 1. 扫描项目根目录和所有 addon 的 menu.json 配置文件
- * 2. 项目的 menu.json 优先级最高，可以覆盖 addon 的菜单配置
- * 3. 文件不存在或格式错误时默认为空数组
- * 4. 根据菜单的 path 字段检查是否存在
- * 5. 存在则更新其他字段（name、sort、type、pid）
- * 6. 不存在则新增菜单记录
- * 7. 强制删除配置中不存在的菜单记录
+ * 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. 强制删除配置中不存在的菜单记录
  * 注：state 字段由框架自动管理（1=正常，2=禁用，0=删除）
  */
 
 import { join } from 'pathe';
-import { existsSync } from 'node:fs';
-import { Database } from '../lib/database.js';
+import { cloneDeep } from 'es-toolkit';
+import { Connect } from '../lib/connect.js';
 import { RedisHelper } from '../lib/redisHelper.js';
-import { scanAddons, getAddonDir } from 'befly-util';
+import { scanAddons, getAddonDir, scanConfig } from 'befly-util';
 import { Logger } from '../lib/logger.js';
 import { projectDir } from '../paths.js';
 
 import type { SyncMenuOptions, MenuConfig, BeflyOptions } from '../types/index.js';
 
 /**
- * 读取菜单配置文件
- * 如果文件不存在或不是数组格式，返回空数组
+ * 递归转换菜单路径
+ * @param menu 菜单对象（会被修改）
+ * @param transform 路径转换函数
  */
-async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
-    try {
-        if (!existsSync(filePath)) {
-            return [];
-        }
-
-        const content = await import(filePath, { with: { type: 'json' } });
-
-        // 验证是否为数组
-        if (!Array.isArray(content.default)) {
-            return [];
-        }
-
-        return content.default;
-    } catch (error: any) {
-        Logger.warn(`读取菜单配置失败 ${filePath}: ${error.message}`);
-        return [];
+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));
 }
 
 /**
@@ -57,25 +46,15 @@ async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
  */
 function addAddonPrefix(menus: MenuConfig[], addonName: string): MenuConfig[] {
     return menus.map((menu) => {
-        const newMenu = { ...menu };
-
-        // 处理当前菜单的 path（包括根路径 /）
-        if (newMenu.path && newMenu.path.startsWith('/')) {
-            newMenu.path = `/addon/${addonName}${newMenu.path}`;
-        }
-
-        // 递归处理子菜单
-        if (newMenu.children && newMenu.children.length > 0) {
-            newMenu.children = addAddonPrefix(newMenu.children, addonName);
-        }
-
-        return newMenu;
+        const cloned = cloneDeep(menu);
+        transformMenuPaths(cloned, (path) => `/addon/${addonName}${path}`);
+        return cloned;
     });
 }
 
 /**
  * 合并菜单配置
- * 优先级：项目 menu.json > addon menu.json
+ * 优先级：项目 package.json > addon package.json
  * 支持三级菜单结构：父级、子级、孙级
  */
 function mergeMenuConfigs(allMenus: Array<{ menus: MenuConfig[]; addonName: string }>): MenuConfig[] {
@@ -251,6 +230,58 @@ async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Pro
     }
 }
 
+/**
+ * 加载所有菜单配置（addon + 项目）
+ * @returns 菜单配置数组
+ */
+async function loadMenuConfigs(): Promise<Array<{ menus: MenuConfig[]; addonName: string }>> {
+    const allMenus: Array<{ menus: MenuConfig[]; addonName: string }> = [];
+
+    // 1. 加载所有 addon 配置
+    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 });
+            }
+        } catch (error: any) {
+            Logger.warn(`读取 addon 配置失败 ${addonName}: ${error.message}`);
+        }
+    }
+
+    // 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' });
+        }
+    } catch (error: any) {
+        Logger.warn(`读取项目配置失败: ${error.message}`);
+    }
+
+    return allMenus;
+}
+
 /**
  * SyncMenu 命令主函数
  */
@@ -261,37 +292,18 @@ export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOpt
             return;
         }
 
-        // 1. 扫描所有 addon 的 menu.json 配置文件
-        const allMenus: Array<{ menus: MenuConfig[]; addonName: string }> = [];
-
-        const addonNames = scanAddons();
-
-        for (const addonName of addonNames) {
-            const addonMenuPath = getAddonDir(addonName, 'menu.json');
-            if (existsSync(addonMenuPath)) {
-                const addonMenus = await readMenuConfig(addonMenuPath);
-                if (addonMenus.length > 0) {
-                    // 为 addon 菜单添加路径前缀
-                    const menusWithPrefix = addAddonPrefix(addonMenus, addonName);
-                    allMenus.push({ menus: menusWithPrefix, addonName: addonName });
-                }
-            }
-        }
+        // 1. 加载所有菜单配置（addon + 项目）
+        const allMenus = await loadMenuConfigs();
 
-        // 2. 读取项目根目录的 menu.json（优先级最高，不添加前缀）
-        const projectMenuPath = join(projectDir, 'menu.json');
-        const projectMenus = await readMenuConfig(projectMenuPath);
-        if (projectMenus.length > 0) {
-            allMenus.push({ menus: projectMenus, addonName: 'project' });
-        } // 3. 合并菜单配置（项目配置优先）
+        // 2. 合并菜单配置
         const mergedMenus = mergeMenuConfigs(allMenus);
 
         // 连接数据库（SQL + Redis）
-        await Database.connect();
+        await Connect.connect(config);
 
-        const helper = Database.getDbHelper();
+        const helper = Connect.getDbHelper();
 
-        // 4. 检查表是否存在（addon_admin_menu 来自 addon-admin 组件）
+        // 3. 检查表是否存在（addon_admin_menu 来自 addon-admin 组件）
         const exists = await helper.tableExists('addon_admin_menu');
 
         if (!exists) {
@@ -299,23 +311,23 @@ export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOpt
             return;
         }
 
-        // 5. 收集配置文件中所有菜单的 path
+        // 4. 收集配置文件中所有菜单的 path
         const configPaths = collectPaths(mergedMenus);
 
-        // 6. 同步菜单
+        // 5. 同步菜单
         await syncMenus(helper, mergedMenus);
 
-        // 7. 删除文件中不存在的菜单（强制删除）
+        // 6. 删除文件中不存在的菜单（强制删除）
         await deleteObsoleteRecords(helper, configPaths);
 
-        // 8. 获取最终菜单数据（用于缓存）
+        // 7. 获取最终菜单数据（用于缓存）
         const allMenusData = await helper.getAll({
             table: 'addon_admin_menu',
             fields: ['id', 'pid', 'name', 'path', 'sort'],
             orderBy: ['sort#ASC', 'id#ASC']
         });
 
-        // 9. 缓存菜单数据到 Redis
+        // 8. 缓存菜单数据到 Redis
         try {
             const redisHelper = new RedisHelper();
             await redisHelper.setObject('menus:all', allMenusData);
@@ -326,6 +338,6 @@ export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOpt
         Logger.error('菜单同步失败', error);
         throw error;
     } finally {
-        await Database?.disconnect();
+        await Connect.disconnect();
     }
 }

package/tests/redisHelper.test.ts

@@ -3,29 +3,24 @@
  * 测试 Redis 操作功能
  */
 
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { Database } from '../lib/database.js';
-import { RedisHelper } from '../lib/redisHelper.js';
+import { describe, expect, it, test, beforeAll, afterAll } from 'bun:test';
+import { RedisClient } from 'bun';
+
 import { defaultOptions } from '../config.js';
+import { Connect } from '../lib/connect.js';
+import { RedisHelper } from '../lib/redisHelper.js';
 
 let redis: RedisHelper;
 
 beforeAll(async () => {
-    // 使用项目默认配置连接 Redis
-    await Database.connectRedis(defaultOptions.redis);
-    // 使用项目配置的 prefix
-    redis = new RedisHelper(defaultOptions.redis.prefix);
+    // 连接 Redis
+    await Connect.connectRedis(defaultOptions.redis);
+    redis = new RedisHelper();
 });
 
 afterAll(async () => {
-    // 清理测试数据
-    await redis.del('test:string');
-    await redis.del('test:object');
-    await redis.del('test:set');
-    await redis.del('test:ttl');
-    await redis.del('test:expire');
-
-    await Database.disconnectRedis();
+    // 断开 Redis 连接
+    await Connect.disconnectRedis();
 });
 
 describe('RedisHelper - 字符串操作', () => {
@@ -102,11 +97,15 @@ describe('RedisHelper - 对象操作', () => {
 
 describe('RedisHelper - Set 操作', () => {
     test('sadd - 添加成员到 Set', async () => {
-        const count = await redis.sadd('test:set', ['member1', 'member2', 'member3']);
+        // 先清除，确保测试隔离
+        await redis.del('test:set:sadd');
+        const count = await redis.sadd('test:set:sadd', ['member1', 'member2', 'member3']);
         expect(count).toBeGreaterThan(0);
+        await redis.del('test:set:sadd');
     });
 
     test('sismember - 检查成员是否存在', async () => {
+        await redis.del('test:set');
         await redis.sadd('test:set', ['member1']);
 
         const exists = await redis.sismember('test:set', 'member1');

package/tests/sync-connection.test.ts

@@ -0,0 +1,189 @@
+/**
+ * sync 模块连接管理集成测试
+ * 验证数据库连接的正确关闭
+ */
+import { describe, test, expect, afterEach } from 'bun:test';
+
+import { Connect } from '../lib/connect.js';
+
+describe('sync 模块连接管理', () => {
+    afterEach(() => {
+        // 每个测试后重置连接状态
+        Connect.__reset();
+    });
+
+    describe('Connect.isConnected', () => {
+        test('初始状态应该都是未连接', () => {
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(false);
+            expect(status.redis).toBe(false);
+        });
+    });
+
+    describe('Connect.disconnect', () => {
+        test('disconnect 应该能安全地关闭未连接的状态', async () => {
+            // 即使没有连接，disconnect 也不应该抛出错误
+            await expect(Connect.disconnect()).resolves.toBeUndefined();
+        });
+
+        test('disconnectSql 应该能安全地关闭未连接的状态', async () => {
+            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
+        });
+
+        test('disconnectRedis 应该能安全地关闭未连接的状态', async () => {
+            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
+        });
+    });
+
+    describe('Connect.getSql', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getSql()).toThrow('SQL 客户端未连接');
+        });
+    });
+
+    describe('Connect.getRedis', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getRedis()).toThrow('Redis 客户端未连接');
+        });
+    });
+
+    describe('Connect.getDbHelper', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getDbHelper()).toThrow('SQL 客户端未连接');
+        });
+    });
+
+    describe('Mock 连接测试', () => {
+        test('__setMockSql 应该设置 mock SQL 客户端', () => {
+            const mockSql = { close: async () => {} } as any;
+            Connect.__setMockSql(mockSql);
+
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(true);
+            expect(status.redis).toBe(false);
+        });
+
+        test('__setMockRedis 应该设置 mock Redis 客户端', () => {
+            const mockRedis = { close: () => {} } as any;
+            Connect.__setMockRedis(mockRedis);
+
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(false);
+            expect(status.redis).toBe(true);
+        });
+
+        test('__reset 应该重置所有连接', () => {
+            const mockSql = { close: async () => {} } as any;
+            const mockRedis = { close: () => {} } as any;
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            expect(Connect.isConnected().sql).toBe(true);
+            expect(Connect.isConnected().redis).toBe(true);
+
+            Connect.__reset();
+
+            expect(Connect.isConnected().sql).toBe(false);
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+
+        test('disconnect 应该正确关闭 mock 连接', async () => {
+            let sqlClosed = false;
+            let redisClosed = false;
+
+            const mockSql = {
+                close: async () => {
+                    sqlClosed = true;
+                }
+            } as any;
+            const mockRedis = {
+                close: () => {
+                    redisClosed = true;
+                }
+            } as any;
+
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            await Connect.disconnect();
+
+            expect(sqlClosed).toBe(true);
+            expect(redisClosed).toBe(true);
+            expect(Connect.isConnected().sql).toBe(false);
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+    });
+
+    describe('连接异常处理', () => {
+        test('disconnectSql 应该处理关闭时的错误', async () => {
+            const mockSql = {
+                close: async () => {
+                    throw new Error('Close error');
+                }
+            } as any;
+
+            Connect.__setMockSql(mockSql);
+
+            // 不应该抛出错误，只是记录日志
+            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
+            expect(Connect.isConnected().sql).toBe(false);
+        });
+
+        test('disconnectRedis 应该处理关闭时的错误', async () => {
+            const mockRedis = {
+                close: () => {
+                    throw new Error('Close error');
+                }
+            } as any;
+
+            Connect.__setMockRedis(mockRedis);
+
+            // 不应该抛出错误，只是记录日志
+            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+    });
+
+    describe('Connect.getStatus', () => {
+        test('未连接时返回正确的状态', () => {
+            const status = Connect.getStatus();
+
+            expect(status.sql.connected).toBe(false);
+            expect(status.sql.connectedAt).toBeNull();
+            expect(status.sql.uptime).toBeNull();
+            expect(status.sql.poolMax).toBe(1);
+
+            expect(status.redis.connected).toBe(false);
+            expect(status.redis.connectedAt).toBeNull();
+            expect(status.redis.uptime).toBeNull();
+        });
+
+        test('Mock 连接后返回正确的状态', () => {
+            const mockSql = { close: async () => {} } as any;
+            const mockRedis = { close: () => {} } as any;
+
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            const status = Connect.getStatus();
+
+            // Mock 不会设置连接时间，但连接状态应该为 true
+            expect(status.sql.connected).toBe(true);
+            expect(status.redis.connected).toBe(true);
+        });
+
+        test('__reset 应该重置所有状态包括连接时间', () => {
+            const mockSql = { close: async () => {} } as any;
+            Connect.__setMockSql(mockSql);
+
+            expect(Connect.getStatus().sql.connected).toBe(true);
+
+            Connect.__reset();
+
+            const status = Connect.getStatus();
+            expect(status.sql.connected).toBe(false);
+            expect(status.sql.connectedAt).toBeNull();
+            expect(status.sql.poolMax).toBe(1);
+        });
+    });
+});