befly 3.9.38 → 3.9.40

package/tests/dbHelper-columns.test.ts

@@ -3,9 +3,10 @@
  * 测试表字段查询、Redis 缓存、SQL 语法修复等功能
  */
 
-import { test, expect, mock } from 'bun:test';
-import { DbHelper } from '../lib/dbHelper.js';
-import { RedisKeys } from 'befly-shared/redisKeys';
+import { test, expect, mock } from "bun:test";
+
+import { CacheKeys } from "../lib/cacheKeys.js";
+import { DbHelper } from "../lib/dbHelper.js";
 
 // 创建 Mock Befly 上下文
 function createMockBefly(sqlMock: any, redisMock?: any) {
@@ -19,13 +20,13 @@ function createMockBefly(sqlMock: any, redisMock?: any) {
     };
 }
 
-test('getTableColumns - 正常查询表字段', async () => {
-    const mockColumns = [{ Field: 'id' }, { Field: 'username' }, { Field: 'email' }, { Field: 'created_at' }];
+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`');
+            expect(sql).toBe("SHOW COLUMNS FROM `users`");
             return mockColumns;
         })
     };
@@ -39,16 +40,16 @@ test('getTableColumns - 正常查询表字段', async () => {
     const befly = createMockBefly(sqlMock, redisMock);
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const columns = await (dbHelper as any).getTableColumns('users');
+    const columns = await (dbHelper as any).getTableColumns("users");
 
-    expect(columns).toEqual(['id', 'username', 'email', 'created_at']);
+    expect(columns).toEqual(["id", "username", "email", "created_at"]);
     expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
-    expect(redisMock.getObject).toHaveBeenCalledWith(RedisKeys.tableColumns('users'));
+    expect(redisMock.getObject).toHaveBeenCalledWith(CacheKeys.tableColumns("users"));
     expect(redisMock.setObject).toHaveBeenCalled();
 });
 
-test('getTableColumns - Redis 缓存命中', async () => {
-    const cachedColumns = ['id', 'name', 'email'];
+test("getTableColumns - Redis 缓存命中", async () => {
+    const cachedColumns = ["id", "name", "email"];
     const redisMock = {
         getObject: mock(async () => cachedColumns),
         setObject: mock(async () => true),
@@ -57,22 +58,22 @@ test('getTableColumns - Redis 缓存命中', async () => {
 
     const sqlMock = {
         unsafe: mock(async () => {
-            throw new Error('不应该执行 SQL 查询');
+            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');
+    const columns = await (dbHelper as any).getTableColumns("users");
 
     expect(columns).toEqual(cachedColumns);
-    expect(redisMock.getObject).toHaveBeenCalledWith(RedisKeys.tableColumns('users'));
+    expect(redisMock.getObject).toHaveBeenCalledWith(CacheKeys.tableColumns("users"));
     expect(sqlMock.unsafe).not.toHaveBeenCalled(); // SQL 不应该被调用
     expect(redisMock.setObject).not.toHaveBeenCalled(); // 不需要写缓存
 });
 
-test('getTableColumns - 表不存在错误', async () => {
+test("getTableColumns - 表不存在错误", async () => {
     const sqlMock = {
         unsafe: mock(async () => []) // 返回空结果
     };
@@ -87,16 +88,16 @@ test('getTableColumns - 表不存在错误', async () => {
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     try {
-        await (dbHelper as any).getTableColumns('non_existent_table');
+        await (dbHelper as any).getTableColumns("non_existent_table");
         expect(true).toBe(false); // 不应该执行到这里
     } catch (error: any) {
-        expect(error.message).toContain('表 non_existent_table 不存在或没有字段');
+        expect(error.message).toContain("表 non_existent_table 不存在或没有字段");
     }
 });
 
-test('getTableColumns - SQL 语法使用反引号', async () => {
-    const mockColumns = [{ Field: 'id' }];
-    let capturedSql = '';
+test("getTableColumns - SQL 语法使用反引号", async () => {
+    const mockColumns = [{ Field: "id" }];
+    let capturedSql = "";
 
     const sqlMock = {
         unsafe: mock(async (sql: string) => {
@@ -108,16 +109,16 @@ test('getTableColumns - SQL 语法使用反引号', async () => {
     const befly = createMockBefly(sqlMock);
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    await (dbHelper as any).getTableColumns('addon_admin_user');
+    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('`'); // 应该使用反引号
+    expect(capturedSql).toBe("SHOW COLUMNS FROM `addon_admin_user`");
+    expect(capturedSql).not.toContain("??"); // 不应该包含占位符
+    expect(capturedSql).toContain("`"); // 应该使用反引号
 });
 
