befly 3.8.20 → 3.8.24

package/tests/dbHelper-columns.test.ts

@@ -0,0 +1,266 @@
+/**
+ * DbHelper getTableColumns 方法单元测试
+ * 测试表字段查询、Redis 缓存、SQL 语法修复等功能
+ */
+
+import { test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { DbHelper } from '../lib/dbHelper.js';
+import { Logger } from '../lib/logger.js';
+
+// Mock Logger
+const originalLoggerError = Logger.error;
+let errorLogs: string[] = [];
+
+beforeEach(() => {
+    errorLogs = [];
+    Logger.error = mock((msg: string) => {
+        errorLogs.push(msg);
+    });
+});
+
+afterEach(() => {
+    Logger.error = originalLoggerError;
+});
+
+// 创建 Mock Befly 上下文
+function createMockBefly(sqlMock: any, redisMock?: any) {
+    return {
+        redis: redisMock || {
+            getObject: mock(async () => null),
+            setObject: mock(async () => true),
+            del: mock(async () => 1)
+        },
+        db: null
+    };
+}
+
+test('getTableColumns - 正常查询表字段', async () => {
+    const mockColumns = [{ Field: 'id' }, { Field: 'username' }, { Field: 'email' }, { Field: 'created_at' }];
+
+    const sqlMock = {
+        unsafe: mock(async (sql: string) => {
+            // 验证 SQL 语法正确（使用反引号）
+            expect(sql).toBe('SHOW COLUMNS FROM `users`');
+            return mockColumns;
+        })
+    };
+
+    const redisMock = {
+        getObject: mock(async () => null), // 缓存未命中
+        setObject: mock(async () => true),
+        del: mock(async () => 1)
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const columns = await (dbHelper as any).getTableColumns('users');
+
+    expect(columns).toEqual(['id', 'username', 'email', 'created_at']);
+    expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
+    expect(redisMock.getObject).toHaveBeenCalledWith('table:columns:users');
+    expect(redisMock.setObject).toHaveBeenCalled();
+});
+
+test('getTableColumns - Redis 缓存命中', async () => {
+    const cachedColumns = ['id', 'name', 'email'];
+    const redisMock = {
+        getObject: mock(async () => cachedColumns),
+        setObject: mock(async () => true),
+        del: mock(async () => 1)
+    };
+
+    const sqlMock = {
+        unsafe: mock(async () => {
+            throw new Error('不应该执行 SQL 查询');
+        })
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const columns = await (dbHelper as any).getTableColumns('users');
+
+    expect(columns).toEqual(cachedColumns);
+    expect(redisMock.getObject).toHaveBeenCalledWith('table:columns:users');
+    expect(sqlMock.unsafe).not.toHaveBeenCalled(); // SQL 不应该被调用
+    expect(redisMock.setObject).not.toHaveBeenCalled(); // 不需要写缓存
+});
+
+test('getTableColumns - 表不存在错误', async () => {
+    const sqlMock = {
+        unsafe: mock(async () => []) // 返回空结果
+    };
+
+    const redisMock = {
+        getObject: mock(async () => null),
+        setObject: mock(async () => true),
+        del: mock(async () => 1)
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    try {
+        await (dbHelper as any).getTableColumns('non_existent_table');
+        expect(true).toBe(false); // 不应该执行到这里
+    } catch (error: any) {
+        expect(error.message).toContain('表 non_existent_table 不存在或没有字段');
+    }
+});
+
+test('getTableColumns - SQL 语法使用反引号', async () => {
+    const mockColumns = [{ Field: 'id' }];
+    let capturedSql = '';
+
+    const sqlMock = {
+        unsafe: mock(async (sql: string) => {
+            capturedSql = sql;
+            return mockColumns;
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    await (dbHelper as any).getTableColumns('addon_admin_user');
+
+    // 验证 SQL 语法
+    expect(capturedSql).toBe('SHOW COLUMNS FROM `addon_admin_user`');
+    expect(capturedSql).not.toContain('??'); // 不应该包含占位符
+    expect(capturedSql).toContain('`'); // 应该使用反引号
+});
+
+test('getTableColumns - 表名特殊字符处理', async () => {
+    const mockColumns = [{ Field: 'id' }];
+    const sqlMock = {
+        unsafe: mock(async () => mockColumns)
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    // 测试下划线表名
+    await (dbHelper as any).getTableColumns('addon_admin_user');
+    expect(sqlMock.unsafe).toHaveBeenLastCalledWith('SHOW COLUMNS FROM `addon_admin_user`');
+
+    // 测试普通表名
+    await (dbHelper as any).getTableColumns('users');
+    expect(sqlMock.unsafe).toHaveBeenLastCalledWith('SHOW COLUMNS FROM `users`');
+});
+
+test('getTableColumns - 缓存键格式正确', async () => {
+    const mockColumns = [{ Field: 'id' }];
+    const sqlMock = {
+        unsafe: mock(async () => mockColumns)
+    };
+
+    const redisMock = {
+        getObject: mock(async () => null),
+        setObject: mock(async (key: string, value: any, seconds: number) => {
+            // 验证缓存键格式
+            expect(key).toBe('table:columns:test_table');
+            // 验证缓存值格式
+            expect(Array.isArray(value)).toBe(true);
+            // 验证过期时间
+            expect(seconds).toBe(3600); // 1 小时
+            return true;
+        }),
+        del: mock(async () => 1)
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    await (dbHelper as any).getTableColumns('test_table');
+
+    expect(redisMock.setObject).toHaveBeenCalled();
+});
+
+test('getTableColumns - 多次调用相同表（缓存效果）', async () => {
+    const mockColumns = [{ Field: 'id' }, { Field: 'name' }];
+    let sqlCallCount = 0;
+
+    const sqlMock = {
+        unsafe: mock(async () => {
+            sqlCallCount++;
+            return mockColumns;
+        })
+    };
+
+    const cache: Record<string, any> = {};
+    const redisMock = {
+        getObject: mock(async (key: string) => cache[key] || null),
+        setObject: mock(async (key: string, value: any) => {
+            cache[key] = value;
+            return true;
+        }),
+        del: mock(async () => 1)
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    // 第一次调用 - 应该查询数据库
+    const columns1 = await (dbHelper as any).getTableColumns('users');
+    expect(columns1).toEqual(['id', 'name']);
+    expect(sqlCallCount).toBe(1);
+
+    // 第二次调用 - 应该从缓存读取
+    const columns2 = await (dbHelper as any).getTableColumns('users');
+    expect(columns2).toEqual(['id', 'name']);
+    expect(sqlCallCount).toBe(1); // SQL 调用次数不变
+
+    // 第三次调用 - 仍然从缓存读取
+    const columns3 = await (dbHelper as any).getTableColumns('users');
+    expect(columns3).toEqual(['id', 'name']);
+    expect(sqlCallCount).toBe(1);
+});
+
+test('getTableColumns - Redis 错误处理', async () => {
+    const mockColumns = [{ Field: 'id' }];
+    const sqlMock = {
+        unsafe: mock(async () => mockColumns)
+    };
+
+    const redisMock = {
+        getObject: mock(async () => {
+            throw new Error('Redis 连接失败');
+        }),
+        setObject: mock(async () => true),
+        del: mock(async () => 1)
+    };
+
+    const befly = createMockBefly(sqlMock, redisMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    try {
+        await (dbHelper as any).getTableColumns('users');
+        expect(true).toBe(false); // 不应该执行到这里
+    } catch (error: any) {
+        expect(error.message).toContain('Redis 连接失败');
+    }
+});
+
+test('getTableColumns - 字段映射正确性', async () => {
+    const mockColumns = [
+        { Field: 'id', Type: 'int' },
+        { Field: 'user_name', Type: 'varchar' },
+        { Field: 'created_at', Type: 'timestamp' },
+        { Field: 'is_active', Type: 'tinyint' }
+    ];
+
+    const sqlMock = {
+        unsafe: mock(async () => mockColumns)
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const columns = await (dbHelper as any).getTableColumns('users');
+
+    // 验证只提取 Field 字段
+    expect(columns).toEqual(['id', 'user_name', 'created_at', 'is_active']);
+    expect(columns.length).toBe(4);
+    expect(columns.every((col: string) => typeof col === 'string')).toBe(true);
+});

package/tests/dbHelper-execute.test.ts

@@ -0,0 +1,240 @@
+/**
+ * DbHelper executeWithConn 方法单元测试
+ * 测试 SQL 执行、错误处理、慢查询日志等功能
+ */
+
+import { test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { DbHelper } from '../lib/dbHelper.js';
+import { Logger } from '../lib/logger.js';
+
+// Mock Logger
+const originalLoggerError = Logger.error;
+const originalLoggerWarn = Logger.warn;
+let errorLogs: string[] = [];
+let warnLogs: string[] = [];
+
+beforeEach(() => {
+    errorLogs = [];
+    warnLogs = [];
+    Logger.error = mock((msg: string) => {
+        errorLogs.push(msg);
+    });
+    Logger.warn = mock((msg: string) => {
+        warnLogs.push(msg);
+    });
+});
+
+afterEach(() => {
+    Logger.error = originalLoggerError;
+    Logger.warn = originalLoggerWarn;
+});
+
+// 创建 Mock Befly 上下文
+function createMockBefly(sqlMock: any) {
+    return {
+        redis: {
+            get: mock(async () => null),
+            set: mock(async () => true),
+            del: mock(async () => 1)
+        },
+        db: null
+    };
+}
+
+test('executeWithConn - 正常执行（无参数）', async () => {
+    const mockResult = [{ id: 1, name: 'test' }];
+    const sqlMock = {
+        unsafe: mock(async () => mockResult)
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    // 使用反射访问私有方法
+    const result = await (dbHelper as any).executeWithConn('SELECT * FROM users');
+
+    expect(result).toEqual(mockResult);
+    expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT * FROM users');
+    expect(errorLogs.length).toBe(0);
+});
+
+test('executeWithConn - 正常执行（带参数）', async () => {
+    const mockResult = [{ id: 1, email: 'test@example.com' }];
+    const sqlMock = {
+        unsafe: mock(async () => mockResult)
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const result = await (dbHelper as any).executeWithConn('SELECT * FROM users WHERE id = ?', [1]);
+
+    expect(result).toEqual(mockResult);
+    expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT * FROM users WHERE id = ?', [1]);
+    expect(errorLogs.length).toBe(0);
+});
+
+test('executeWithConn - SQL 错误捕获', async () => {
+    const sqlError = new Error('You have an error in your SQL syntax');
+    const sqlMock = {
+        unsafe: mock(async () => {
+            throw sqlError;
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    try {
+        await (dbHelper as any).executeWithConn('SELECT * FROM invalid_table');
+        expect(true).toBe(false); // 不应该执行到这里
+    } catch (error: any) {
+        // 验证错误信息
+        expect(error.message).toContain('SQL执行失败');
+        expect(error.originalError).toBe(sqlError);
+        expect(error.sql).toBe('SELECT * FROM invalid_table');
+        expect(error.params).toEqual([]);
+        expect(error.duration).toBeGreaterThanOrEqual(0);
+
+        // 验证错误日志
+        expect(errorLogs.length).toBeGreaterThan(0);
+        expect(errorLogs.some((log) => log.includes('SQL 执行错误'))).toBe(true);
+        expect(errorLogs.some((log) => log.includes('SELECT * FROM invalid_table'))).toBe(true);
+        expect(errorLogs.some((log) => log.includes('You have an error in your SQL syntax'))).toBe(true);
+    }
+});
+
+test('executeWithConn - 错误日志包含完整信息', async () => {
+    const sqlMock = {
+        unsafe: mock(async () => {
+            throw new Error('Syntax error near "??"');
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const testSql = 'SHOW COLUMNS FROM ??';
+    const testParams = ['users'];
+
+    try {
+        await (dbHelper as any).executeWithConn(testSql, testParams);
+    } catch (error: any) {
+        // 验证增强的错误对象
+        expect(error.sql).toBe(testSql);
+        expect(error.params).toEqual(testParams);
+        expect(typeof error.duration).toBe('number');
+
+        // 验证日志内容
+        const allLogs = errorLogs.join('\n');
+        expect(allLogs).toContain('SQL 语句:');
+        expect(allLogs).toContain('SHOW COLUMNS FROM ??');
+        expect(allLogs).toContain('参数列表:');
+        expect(allLogs).toContain('["users"]');
+        expect(allLogs).toContain('执行耗时:');
+        expect(allLogs).toContain('错误信息:');
+        expect(allLogs).toContain('Syntax error near "??"');
+    }
+});
+
+test('executeWithConn - 超长 SQL 截断', async () => {
+    const longSql = 'SELECT * FROM users WHERE ' + 'id = ? AND '.repeat(50) + 'name = ?';
+    const sqlMock = {
+        unsafe: mock(async () => {
+            throw new Error('Test error');
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    try {
+        await (dbHelper as any).executeWithConn(longSql);
+    } catch (error: any) {
+        // SQL 应该被截断
+        expect(error.sql).toBe(longSql); // 完整保存在错误对象中
+
+        // 日志中应该截断并加 ...
+        const sqlLog = errorLogs.find((log) => log.includes('SQL 语句:'));
+        expect(sqlLog).toBeDefined();
+        if (sqlLog) {
+            expect(sqlLog.length).toBeLessThan(longSql.length + 50); // 截断后应该更短
+            expect(sqlLog).toContain('...');
+        }
+    }
+});
+
+test('executeWithConn - 慢查询日志（>1000ms）', async () => {
+    const mockResult = [{ id: 1 }];
+    const sqlMock = {
+        unsafe: mock(async () => {
+            // 模拟慢查询
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            return mockResult;
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const result = await (dbHelper as any).executeWithConn('SELECT SLEEP(1)');
+
+    expect(result).toEqual(mockResult);
+    expect(warnLogs.length).toBeGreaterThan(0);
+    expect(warnLogs.some((log) => log.includes('🐌 检测到慢查询'))).toBe(true);
+    expect(warnLogs.some((log) => log.includes('ms'))).toBe(true);
+});
+
+test('executeWithConn - 数据库未连接错误', async () => {
+    const befly = createMockBefly(null);
+    const dbHelper = new DbHelper(befly as any, null); // 没有 sql 实例
+
+    try {
+        await (dbHelper as any).executeWithConn('SELECT * FROM users');
+        expect(true).toBe(false); // 不应该执行到这里
+    } catch (error: any) {
+        expect(error.message).toBe('数据库连接未初始化');
+    }
+});
+
+test('executeWithConn - 空参数数组', async () => {
+    const mockResult = [{ count: 10 }];
+    const sqlMock = {
+        unsafe: mock(async () => mockResult)
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const result = await (dbHelper as any).executeWithConn('SELECT COUNT(*) as count FROM users', []);
+
+    expect(result).toEqual(mockResult);
+    // 空数组应该走 else 分支（不传参数）
+    expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT COUNT(*) as count FROM users');
+});
+
+test('executeWithConn - 参数 JSON 序列化', async () => {
+    const sqlMock = {
+        unsafe: mock(async () => {
+            throw new Error('Test error');
+        })
+    };
+
+    const befly = createMockBefly(sqlMock);
+    const dbHelper = new DbHelper(befly as any, sqlMock);
+
+    const complexParams = [1, 'test', { nested: 'object' }, [1, 2, 3], null, undefined];
+
+    try {
+        await (dbHelper as any).executeWithConn('SELECT ?', complexParams);
+    } catch (error: any) {
+        // 验证参数被正确序列化
+        const paramsLog = errorLogs.find((log) => log.includes('参数列表:'));
+        expect(paramsLog).toBeDefined();
+        if (paramsLog) {
+            // JSON.stringify 应该能处理复杂参数
+            expect(paramsLog).toContain('参数列表:');
+            expect(() => JSON.parse(paramsLog.split('参数列表:')[1].trim())).not.toThrow();
+        }
+    }
+});

package/tests/fields-redis-cache.test.ts

@@ -0,0 +1,123 @@
+/**
+ * 验证 Redis 缓存的字段查询功能
+ */
+
+console.log('\n========== Redis 缓存验证 ==========\n');
+
+// 模拟 Redis 缓存逻辑
+class MockRedis {
+    private cache: Map<string, { value: any; expire: number }> = new Map();
+
+    async getObject<T>(key: string): Promise<T | null> {
+        const cached = this.cache.get(key);
+        if (cached && cached.expire > Date.now()) {
+            console.log(`✅ Redis 缓存命中: ${key}`);
+            return cached.value as T;
+        }
+        console.log(`❌ Redis 缓存未命中: ${key}`);
+        return null;
+    }
+
+    async setObject(key: string, value: any, ttl: number): Promise<void> {
+        this.cache.set(key, {
+            value: value,
+            expire: Date.now() + ttl * 1000
+        });
+        console.log(`📝 写入 Redis 缓存: ${key} (TTL: ${ttl}s)`);
+    }
+}
+
+// 模拟数据库查询
+async function queryDatabase(table: string): Promise<string[]> {
+    console.log(`🔍 查询数据库表结构: ${table}`);
+    // 模拟数据库延迟
+    await new Promise((resolve) => setTimeout(resolve, 3));
+    return ['id', 'name', 'email', 'password', 'salt', 'created_at'];
+}
+
+// 模拟 getTableColumns 方法
+async function getTableColumns(redis: MockRedis, table: string): Promise<string[]> {
+    // 1. 先查 Redis 缓存
+    const cacheKey = `table:columns:${table}`;
+    let columns = await redis.getObject<string[]>(cacheKey);
+
+    if (columns && columns.length > 0) {
+        return columns;
+    }
+
+    // 2. 缓存未命中，查询数据库
+    columns = await queryDatabase(table);
+
+    // 3. 写入 Redis 缓存（1小时过期）
+    await redis.setObject(cacheKey, columns, 3600);
+
+    return columns;
+}
+
+async function test() {
+    const redis = new MockRedis();
+
+    console.log('【场景1】单进程多次查询\n');
+
+    // 第1次查询（缓存未命中）
+    console.log('--- 第1次查询 user 表 ---');
+    const start1 = Date.now();
+    const columns1 = await getTableColumns(redis, 'user');
+    const time1 = Date.now() - start1;
+    console.log(`结果: ${columns1.join(', ')}`);
+    console.log(`耗时: ${time1}ms\n`);
+
+    // 第2次查询（缓存命中）
+    console.log('--- 第2次查询 user 表 ---');
+    const start2 = Date.now();
+    const columns2 = await getTableColumns(redis, 'user');
+    const time2 = Date.now() - start2;
+    console.log(`结果: ${columns2.join(', ')}`);
+    console.log(`耗时: ${time2}ms\n`);
+
+    // 第3次查询（缓存命中）
+    console.log('--- 第3次查询 user 表 ---');
+    const start3 = Date.now();
+    const columns3 = await getTableColumns(redis, 'user');
+    const time3 = Date.now() - start3;
+    console.log(`结果: ${columns3.join(', ')}`);
+    console.log(`耗时: ${time3}ms\n`);
+
+    console.log('【场景2】模拟 PM2 cluster（多进程共享 Redis）\n');
+
+    // 模拟 Worker 1 查询
+    console.log('--- Worker 1 查询 article 表 ---');
+    const worker1Start = Date.now();
+    const worker1Columns = await getTableColumns(redis, 'article');
+    const worker1Time = Date.now() - worker1Start;
+    console.log(`结果: ${worker1Columns.join(', ')}`);
+    console.log(`耗时: ${worker1Time}ms\n`);
+
+    // 模拟 Worker 2 查询（共享 Redis 缓存）
+    console.log('--- Worker 2 查询 article 表 ---');
+    const worker2Start = Date.now();
+    const worker2Columns = await getTableColumns(redis, 'article');
+    const worker2Time = Date.now() - worker2Start;
+    console.log(`结果: ${worker2Columns.join(', ')}`);
+    console.log(`耗时: ${worker2Time}ms`);
+    console.log(`✅ Worker 2 直接使用 Worker 1 的缓存，无需再查数据库\n`);
+
+    // 模拟 Worker 3 查询（共享 Redis 缓存）
+    console.log('--- Worker 3 查询 article 表 ---');
+    const worker3Start = Date.now();
+    const worker3Columns = await getTableColumns(redis, 'article');
+    const worker3Time = Date.now() - worker3Start;
+    console.log(`结果: ${worker3Columns.join(', ')}`);
+    console.log(`耗时: ${worker3Time}ms`);
+    console.log(`✅ Worker 3 直接使用 Worker 1 的缓存，无需再查数据库\n`);
+
+    console.log('========== 验证完成 ==========\n');
+
+    console.log('📊 性能总结:');
+    console.log(`- 首次查询（数据库）: ${time1}ms`);
+    console.log(`- 后续查询（Redis）: ${time2}ms`);
+    console.log(`- 性能提升: ${(time1 / time2).toFixed(1)}x`);
+    console.log(`- PM2 cluster: ✅ 所有 worker 共享同一份 Redis 缓存`);
+}
+
+test();