befly 3.8.19 → 3.8.21

package/sync/syncMenu.ts

@@ -0,0 +1,331 @@
+/**
+ * SyncMenu 命令 - 同步菜单数据到数据库
+ * 说明：根据 menu.json 配置文件增量同步菜单数据（最多3级：父级、子级、孙级）
+ *
+ * 流程：
+ * 1. 扫描项目根目录和所有 addon 的 menu.json 配置文件
+ * 2. 项目的 menu.json 优先级最高，可以覆盖 addon 的菜单配置
+ * 3. 文件不存在或格式错误时默认为空数组
+ * 4. 根据菜单的 path 字段检查是否存在
+ * 5. 存在则更新其他字段（name、sort、type、pid）
+ * 6. 不存在则新增菜单记录
+ * 7. 强制删除配置中不存在的菜单记录
+ * 注：state 字段由框架自动管理（1=正常，2=禁用，0=删除）
+ */
+
+import { join } from 'pathe';
+import { existsSync } from 'node:fs';
+import { Database } from '../lib/database.js';
+import { RedisHelper } from '../lib/redisHelper.js';
+import { scanAddons, getAddonDir } from 'befly-util';
+import { Logger } from '../lib/logger.js';
+import { projectDir } from '../paths.js';
+
+import type { SyncMenuOptions, MenuConfig, BeflyOptions } from '../types/index.js';
+
+/**
+ * 读取菜单配置文件
+ * 如果文件不存在或不是数组格式，返回空数组
+ */
+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 [];
+    }
+}
+
+/**
+ * 为 addon 菜单的 path 添加前缀
+ * 规则：
+ * 1. 所有路径必须以 / 开头
+ * 2. 所有路径都添加 /addon/{addonName} 前缀（包括根路径 /）
+ * 3. 递归处理所有层级的子菜单
+ * 4. 项目菜单不添加前缀
+ */
+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;
+    });
+}
+
+/**
+ * 合并菜单配置
+ * 优先级：项目 menu.json > addon menu.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>();
+
+        for (const menu of menus) {
+            if (!menu.path) continue;
+
+            const existing = menuMap.get(menu.path);
+            if (existing) {
+                // 合并子菜单
+                if (menu.children?.length > 0) {
+                    existing.children = existing.children || [];
+                    existing.children.push(...menu.children);
+                }
+            } else {
+                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());
+    }
+
+    // 收集所有菜单（扁平化）
+    const allFlatMenus = allMenus.flatMap(({ menus }) => menus);
+
+    return mergeLevel(allFlatMenus, 1);
+}
+
+/**
+ * 收集配置文件中所有菜单的 path（最多3级）
+ * 子级菜单使用独立路径
+ */
+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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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> {
+    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) {
+            await helper.updData({
+                table: 'addon_admin_menu',
+                where: { id: existing.id },
+                data: {
+                    pid: pid,
+                    name: menu.name,
+                    sort: menu.sort || 0
+                }
+            });
+        }
+    } else {
+        menuId = await helper.insData({
+            table: 'addon_admin_menu',
+            data: {
+                pid: pid,
+                name: menu.name,
+                path: menu.path || '',
+                sort: menu.sort || 0
+            }
+        });
+    }
+
+    // 递归处理子菜单（限制最多3层）
+    if (depth < 3 && menu.children?.length > 0) {
+        for (const child of menu.children) {
+            await syncMenuRecursive(helper, child, menuId, existingMenuMap, depth + 1);
+        }
+    }
+
+    return menuId;
+}
+
+/**
+ * 同步菜单（三层结构：父级、子级、孙级）
+ * 子级菜单使用独立路径
+ */
+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']
+    });
+    const existingMenuMap = new Map<string, any>();
+    for (const menu of allExistingMenus) {
+        if (menu.path) {
+            existingMenuMap.set(menu.path, menu);
+        }
+    }
+
+    for (const menu of menus) {
+        try {
+            await syncMenuRecursive(helper, menu, 0, existingMenuMap, 1);
+        } catch (error: any) {
+            Logger.error(`同步菜单 "${menu.name}" 失败`, error.message || String(error));
+            throw error;
+        }
+    }
+}
+
+/**
+ * 删除配置中不存在的菜单（强制删除）
+ */
+async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Promise<void> {
+    const allRecords = await helper.getAll({
+        table: 'addon_admin_menu',
+        fields: ['id', 'path'],
+        where: { state$gte: 0 }
+    });
+
+    for (const record of allRecords) {
+        if (record.path && !configPaths.has(record.path)) {
+            await helper.delForce({
+                table: 'addon_admin_menu',
+                where: { id: record.id }
+            });
+        }
+    }
+}
+
+/**
+ * SyncMenu 命令主函数
+ */
+export async function syncMenuCommand(config: BeflyOptions, options: SyncMenuOptions = {}): Promise<void> {
+    try {
+        if (options.plan) {
+            Logger.debug('[计划] 同步菜单配置到数据库（plan 模式不执行）');
+            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 });
+                }
+            }
+        }
+
+        // 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. 合并菜单配置（项目配置优先）
+        const mergedMenus = mergeMenuConfigs(allMenus);
+
+        // 连接数据库（SQL + Redis）
+        await Database.connect();
+
+        const helper = Database.getDbHelper();
+
+        // 4. 检查表是否存在（addon_admin_menu 来自 addon-admin 组件）
+        const exists = await helper.tableExists('addon_admin_menu');
+
+        if (!exists) {
+            Logger.debug('表 addon_admin_menu 不存在，跳过菜单同步（需要安装 addon-admin 组件）');
+            return;
+        }
+
+        // 5. 收集配置文件中所有菜单的 path
+        const configPaths = collectPaths(mergedMenus);
+
+        // 6. 同步菜单
+        await syncMenus(helper, mergedMenus);
+
+        // 7. 删除文件中不存在的菜单（强制删除）
+        await deleteObsoleteRecords(helper, configPaths);
+
+        // 8. 获取最终菜单数据（用于缓存）
+        const allMenusData = await helper.getAll({
+            table: 'addon_admin_menu',
+            fields: ['id', 'pid', 'name', 'path', 'sort'],
+            orderBy: ['sort#ASC', 'id#ASC']
+        });
+
+        // 9. 缓存菜单数据到 Redis
+        try {
+            const redisHelper = new RedisHelper();
+            await redisHelper.setObject('menus:all', allMenusData);
+        } catch (error: any) {
+            Logger.warn(`Redis 缓存菜单数据失败: ${error.message}`);
+        }
+    } catch (error: any) {
+        Logger.error('菜单同步失败', error);
+        throw error;
+    } finally {
+        await Database?.disconnect();
+    }
+}