-test('getTableColumns - 表名特殊字符处理', async () => {
-    const mockColumns = [{ Field: 'id' }];
+test("getTableColumns - 表名特殊字符处理", async () => {
+    const mockColumns = [{ Field: "id" }];
     const sqlMock = {
         unsafe: mock(async () => mockColumns)
     };
@@ -126,16 +127,16 @@ test('getTableColumns - 表名特殊字符处理', async () => {
     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("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`');
+    await (dbHelper as any).getTableColumns("users");
+    expect(sqlMock.unsafe).toHaveBeenLastCalledWith("SHOW COLUMNS FROM `users`");
 });
 
-test('getTableColumns - 缓存键格式正确', async () => {
-    const mockColumns = [{ Field: 'id' }];
+test("getTableColumns - 缓存键格式正确", async () => {
+    const mockColumns = [{ Field: "id" }];
     const sqlMock = {
         unsafe: mock(async () => mockColumns)
     };
@@ -144,7 +145,7 @@ test('getTableColumns - 缓存键格式正确', async () => {
         getObject: mock(async () => null),
         setObject: mock(async (key: string, value: any, seconds: number) => {
             // 验证缓存键格式
-            expect(key).toBe(RedisKeys.tableColumns('test_table'));
+            expect(key).toBe(CacheKeys.tableColumns("test_table"));
             // 验证缓存值格式
             expect(Array.isArray(value)).toBe(true);
             // 验证过期时间
@@ -157,13 +158,13 @@ test('getTableColumns - 缓存键格式正确', async () => {
     const befly = createMockBefly(sqlMock, redisMock);
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    await (dbHelper as any).getTableColumns('test_table');
+    await (dbHelper as any).getTableColumns("test_table");
 
     expect(redisMock.setObject).toHaveBeenCalled();
 });
 
-test('getTableColumns - 多次调用相同表（缓存效果）', async () => {
-    const mockColumns = [{ Field: 'id' }, { Field: 'name' }];
+test("getTableColumns - 多次调用相同表（缓存效果）", async () => {
+    const mockColumns = [{ Field: "id" }, { Field: "name" }];
     let sqlCallCount = 0;
 
     const sqlMock = {
@@ -187,30 +188,30 @@ test('getTableColumns - 多次调用相同表（缓存效果）', async () => {
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     // 第一次调用 - 应该查询数据库
-    const columns1 = await (dbHelper as any).getTableColumns('users');
-    expect(columns1).toEqual(['id', 'name']);
+    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']);
+    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']);
+    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' }];
+test("getTableColumns - Redis 错误处理", async () => {
+    const mockColumns = [{ Field: "id" }];
     const sqlMock = {
         unsafe: mock(async () => mockColumns)
     };
 
     const redisMock = {
         getObject: mock(async () => {
-            throw new Error('Redis 连接失败');
+            throw new Error("Redis 连接失败");
         }),
         setObject: mock(async () => true),
         del: mock(async () => 1)
@@ -220,19 +221,19 @@ test('getTableColumns - Redis 错误处理', async () => {
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     try {
-        await (dbHelper as any).getTableColumns('users');
+        await (dbHelper as any).getTableColumns("users");
         expect(true).toBe(false); // 不应该执行到这里
     } catch (error: any) {
-        expect(error.message).toContain('Redis 连接失败');
+        expect(error.message).toContain("Redis 连接失败");
     }
 });
 
-test('getTableColumns - 字段映射正确性', async () => {
+test("getTableColumns - 字段映射正确性", async () => {
     const mockColumns = [
-        { Field: 'id', Type: 'int' },
-        { Field: 'user_name', Type: 'varchar' },
-        { Field: 'created_at', Type: 'timestamp' },
-        { Field: 'is_active', Type: 'tinyint' }
+        { Field: "id", Type: "int" },
+        { Field: "user_name", Type: "varchar" },
+        { Field: "created_at", Type: "timestamp" },
+        { Field: "is_active", Type: "tinyint" }
     ];
 
     const sqlMock = {
@@ -242,10 +243,10 @@ test('getTableColumns - 字段映射正确性', async () => {
     const befly = createMockBefly(sqlMock);
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const columns = await (dbHelper as any).getTableColumns('users');
+    const columns = await (dbHelper as any).getTableColumns("users");
 
     // 验证只提取 Field 字段
-    expect(columns).toEqual(['id', 'user_name', 'created_at', 'is_active']);
+    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);
+    expect(columns.every((col: string) => typeof col === "string")).toBe(true);
 });

package/tests/dbHelper-execute.test.ts

@@ -3,11 +3,12 @@
  * 测试 SQL 执行、错误处理等功能
  */
 
-import { test, expect, mock } from 'bun:test';
-import { DbHelper } from '../lib/dbHelper.js';
+import { test, expect, mock } from "bun:test";
+
+import { DbHelper } from "../lib/dbHelper.js";
 
 // 创建 Mock Befly 上下文
-function createMockBefly(sqlMock: any) {
+function createMockBefly() {
     return {
         redis: {
             get: mock(async () => null),
@@ -18,73 +19,73 @@ function createMockBefly(sqlMock: any) {
     };
 }
 
-test('executeWithConn - 正常执行（无参数）', async () => {
-    const mockResult = [{ id: 1, name: 'test' }];
+test("executeWithConn - 正常执行（无参数）", async () => {
+    const mockResult = [{ id: 1, name: "test" }];
     const sqlMock = {
         unsafe: mock(async () => mockResult)
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     // 使用反射访问私有方法
-    const result = await (dbHelper as any).executeWithConn('SELECT * FROM users');
+    const result = await (dbHelper as any).executeWithConn("SELECT * FROM users");
 
     expect(result).toEqual(mockResult);
-    expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT * FROM users');
+    expect(sqlMock.unsafe).toHaveBeenCalledWith("SELECT * FROM users");
 });
 
-test('executeWithConn - 正常执行（带参数）', async () => {
-    const mockResult = [{ id: 1, email: 'test@example.com' }];
+test("executeWithConn - 正常执行（带参数）", async () => {
+    const mockResult = [{ id: 1, email: "test@example.com" }];
     const sqlMock = {
         unsafe: mock(async () => mockResult)
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const result = await (dbHelper as any).executeWithConn('SELECT * FROM users WHERE id = ?', [1]);
+    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(sqlMock.unsafe).toHaveBeenCalledWith("SELECT * FROM users WHERE id = ?", [1]);
 });
 
-test('executeWithConn - SQL 错误捕获', async () => {
-    const sqlError = new Error('You have an error in your SQL syntax');
+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 befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     try {
-        await (dbHelper as any).executeWithConn('SELECT * FROM invalid_table');
+        await (dbHelper as any).executeWithConn("SELECT * FROM invalid_table");
         expect(true).toBe(false); // 不应该执行到这里
     } catch (error: any) {
         // 验证错误信息
-        expect(error.message).toContain('SQL执行失败');
+        expect(error.message).toContain("SQL执行失败");
         expect(error.originalError).toBe(sqlError);
-        expect(error.sql).toBe('SELECT * FROM invalid_table');
+        expect(error.sql).toBe("SELECT * FROM invalid_table");
         expect(error.params).toEqual([]);
         expect(error.duration).toBeGreaterThanOrEqual(0);
     }
 });
 
-test('executeWithConn - 错误信息包含完整信息', async () => {
+test("executeWithConn - 错误信息包含完整信息", async () => {
     const sqlMock = {
         unsafe: mock(async () => {
             throw new Error('Syntax error near "??"');
         })
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const testSql = 'SHOW COLUMNS FROM ??';
-    const testParams = ['users'];
+    const testSql = "SHOW COLUMNS FROM ??";
+    const testParams = ["users"];
 
     try {
         await (dbHelper as any).executeWithConn(testSql, testParams);
@@ -92,20 +93,20 @@ test('executeWithConn - 错误信息包含完整信息', async () => {
         // 验证增强的错误对象
         expect(error.sql).toBe(testSql);
         expect(error.params).toEqual(testParams);
-        expect(typeof error.duration).toBe('number');
+        expect(typeof error.duration).toBe("number");
         expect(error.originalError.message).toBe('Syntax error near "??"');
     }
 });
 
-test('executeWithConn - 超长 SQL 保留在错误对象中', async () => {
-    const longSql = 'SELECT * FROM users WHERE ' + 'id = ? AND '.repeat(50) + 'name = ?';
+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');
+            throw new Error("Test error");
         })
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
     try {
@@ -117,7 +118,7 @@ test('executeWithConn - 超长 SQL 保留在错误对象中', async () => {
     }
 });
 
-test('executeWithConn - 慢查询检测（>1000ms）', async () => {
+test("executeWithConn - 慢查询检测（>1000ms）", async () => {
     const mockResult = [{ id: 1 }];
     const sqlMock = {
         unsafe: mock(async () => {
@@ -127,60 +128,60 @@ test('executeWithConn - 慢查询检测（>1000ms）', async () => {
         })
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const result = await (dbHelper as any).executeWithConn('SELECT SLEEP(1)');
+    const result = await (dbHelper as any).executeWithConn("SELECT SLEEP(1)");
 
     // 功能仍正常返回结果
     expect(result).toEqual(mockResult);
 });
 
-test('executeWithConn - 数据库未连接错误', async () => {
+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');
+        await (dbHelper as any).executeWithConn("SELECT * FROM users");
         expect(true).toBe(false); // 不应该执行到这里
     } catch (error: any) {
-        expect(error.message).toBe('数据库连接未初始化');
+        expect(error.message).toBe("数据库连接未初始化");
     }
 });
 
-test('executeWithConn - 空参数数组', async () => {
+test("executeWithConn - 空参数数组", async () => {
     const mockResult = [{ count: 10 }];
     const sqlMock = {
         unsafe: mock(async () => mockResult)
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const result = await (dbHelper as any).executeWithConn('SELECT COUNT(*) as count FROM users', []);
+    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');
+    expect(sqlMock.unsafe).toHaveBeenCalledWith("SELECT COUNT(*) as count FROM users");
 });
 
-test('executeWithConn - 复杂参数处理', async () => {
+test("executeWithConn - 复杂参数处理", async () => {
     const sqlMock = {
         unsafe: mock(async () => {
-            throw new Error('Test error');
+            throw new Error("Test error");
         })
     };
 
-    const befly = createMockBefly(sqlMock);
+    const befly = createMockBefly();
     const dbHelper = new DbHelper(befly as any, sqlMock);
 
-    const complexParams = [1, 'test', { nested: 'object' }, [1, 2, 3], null, undefined];
+    const complexParams = [1, "test", { nested: "object" }, [1, 2, 3], null, undefined];
 
     try {
-        await (dbHelper as any).executeWithConn('SELECT ?', complexParams);
+        await (dbHelper as any).executeWithConn("SELECT ?", complexParams);
     } catch (error: any) {
         // 验证参数被正确保存
         expect(error.params).toEqual(complexParams);
-        expect(error.sql).toBe('SELECT ?');
+        expect(error.sql).toBe("SELECT ?");
     }
 });