befly 3.9.38 → 3.9.39

package/tests/dbHelper-advanced.test.ts

@@ -3,117 +3,117 @@
  * 测试边界条件、错误处理、复杂场景
  */
 
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect } from "bun:test";
 
-describe('DbHelper - 字段验证逻辑', () => {
-    test('validateAndClassifyFields - 空数组应返回 all 类型', () => {
+describe("DbHelper - 字段验证逻辑", () => {
+    test("validateAndClassifyFields - 空数组应返回 all 类型", () => {
         // 测试目的：验证空数组被正确识别为查询所有字段
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
                 if (!fields || fields.length === 0) {
-                    return { type: 'all' as const, fields: [] };
+                    return { type: "all" as const, fields: [] };
                 }
-                return { type: 'include' as const, fields: fields };
+                return { type: "include" as const, fields: fields };
             }
         };
 
         const result = mockHelper.validateAndClassifyFields([]);
-        expect(result.type).toBe('all');
+        expect(result.type).toBe("all");
         expect(result.fields.length).toBe(0);
     });
 
-    test('validateAndClassifyFields - undefined 应返回 all 类型', () => {
+    test("validateAndClassifyFields - undefined 应返回 all 类型", () => {
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
                 if (!fields || fields.length === 0) {
-                    return { type: 'all' as const, fields: [] };
+                    return { type: "all" as const, fields: [] };
                 }
-                return { type: 'include' as const, fields: fields };
+                return { type: "include" as const, fields: fields };
             }
         };
 
         const result = mockHelper.validateAndClassifyFields(undefined);
-        expect(result.type).toBe('all');
+        expect(result.type).toBe("all");
     });
 
-    test('validateAndClassifyFields - 星号应抛出错误', () => {
+    test("validateAndClassifyFields - 星号应抛出错误", () => {
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
                 if (!fields || fields.length === 0) {
-                    return { type: 'all' as const, fields: [] };
+                    return { type: "all" as const, fields: [] };
                 }
-                if (fields.some((f) => f === '*')) {
-                    throw new Error('fields 不支持 * 星号');
+                if (fields.some((f) => f === "*")) {
+                    throw new Error("fields 不支持 * 星号");
                 }
-                return { type: 'include' as const, fields: fields };
+                return { type: "include" as const, fields: fields };
             }
         };
 
         expect(() => {
-            mockHelper.validateAndClassifyFields(['id', '*', 'name']);
-        }).toThrow('fields 不支持 * 星号');
+            mockHelper.validateAndClassifyFields(["id", "*", "name"]);
+        }).toThrow("fields 不支持 * 星号");
     });
 
-    test('validateAndClassifyFields - 空字符串应抛出错误', () => {
+    test("validateAndClassifyFields - 空字符串应抛出错误", () => {
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
-                if (fields.some((f) => !f || typeof f !== 'string' || f.trim() === '')) {
-                    throw new Error('fields 不能包含空字符串或无效值');
+                if (fields.some((f) => !f || typeof f !== "string" || f.trim() === "")) {
+                    throw new Error("fields 不能包含空字符串或无效值");
                 }
-                return { type: 'include' as const, fields: fields };
+                return { type: "include" as const, fields: fields };
             }
         };
 
         expect(() => {
-            mockHelper.validateAndClassifyFields(['id', '', 'name']);
-        }).toThrow('fields 不能包含空字符串或无效值');
+            mockHelper.validateAndClassifyFields(["id", "", "name"]);
+        }).toThrow("fields 不能包含空字符串或无效值");
     });
 
-    test('validateAndClassifyFields - 混用包含和排除字段应抛出错误', () => {
+    test("validateAndClassifyFields - 混用包含和排除字段应抛出错误", () => {
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
-                const includeFields = fields!.filter((f) => !f.startsWith('!'));
-                const excludeFields = fields!.filter((f) => f.startsWith('!'));
+                const includeFields = fields!.filter((f) => !f.startsWith("!"));
+                const excludeFields = fields!.filter((f) => f.startsWith("!"));
 
                 if (includeFields.length > 0 && excludeFields.length > 0) {
-                    throw new Error('fields 不能同时包含普通字段和排除字段');
+                    throw new Error("fields 不能同时包含普通字段和排除字段");
                 }
 
                 if (excludeFields.length > 0) {
-                    return { type: 'exclude' as const, fields: excludeFields.map((f) => f.substring(1)) };
+                    return { type: "exclude" as const, fields: excludeFields.map((f) => f.substring(1)) };
                 }
 
-                return { type: 'include' as const, fields: includeFields };
+                return { type: "include" as const, fields: includeFields };
             }
         };
 
         expect(() => {
-            mockHelper.validateAndClassifyFields(['id', '!password', 'name']);
-        }).toThrow('fields 不能同时包含普通字段和排除字段');
+            mockHelper.validateAndClassifyFields(["id", "!password", "name"]);
+        }).toThrow("fields 不能同时包含普通字段和排除字段");
     });
 