package/tests/cipher.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Cipher 加密工具测试
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { Cipher } from '../lib/cipher';
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+describe('Cipher - 哈希功能', () => {
+    const testData = 'hello world';
+    const testDataBytes = new TextEncoder().encode(testData);
+
+    test('MD5 哈希 - 字符串输入', () => {
+        const result = Cipher.md5(testData);
+        expect(result).toBe('5eb63bbbe01eeed093cb22bb8f5acdc3');
+        expect(result.length).toBe(32);
+    });
+
+    test('MD5 哈希 - Uint8Array 输入', () => {
+        const result = Cipher.md5(testDataBytes);
+        expect(result).toBe('5eb63bbbe01eeed093cb22bb8f5acdc3');
+    });
+
+    test('MD5 哈希 - base64 编码', () => {
+        const result = Cipher.md5(testData, 'base64');
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+
+    test('SHA1 哈希', () => {
+        const result = Cipher.sha1(testData);
+        expect(result).toBe('2aae6c35c94fcfb415dbe95f408b9ce91ee846ed');
+        expect(result.length).toBe(40);
+    });
+
+    test('SHA256 哈希', () => {
+        const result = Cipher.sha256(testData);
+        expect(result).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
+        expect(result.length).toBe(64);
+    });
+
+    test('SHA512 哈希', () => {
+        const result = Cipher.sha512(testData);
+        expect(result.length).toBe(128);
+        expect(typeof result).toBe('string');
+    });
+
+    test('通用 hash 方法 - SHA256', () => {
+        const result = Cipher.hash('sha256', testData);
+        expect(result).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
+    });
+
+    test('通用 hash 方法 - MD5', () => {
+        const result = Cipher.hash('md5', testData);
+        expect(result).toBe('5eb63bbbe01eeed093cb22bb8f5acdc3');
+    });
+});
+
+describe('Cipher - HMAC 签名', () => {
+    const key = 'secret-key';
+    const data = 'test data';
+
+    test('HMAC-MD5', () => {
+        const result = Cipher.hmacMd5(key, data);
+        expect(result.length).toBe(32);
+        expect(typeof result).toBe('string');
+    });
+
+    test('HMAC-SHA1', () => {
+        const result = Cipher.hmacSha1(key, data);
+        expect(result.length).toBe(40);
+        expect(typeof result).toBe('string');
+    });
+
+    test('HMAC-SHA256', () => {
+        const result = Cipher.hmacSha256(key, data);
+        expect(result.length).toBe(64);
+        expect(typeof result).toBe('string');
+    });
+
+    test('HMAC-SHA512', () => {
+        const result = Cipher.hmacSha512(key, data);
+        expect(result.length).toBe(128);
+        expect(typeof result).toBe('string');
+    });
+
+    test('通用 HMAC 方法', () => {
+        const result1 = Cipher.hmac('sha256', key, data);
+        const result2 = Cipher.hmacSha256(key, data);
+        expect(result1).toBe(result2);
+    });
+
+    test('HMAC - Uint8Array 输入', () => {
+        const keyBytes = new TextEncoder().encode(key);
+        const dataBytes = new TextEncoder().encode(data);
+        const result = Cipher.hmacSha256(keyBytes, dataBytes);
+        expect(result.length).toBe(64);
+    });
+});
+
+describe('Cipher - 密码加密', () => {
+    const password = 'MySecurePassword123!';
+
+    test('密码哈希', async () => {
+        const hash = await Cipher.hashPassword(password);
+        expect(hash).toBeDefined();
+        expect(hash.length).toBeGreaterThan(0);
+        expect(hash).not.toBe(password);
+    });
+
+    test('密码验证 - 正确密码', async () => {
+        const hash = await Cipher.hashPassword(password);
+        const isValid = await Cipher.verifyPassword(password, hash);
+        expect(isValid).toBe(true);
+    });
+
+    test('密码验证 - 错误密码', async () => {
+        const hash = await Cipher.hashPassword(password);
+        const isValid = await Cipher.verifyPassword('wrong-password', hash);
+        expect(isValid).toBe(false);
+    });
+
+    test('相同密码生成不同哈希', async () => {
+        const hash1 = await Cipher.hashPassword(password);
+        const hash2 = await Cipher.hashPassword(password);
+        expect(hash1).not.toBe(hash2);
+    });
+});
+
+describe('Cipher - Base64 编码', () => {
+    const original = 'Hello, 世界!';
+
+    test('Base64 编码', () => {
+        const encoded = Cipher.base64Encode(original);
+        expect(encoded).toBe('SGVsbG8sIOS4lueVjCE=');
+    });
+
+    test('Base64 解码', () => {
+        const encoded = 'SGVsbG8sIOS4lueVjCE=';
+        const decoded = Cipher.base64Decode(encoded);
+        expect(decoded).toBe(original);
+    });
+
+    test('Base64 编码解码循环', () => {
+        const encoded = Cipher.base64Encode(original);
+        const decoded = Cipher.base64Decode(encoded);
+        expect(decoded).toBe(original);
+    });
+
+    test('Base64 编码空字符串', () => {
+        const encoded = Cipher.base64Encode('');
+        expect(encoded).toBe('');
+    });
+});
+
+describe('Cipher - 随机字符串', () => {
+    test('生成指定长度的随机字符串', () => {
+        const result = Cipher.randomString(16);
+        expect(result.length).toBe(16);
+        expect(/^[0-9a-f]+$/.test(result)).toBe(true);
+    });
+
+    test('生成不同的随机字符串', () => {
+        const result1 = Cipher.randomString(32);
+        const result2 = Cipher.randomString(32);
+        expect(result1).not.toBe(result2);
+    });
+
+    test('生成奇数长度的随机字符串', () => {
+        const result = Cipher.randomString(15);
+        expect(result.length).toBe(15);
+    });
+
+    test('生成 0 长度字符串', () => {
+        const result = Cipher.randomString(0);
+        expect(result).toBe('');
+    });
+});
+
+describe('Cipher - 文件哈希', () => {
+    const testFilePath = join(process.cwd(), 'temp', 'cipher-test-file.txt');
+    const testContent = 'Test file content for hashing';
+
+    beforeAll(() => {
+        const tempDir = join(process.cwd(), 'temp');
+        if (!existsSync(tempDir)) {
+            mkdirSync(tempDir, { recursive: true });
+        }
+        writeFileSync(testFilePath, testContent, 'utf8');
+    });
+
+    test('SHA256 文件哈希', async () => {
+        const result = await Cipher.hashFile(testFilePath, 'sha256');
+        expect(result.length).toBe(64);
+        expect(typeof result).toBe('string');
+    });
+
+    test('MD5 文件哈希', async () => {
+        const result = await Cipher.hashFile(testFilePath, 'md5');
+        expect(result.length).toBe(32);
+    });
+
+    test('文件哈希与内容哈希一致', async () => {
+        const fileHash = await Cipher.hashFile(testFilePath, 'sha256');
+        const contentHash = Cipher.sha256(testContent);
+        expect(fileHash).toBe(contentHash);
+    });
+
+    test('文件哈希 - base64 编码', async () => {
+        const result = await Cipher.hashFile(testFilePath, 'sha256', 'base64');
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+});
+
+describe('Cipher - 快速哈希', () => {
+    const testData = 'quick hash test';
+
+    test('快速哈希 - 字符串输入', () => {
+        const result = Cipher.fastHash(testData);
+        expect(typeof result).toBe('bigint');
+        expect(result).toBeGreaterThan(0n);
+    });
+
+    test('快速哈希 - Uint8Array 输入', () => {
+        const bytes = new TextEncoder().encode(testData);
+        const result = Cipher.fastHash(bytes);
+        expect(typeof result).toBe('bigint');
+    });
+
+    test('快速哈希 - 相同输入产生相同哈希', () => {
+        const result1 = Cipher.fastHash(testData);
+        const result2 = Cipher.fastHash(testData);
+        expect(result1).toBe(result2);
+    });
+
+    test('快速哈希 - 不同 seed 产生不同结果', () => {
+        const result1 = Cipher.fastHash(testData, 0);
+        const result2 = Cipher.fastHash(testData, 1);
+        expect(result1).not.toBe(result2);
+    });
+
+    test('快速哈希 - 空字符串', () => {
+        const result = Cipher.fastHash('');
+        expect(typeof result).toBe('bigint');
+    });
+});