-    test('validateAndClassifyFields - 排除字段应正确去除感叹号', () => {
+    test("validateAndClassifyFields - 排除字段应正确去除感叹号", () => {
         const mockHelper = {
             validateAndClassifyFields: (fields?: string[]) => {
-                const excludeFields = fields!.filter((f) => f.startsWith('!'));
-                return { type: 'exclude' as const, fields: excludeFields.map((f) => f.substring(1)) };
+                const excludeFields = fields!.filter((f) => f.startsWith("!"));
+                return { type: "exclude" as const, fields: excludeFields.map((f) => f.substring(1)) };
             }
         };
 
-        const result = mockHelper.validateAndClassifyFields(['!password', '!token', '!salt']);
-        expect(result.type).toBe('exclude');
-        expect(result.fields).toEqual(['password', 'token', 'salt']);
+        const result = mockHelper.validateAndClassifyFields(["!password", "!token", "!salt"]);
+        expect(result.type).toBe("exclude");
+        expect(result.fields).toEqual(["password", "token", "salt"]);
     });
 });
 
-describe('DbHelper - BIGINT 字段转换逻辑', () => {
-    test('convertBigIntFields - 白名单字段应转换', () => {
+describe("DbHelper - BIGINT 字段转换逻辑", () => {
+    test("convertBigIntFields - 白名单字段应转换", () => {
         const mockConvert = (arr: any[]) => {
             return arr.map((item) => {
                 const converted = { ...item };
-                const whiteList = ['id', 'pid', 'sort'];
+                const whiteList = ["id", "pid", "sort"];
                 for (const key of whiteList) {
-                    if (key in converted && typeof converted[key] === 'string') {
+                    if (key in converted && typeof converted[key] === "string") {
                         converted[key] = Number(converted[key]);
                     }
                 }
@@ -121,21 +121,21 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
             });
         };
 
-        const data = [{ id: '123', pid: '456', sort: '10', name: 'test' }];
+        const data = [{ id: "123", pid: "456", sort: "10", name: "test" }];
         const result = mockConvert(data);
 
         expect(result[0].id).toBe(123);
         expect(result[0].pid).toBe(456);
         expect(result[0].sort).toBe(10);
-        expect(typeof result[0].id).toBe('number');
+        expect(typeof result[0].id).toBe("number");
     });
 
-    test('convertBigIntFields - Id 后缀字段应转换', () => {
+    test("convertBigIntFields - Id 后缀字段应转换", () => {
         const mockConvert = (arr: any[]) => {
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const [key, value] of Object.entries(converted)) {
-                    if ((key.endsWith('Id') || key.endsWith('_id')) && typeof value === 'string') {
+                    if ((key.endsWith("Id") || key.endsWith("_id")) && typeof value === "string") {
                         converted[key] = Number(value);
                     }
                 }
@@ -143,7 +143,7 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
             });
         };
 
-        const data = [{ userId: '100', roleId: '200', category_id: '300', name: 'test' }];
+        const data = [{ userId: "100", roleId: "200", category_id: "300", name: "test" }];
         const result = mockConvert(data);
 
         expect(result[0].userId).toBe(100);
@@ -151,12 +151,12 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
         expect(result[0].category_id).toBe(300);
     });
 
-    test('convertBigIntFields - At 后缀字段应转换（时间戳）', () => {
+    test("convertBigIntFields - At 后缀字段应转换（时间戳）", () => {
         const mockConvert = (arr: any[]) => {
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const [key, value] of Object.entries(converted)) {
-                    if ((key.endsWith('At') || key.endsWith('_at')) && typeof value === 'string') {
+                    if ((key.endsWith("At") || key.endsWith("_at")) && typeof value === "string") {
                         converted[key] = Number(value);
                     }
                 }
@@ -164,7 +164,7 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
             });
         };
 
-        const data = [{ createdAt: '1609459200000', updatedAt: '1609459300000', deleted_at: '0' }];
+        const data = [{ createdAt: "1609459200000", updatedAt: "1609459300000", deleted_at: "0" }];
         const result = mockConvert(data);
 
         expect(result[0].createdAt).toBe(1609459200000);
@@ -172,12 +172,12 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
         expect(result[0].deleted_at).toBe(0);
     });
 
-    test('convertBigIntFields - 非数字字符串不应转换', () => {
+    test("convertBigIntFields - 非数字字符串不应转换", () => {
         const mockConvert = (arr: any[]) => {
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const [key, value] of Object.entries(converted)) {
-                    if (key.endsWith('Id') && typeof value === 'string') {
+                    if (key.endsWith("Id") && typeof value === "string") {
                         const num = Number(value);
                         if (!isNaN(num)) {
                             converted[key] = num;
@@ -188,20 +188,20 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
             });
         };
 
-        const data = [{ userId: 'invalid', roleId: '123' }];
+        const data = [{ userId: "invalid", roleId: "123" }];
         const result = mockConvert(data);
 
-        expect(result[0].userId).toBe('invalid'); // 保持原值
+        expect(result[0].userId).toBe("invalid"); // 保持原值
         expect(result[0].roleId).toBe(123);
     });
 
-    test('convertBigIntFields - null 和 undefined 应跳过', () => {
+    test("convertBigIntFields - null 和 undefined 应跳过", () => {
         const mockConvert = (arr: any[]) => {
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const [key, value] of Object.entries(converted)) {
                     if (value === null || value === undefined) continue;
-                    if (key.endsWith('Id') && typeof value === 'string') {
+                    if (key.endsWith("Id") && typeof value === "string") {
                         converted[key] = Number(value);
                     }
                 }
@@ -209,7 +209,7 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
             });
         };
 
-        const data = [{ userId: null, roleId: undefined, categoryId: '123' }];
+        const data = [{ userId: null, roleId: undefined, categoryId: "123" }];
         const result = mockConvert(data);
 
         expect(result[0].userId).toBeNull();
@@ -217,7 +217,7 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
         expect(result[0].categoryId).toBe(123);
     });
 
-    test('convertBigIntFields - 空数组应返回空数组', () => {
+    test("convertBigIntFields - 空数组应返回空数组", () => {
         const mockConvert = (arr: any[]) => {
             if (!arr || !Array.isArray(arr)) return arr;
             return arr;
@@ -227,7 +227,7 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
         expect(result).toEqual([]);
     });
 
-    test('convertBigIntFields - 非数组应返回原值', () => {
+    test("convertBigIntFields - 非数组应返回原值", () => {
         const mockConvert = (arr: any) => {
             if (!arr || !Array.isArray(arr)) return arr;
             return arr;
@@ -238,8 +238,8 @@ describe('DbHelper - BIGINT 字段转换逻辑', () => {
     });
 });
 
-describe('DbHelper - WHERE 条件键名转换', () => {
-    test('whereKeysToSnake - 简单字段名应转换为下划线', () => {
+describe("DbHelper - WHERE 条件键名转换", () => {
+    test("whereKeysToSnake - 简单字段名应转换为下划线", () => {
         const snakeCase = (str: string) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 
         const mockConvert = (where: any): any => {
@@ -250,21 +250,21 @@ describe('DbHelper - WHERE 条件键名转换', () => {
             return result;
         };
 
-        const where = { userId: 123, userName: 'john' };
+        const where = { userId: 123, userName: "john" };
         const result = mockConvert(where);
 
         expect(result.user_id).toBe(123);
-        expect(result.user_name).toBe('john');
+        expect(result.user_name).toBe("john");
     });
 
-    test('whereKeysToSnake - 带操作符的字段名应正确处理', () => {
+    test("whereKeysToSnake - 带操作符的字段名应正确处理", () => {
         const snakeCase = (str: string) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 
         const mockConvert = (where: any): any => {
             const result: any = {};
             for (const [key, value] of Object.entries(where)) {
-                if (key.includes('$')) {
-                    const lastDollarIndex = key.lastIndexOf('$');
+                if (key.includes("$")) {
+                    const lastDollarIndex = key.lastIndexOf("$");
                     const fieldName = key.substring(0, lastDollarIndex);
                     const operator = key.substring(lastDollarIndex);
                     result[snakeCase(fieldName) + operator] = value;
@@ -275,25 +275,25 @@ describe('DbHelper - WHERE 条件键名转换', () => {
             return result;
         };
 
-        const where = { userId$gt: 100, userName$like: '%john%' };
+        const where = { userId$gt: 100, userName$like: "%john%" };
         const result = mockConvert(where);
 
         expect(result.user_id$gt).toBe(100);
-        expect(result.user_name$like).toBe('%john%');
+        expect(result.user_name$like).toBe("%john%");
     });
 
-    test('whereKeysToSnake - $or 和 $and 应递归处理', () => {
+    test("whereKeysToSnake - $or 和 $and 应递归处理", () => {
         const snakeCase = (str: string) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 
         const mockConvert = (where: any): any => {
-            if (!where || typeof where !== 'object') return where;
+            if (!where || typeof where !== "object") return where;
             if (Array.isArray(where)) {
                 return where.map((item) => mockConvert(item));
             }
 
             const result: any = {};
             for (const [key, value] of Object.entries(where)) {
-                if (key === '$or' || key === '$and') {
+                if (key === "$or" || key === "$and") {
                     result[key] = (value as any[]).map((item) => mockConvert(item));
                 } else {
                     result[snakeCase(key)] = value;
@@ -303,24 +303,24 @@ describe('DbHelper - WHERE 条件键名转换', () => {
         };
 
         const where = {
-            $or: [{ userId: 1 }, { userName: 'john' }]
+            $or: [{ userId: 1 }, { userName: "john" }]
         };
         const result = mockConvert(where);
 
         expect(result.$or[0].user_id).toBe(1);
-        expect(result.$or[1].user_name).toBe('john');
+        expect(result.$or[1].user_name).toBe("john");
     });
 
-    test('whereKeysToSnake - 嵌套对象应递归转换', () => {
+    test("whereKeysToSnake - 嵌套对象应递归转换", () => {
         const snakeCase = (str: string) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 
         const mockConvert = (where: any): any => {
-            if (!where || typeof where !== 'object') return where;
+            if (!where || typeof where !== "object") return where;
 
             const result: any = {};
             for (const [key, value] of Object.entries(where)) {
                 const snakeKey = snakeCase(key);
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                if (typeof value === "object" && value !== null && !Array.isArray(value)) {
                     result[snakeKey] = mockConvert(value);
                 } else {
                     result[snakeKey] = value;
@@ -331,19 +331,19 @@ describe('DbHelper - WHERE 条件键名转换', () => {
 
         const where = {
             userProfile: {
-                firstName: 'John',
-                lastName: 'Doe'
+                firstName: "John",
+                lastName: "Doe"
             }
         };
         const result = mockConvert(where);
 
-        expect(result.user_profile.first_name).toBe('John');
-        expect(result.user_profile.last_name).toBe('Doe');
+        expect(result.user_profile.first_name).toBe("John");
+        expect(result.user_profile.last_name).toBe("Doe");
     });
 });
 
-describe('DbHelper - 默认状态过滤', () => {
-    test('addDefaultStateFilter - 应添加 state > 0 条件', () => {
+describe("DbHelper - 默认状态过滤", () => {
+    test("addDefaultStateFilter - 应添加 state > 0 条件", () => {
         const mockAddFilter = (where: any) => {
             return {
                 ...where,
@@ -358,13 +358,13 @@ describe('DbHelper - 默认状态过滤', () => {
         expect(result.state$gt).toBe(0);
     });
 
-    test('addDefaultStateFilter - 已有 state 条件不应覆盖', () => {
+    test("addDefaultStateFilter - 已有 state 条件不应覆盖", () => {
         // **潜在问题**：如果用户传入 state: 0（查询已删除数据），
         // addDefaultStateFilter 可能会添加 state$gt: 0，导致冲突
 
         const mockAddFilter = (where: any) => {
             // 正确做法：检查是否已有 state 相关条件
-            if ('state' in where || 'state$gt' in where || 'state$gte' in where) {
+            if ("state" in where || "state$gt" in where || "state$gte" in where) {
                 return where; // 不添加默认过滤
             }
             return {
@@ -384,49 +384,49 @@ describe('DbHelper - 默认状态过滤', () => {
     });
 });
 
-describe('DbHelper - 分页参数验证', () => {
-    test('getList - page 小于 1 应抛出错误', () => {
-        const mockValidate = (page: number, limit: number) => {
+describe("DbHelper - 分页参数验证", () => {
+    test("getList - page 小于 1 应抛出错误", () => {
+        const mockValidate = (page: number, _limit: number) => {
             if (page < 1 || page > 10000) {
                 throw new Error(`页码必须在 1 到 10000 之间 (page: ${page})`);
             }
         };
 
-        expect(() => mockValidate(0, 10)).toThrow('页码必须在 1 到 10000 之间');
-        expect(() => mockValidate(-5, 10)).toThrow('页码必须在 1 到 10000 之间');
+        expect(() => mockValidate(0, 10)).toThrow("页码必须在 1 到 10000 之间");
+        expect(() => mockValidate(-5, 10)).toThrow("页码必须在 1 到 10000 之间");
     });
 
-    test('getList - page 大于 10000 应抛出错误', () => {
+    test("getList - page 大于 10000 应抛出错误", () => {
         const mockValidate = (page: number) => {
             if (page > 10000) {
                 throw new Error(`页码必须在 1 到 10000 之间 (page: ${page})`);
             }
         };
 
-        expect(() => mockValidate(10001)).toThrow('页码必须在 1 到 10000 之间');
+        expect(() => mockValidate(10001)).toThrow("页码必须在 1 到 10000 之间");
     });
 
-    test('getList - limit 小于 1 应抛出错误', () => {
+    test("getList - limit 小于 1 应抛出错误", () => {
         const mockValidate = (limit: number) => {
             if (limit < 1 || limit > 1000) {
                 throw new Error(`每页数量必须在 1 到 1000 之间 (limit: ${limit})`);
             }
         };
 
-        expect(() => mockValidate(0)).toThrow('每页数量必须在 1 到 1000 之间');
+        expect(() => mockValidate(0)).toThrow("每页数量必须在 1 到 1000 之间");
     });
 
-    test('getList - limit 大于 1000 应抛出错误', () => {
+    test("getList - limit 大于 1000 应抛出错误", () => {
         const mockValidate = (limit: number) => {
             if (limit > 1000) {
                 throw new Error(`每页数量必须在 1 到 1000 之间 (limit: ${limit})`);
             }
         };
 
-        expect(() => mockValidate(1001)).toThrow('每页数量必须在 1 到 1000 之间');
+        expect(() => mockValidate(1001)).toThrow("每页数量必须在 1 到 1000 之间");
     });
 
-    test('getList - 边界值测试', () => {
+    test("getList - 边界值测试", () => {
         const mockValidate = (page: number, limit: number) => {
             if (page < 1 || page > 10000) {
                 throw new Error(`页码无效`);
@@ -443,8 +443,8 @@ describe('DbHelper - 分页参数验证', () => {
     });
 });
 
-describe('DbHelper - 总数为 0 的优化', () => {
-    test('getList - 总数为 0 应直接返回空结果', async () => {
+describe("DbHelper - 总数为 0 的优化", () => {
+    test("getList - 总数为 0 应直接返回空结果", async () => {
         const mockGetList = async (total: number, page: number, limit: number) => {
             if (total === 0) {
                 return {
@@ -471,7 +471,7 @@ describe('DbHelper - 总数为 0 的优化', () => {
         expect(result.pages).toBe(0);
     });
 
-    test('getList - pages 计算应正确', () => {
+    test("getList - pages 计算应正确", () => {
         const calcPages = (total: number, limit: number) => Math.ceil(total / limit);
 
         expect(calcPages(100, 10)).toBe(10); // 整除
@@ -481,8 +481,8 @@ describe('DbHelper - 总数为 0 的优化', () => {
     });
 });
 
-describe('DbHelper - 字段清理逻辑', () => {
-    test('cleanFields - 应排除 null 和 undefined', () => {
+describe("DbHelper - 字段清理逻辑", () => {
+    test("cleanFields - 应排除 null 和 undefined", () => {
         const mockClean = (data: any) => {
             const result: any = {};
             for (const [key, value] of Object.entries(data)) {
@@ -493,16 +493,16 @@ describe('DbHelper - 字段清理逻辑', () => {
             return result;
         };
 
-        const data = { name: 'test', age: null, email: undefined, score: 0 };
+        const data = { name: "test", age: null, email: undefined, score: 0 };
         const result = mockClean(data);
 
-        expect(result.name).toBe('test');
+        expect(result.name).toBe("test");
         expect(result.age).toBeUndefined();
         expect(result.email).toBeUndefined();
         expect(result.score).toBe(0); // 0 应保留
     });
 
-    test('cleanFields - 空对象应返回空对象', () => {
+    test("cleanFields - 空对象应返回空对象", () => {
         const mockClean = (data: any) => {
             if (!data || Object.keys(data).length === 0) return {};
             return data;
@@ -514,12 +514,12 @@ describe('DbHelper - 字段清理逻辑', () => {
     });
 });
 
-describe('DbHelper - SQL 执行错误处理', () => {
-    test('executeWithConn - SQL 错误应包含完整信息', () => {
+describe("DbHelper - SQL 执行错误处理", () => {
+    test("executeWithConn - SQL 错误应包含完整信息", () => {
         const mockExecute = async (sql: string, params?: any[]) => {
             try {
                 // 模拟 SQL 错误
-                throw new Error('Table not found');
+                throw new Error("Table not found");
             } catch (error: any) {
                 const errorMsg = `SQL 执行失败 - ${error.message} - SQL: ${sql} - 参数: ${JSON.stringify(params)}`;
                 throw new Error(errorMsg);
@@ -527,28 +527,28 @@ describe('DbHelper - SQL 执行错误处理', () => {
         };
 
         expect(async () => {
-            await mockExecute('SELECT * FROM non_existent_table', []);
+            await mockExecute("SELECT * FROM non_existent_table", []);
         }).toThrow();
     });
 
-    test('executeWithConn - 超长 SQL 应截断', () => {
+    test("executeWithConn - 超长 SQL 应截断", () => {
         const mockTruncate = (sql: string, maxLength: number = 500) => {
             if (sql.length > maxLength) {
-                return sql.substring(0, maxLength) + '...';
+                return sql.substring(0, maxLength) + "...";
             }
             return sql;
         };
 
-        const longSql = 'SELECT * FROM users WHERE ' + 'name = ? AND '.repeat(100) + 'id = ?';
+        const longSql = "SELECT * FROM users WHERE " + "name = ? AND ".repeat(100) + "id = ?";
         const truncated = mockTruncate(longSql, 100);
 
         expect(truncated.length).toBeLessThanOrEqual(103); // 100 + "..."
-        expect(truncated.endsWith('...')).toBe(true);
+        expect(truncated.endsWith("...")).toBe(true);
     });
 });
 
-describe('DbHelper - 代码逻辑问题分析', () => {
-    test('问题1：addDefaultStateFilter 可能覆盖用户的 state 条件', () => {
+describe("DbHelper - 代码逻辑问题分析", () => {
+    test("问题1：addDefaultStateFilter 可能覆盖用户的 state 条件", () => {
         // **问题描述**：
         // 当前实现：addDefaultStateFilter 直接添加 state$gt: 0
         // 问题：如果用户想查询 state=0（已删除）或 state=2（已禁用）的数据，
@@ -565,7 +565,7 @@ describe('DbHelper - 代码逻辑问题分析', () => {
 
         const betterImpl = (where: any) => {
             // 检查是否已有 state 条件
-            const hasStateCondition = Object.keys(where).some((key) => key === 'state' || key.startsWith('state$'));
+            const hasStateCondition = Object.keys(where).some((key) => key === "state" || key.startsWith("state$"));
 
             if (hasStateCondition) {
                 return where; // 不添加默认过滤
@@ -588,7 +588,7 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         expect(result2.state$gt).toBeUndefined(); // 正确
     });
 
-    test('问题2：getTableColumns 缓存键没有区分数据库', () => {
+    test("问题2：getTableColumns 缓存键没有区分数据库", () => {
         // **问题描述**：
         // 缓存键格式：table:columns:${table}
         // 问题：如果连接多个数据库，不同数据库的同名表会共享缓存
@@ -601,15 +601,15 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         const betterCacheKey = (dbName: string, table: string) => `table:columns:${dbName}:${table}`;
 
         // 问题示例
-        expect(currentCacheKey('user')).toBe('table:columns:user');
+        expect(currentCacheKey("user")).toBe("table:columns:user");
         // db1.user 和 db2.user 会冲突
 
         // 改进后
-        expect(betterCacheKey('db1', 'user')).toBe('table:columns:db1:user');
-        expect(betterCacheKey('db2', 'user')).toBe('table:columns:db2:user');
+        expect(betterCacheKey("db1", "user")).toBe("table:columns:db1:user");
+        expect(betterCacheKey("db2", "user")).toBe("table:columns:db2:user");
     });
 
-    test('问题3：convertBigIntFields 白名单硬编码', () => {
+    test("问题3：convertBigIntFields 白名单硬编码", () => {
         // **问题描述**：
         // 白名单字段硬编码为 ['id', 'pid', 'sort']
         // 问题：如果有其他 BIGINT 字段不符合命名规则，需要修改源码
@@ -619,11 +619,11 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         // 2. 或者从表结构元数据中自动获取 BIGINT 字段
 
         const currentImpl = (arr: any[]) => {
-            const whiteList = ['id', 'pid', 'sort']; // 硬编码
+            const whiteList = ["id", "pid", "sort"]; // 硬编码
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const key of whiteList) {
-                    if (key in converted && typeof converted[key] === 'string') {
+                    if (key in converted && typeof converted[key] === "string") {
                         converted[key] = Number(converted[key]);
                     }
                 }
@@ -632,13 +632,13 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         };
 
         const betterImpl = (arr: any[], customWhiteList?: string[]) => {
-            const defaultWhiteList = ['id', 'pid', 'sort'];
+            const defaultWhiteList = ["id", "pid", "sort"];
             const whiteList = customWhiteList || defaultWhiteList;
 
             return arr.map((item) => {
                 const converted = { ...item };
                 for (const key of whiteList) {
-                    if (key in converted && typeof converted[key] === 'string') {
+                    if (key in converted && typeof converted[key] === "string") {
                         converted[key] = Number(converted[key]);
                     }
                 }
@@ -647,12 +647,18 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         };
 
         // 改进后支持自定义
-        const data = [{ id: '123', customId: '456' }];
-        const result = betterImpl(data, ['id', 'customId']);
+        const data = [{ id: "123", customId: "456" }];
+
+        // 当前实现：只能转换硬编码白名单字段
+        const currentResult = currentImpl(data);
+        expect(currentResult[0].id).toBe(123);
+        expect(currentResult[0].customId).toBe("456");
+
+        const result = betterImpl(data, ["id", "customId"]);
         expect(result[0].customId).toBe(456);
     });
 
-    test('问题4：executeWithConn 没有超时保护', async () => {
+    test("问题4：executeWithConn 没有超时保护", async () => {
         // **问题描述**：
         // 当前实现没有查询超时限制
         // 问题：慢查询可能导致长时间阻塞
@@ -662,7 +668,7 @@ describe('DbHelper - 代码逻辑问题分析', () => {
 
         const mockExecuteWithTimeout = async (sql: string, params: any[], timeout: number = 30000) => {
             const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('查询超时')), timeout);
+                setTimeout(() => reject(new Error("查询超时")), timeout);
             });
 
             const queryPromise = new Promise((resolve) => {
@@ -673,19 +679,19 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         };
 
         // 正常查询
-        const result = await mockExecuteWithTimeout('SELECT * FROM users', [], 1000);
+        const result = await mockExecuteWithTimeout("SELECT * FROM users", [], 1000);
         expect(result).toBeDefined();
 
         // 超时查询
         try {
-            await mockExecuteWithTimeout('SELECT * FROM users', [], 10); // 10ms 超时
+            await mockExecuteWithTimeout("SELECT * FROM users", [], 10); // 10ms 超时
             expect(true).toBe(false); // 不应执行到这里
         } catch (error: any) {
-            expect(error.message).toContain('查询超时');
+            expect(error.message).toContain("查询超时");
         }
     });
 
-    test('问题5：getAll 的 MAX_LIMIT 保护不够完善', async () => {
+    test("问题5：getAll 的 MAX_LIMIT 保护不够完善", async () => {
         // **问题描述**：
         // getAll 设置了 MAX_LIMIT = 10000
         // 问题：但没有检测实际查询的数据量，可能超过限制
@@ -707,11 +713,11 @@ describe('DbHelper - 代码逻辑问题分析', () => {
         };
 
         try {
-            await betterGetAll('users', 10000);
+            await betterGetAll("users", 10000);
             expect(true).toBe(false);
         } catch (error: any) {
-            expect(error.message).toContain('数据量过大');
-            expect(error.message).toContain('请使用 getList 分页查询');
+            expect(error.message).toContain("数据量过大");
+            expect(error.message).toContain("请使用 getList 分页查询");
         }
     });
 });