befly 3.10.0 → 3.10.2

package/tests/dbHelper-all-array-types.test.ts

@@ -1,316 +0,0 @@
-/**
- * 验证所有数组类型的序列化/反序列化支持
- *
- * 测试类型：
- * - array_string
- * - array_text
- * - array_number_string
- * - array_number_text
- */
-
-import { describe, expect, test } from "bun:test";
-
-describe("所有数组类型的序列化/反序列化支持", () => {
-    // 模拟 serializeArrayFields 方法
-    const serializeArrayFields = (data: Record<string, any>): Record<string, any> => {
-        const serialized = { ...data };
-
-        for (const [key, value] of Object.entries(serialized)) {
-            if (value === null || value === undefined) continue;
-
-            if (Array.isArray(value)) {
-                serialized[key] = JSON.stringify(value);
-            }
-        }
-
-        return serialized;
-    };
-
-    // 模拟 deserializeArrayFields 方法
-    const deserializeArrayFields = <T = any>(data: Record<string, any> | null): T | null => {
-        if (!data) return null;
-
-        const deserialized = { ...data };
-
-        for (const [key, value] of Object.entries(deserialized)) {
-            if (typeof value !== "string") continue;
-
-            if (value.startsWith("[") && value.endsWith("]")) {
-                try {
-                    const parsed = JSON.parse(value);
-                    if (Array.isArray(parsed)) {
-                        deserialized[key] = parsed;
-                    }
-                } catch {
-                    // 解析失败则保持原值
-                }
-            }
-        }
-
-        return deserialized as T;
-    };
-
-    // ==================== array_string 类型 ====================
-
-    test("array_string: 字符串数组序列化和反序列化", () => {
-        const data = {
-            tags: ["tag1", "tag2", "tag3"]
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(serialized.tags).toBe('["tag1","tag2","tag3"]');
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.tags).toEqual(["tag1", "tag2", "tag3"]);
-    });
-
-    test("array_string: 空数组", () => {
-        const data = {
-            tags: []
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(serialized.tags).toBe("[]");
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.tags).toEqual([]);
-    });
-
-    // ==================== array_text 类型 ====================
-
-    test("array_text: 长文本数组序列化和反序列化", () => {
-        const data = {
-            descriptions: ["这是一段很长的文本描述" + "x".repeat(500), "另一段很长的描述" + "y".repeat(500)]
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(typeof serialized.descriptions).toBe("string");
-        expect(serialized.descriptions.startsWith("[")).toBe(true);
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.descriptions).toEqual(data.descriptions);
-    });
-
-    test("array_text: 包含特殊字符的文本数组", () => {
-        const data = {
-            contents: ['Text with "quotes"', "Text with 'apostrophes'", "Text with\nnewlines", "Text with\ttabs"]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.contents).toEqual(data.contents);
-    });
-
-    // ==================== array_number_string 类型 ====================
-
-    test("array_number_string: 数字数组序列化和反序列化", () => {
-        const data = {
-            menuIds: [1, 2, 3, 4, 5],
-            apiIds: [10, 20, 30, 40, 50]
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(serialized.menuIds).toBe("[1,2,3,4,5]");
-        expect(serialized.apiIds).toBe("[10,20,30,40,50]");
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.menuIds).toEqual([1, 2, 3, 4, 5]);
-        expect(deserialized.apiIds).toEqual([10, 20, 30, 40, 50]);
-    });
-
-    test("array_number_string: 大数字数组", () => {
-        const data = {
-            ids: [999999999999, 888888888888, 777777777777]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.ids).toEqual(data.ids);
-    });
-
-    test("array_number_string: 负数和小数", () => {
-        const data = {
-            numbers: [-1, -2.5, 0, 3.14, 100]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.numbers).toEqual(data.numbers);
-    });
-
-    // ==================== array_number_text 类型 ====================
-
-    test("array_number_text: 长数字数组序列化和反序列化", () => {
-        const data = {
-            historyIds: Array.from({ length: 500 }, (_, i) => i + 1)
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(typeof serialized.historyIds).toBe("string");
-        expect(serialized.historyIds.length).toBeGreaterThan(1000);
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.historyIds).toEqual(data.historyIds);
-        expect(deserialized.historyIds.length).toBe(500);
-    });
-
-    test("array_number_text: 时间戳数组", () => {
-        const data = {
-            timestamps: [1702540800000, 1702627200000, 1702713600000]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.timestamps).toEqual(data.timestamps);
-    });
-
-    // ==================== 混合场景测试 ====================
-
-    test("混合场景: 所有数组类型同时存在", () => {
-        const data = {
-            // array_string
-            tags: ["tag1", "tag2"],
-            // array_text
-            descriptions: ["Long text 1", "Long text 2"],
-            // array_number_string
-            menuIds: [1, 2, 3],
-            // array_number_text
-            historyIds: Array.from({ length: 100 }, (_, i) => i),
-            // 非数组字段
-            name: "test",
-            count: 10
-        };
-
-        const serialized = serializeArrayFields(data);
-
-        // 验证序列化
-        expect(serialized.tags).toBe('["tag1","tag2"]');
-        expect(serialized.descriptions).toBe('["Long text 1","Long text 2"]');
-        expect(serialized.menuIds).toBe("[1,2,3]");
-        expect(typeof serialized.historyIds).toBe("string");
-        expect(serialized.name).toBe("test");
-        expect(serialized.count).toBe(10);
-
-        const deserialized = deserializeArrayFields(serialized);
-
-        // 验证反序列化
-        expect(deserialized.tags).toEqual(["tag1", "tag2"]);
-        expect(deserialized.descriptions).toEqual(["Long text 1", "Long text 2"]);
-        expect(deserialized.menuIds).toEqual([1, 2, 3]);
-        expect(deserialized.historyIds).toEqual(data.historyIds);
-        expect(deserialized.name).toBe("test");
-        expect(deserialized.count).toBe(10);
-    });
-
-    test("混合场景: 包含 null 和 undefined 的数组字段", () => {
-        const data = {
-            tags: ["tag1", "tag2"],
-            menuIds: null,
-            apiIds: undefined,
-            name: "test"
-        };
-
-        const serialized = serializeArrayFields(data);
-        expect(serialized.tags).toBe('["tag1","tag2"]');
-        expect(serialized.menuIds).toBeNull();
-        expect(serialized.apiIds).toBeUndefined();
-
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.tags).toEqual(["tag1", "tag2"]);
-        expect(deserialized.menuIds).toBeNull();
-        expect(deserialized.apiIds).toBeUndefined();
-    });
-
-    // ==================== 数据类型覆盖测试 ====================
-
-    test("数据类型覆盖: 数组中包含不同类型元素", () => {
-        const data = {
-            // 混合类型数组（JSON 支持）
-            mixed: [1, "string", true, null, { key: "value" }],
-            // 嵌套数组
-            nested: [
-                [1, 2],
-                [3, 4],
-                [5, 6]
-            ],
-            // 空数组
-            empty: []
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.mixed).toEqual(data.mixed);
-        expect(deserialized.nested).toEqual(data.nested);
-        expect(deserialized.empty).toEqual([]);
-    });
-
-    // ==================== 实际使用场景模拟 ====================
-
-    test("实际场景: 角色权限数据", () => {
-        const roleData = {
-            id: 1,
-            name: "管理员",
-            code: "admin",
-            menus: ["/dashboard", "/permission/role"], // array_text
-            apis: ["/api/login", "/api/user/list"] // array_text
-        };
-
-        // 模拟写入数据库
-        const serialized = serializeArrayFields(roleData);
-        expect(serialized.menus).toBe('["/dashboard","/permission/role"]');
-        expect(serialized.apis).toBe('["/api/login","/api/user/list"]');
-
-        // 模拟从数据库查询
-        const deserialized = deserializeArrayFields(serialized);
-        expect(deserialized.menus).toEqual(roleData.menus);
-        expect(deserialized.apis).toEqual(roleData.apis);
-
-        // 验证可以直接使用数组方法
-        expect(deserialized.menus.includes("/dashboard")).toBe(true);
-        expect(deserialized.apis.length).toBe(2);
-    });
-
-    test("实际场景: 文章标签和分类", () => {
-        const articleData = {
-            id: 1,
-            title: "测试文章",
-            tags: ["JavaScript", "TypeScript", "Bun"], // array_string
-            categoryIds: [1, 3, 5], // array_number_string
-            relatedIds: Array.from({ length: 20 }, (_, i) => i + 100) // array_number_text
-        };
-
-        const serialized = serializeArrayFields(articleData);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.tags).toEqual(articleData.tags);
-        expect(deserialized.categoryIds).toEqual(articleData.categoryIds);
-        expect(deserialized.relatedIds).toEqual(articleData.relatedIds);
-    });
-
-    // ==================== 完整流程测试 ====================
-
-    test("完整流程: 批量插入场景", () => {
-        const roles = [
-            { name: "管理员", menus: ["/dashboard", "/permission/role"], apis: ["/api/login", "/api/user/list"] },
-            { name: "编辑", menus: ["/dashboard"], apis: ["/api/user/list"] },
-            { name: "访客", menus: ["/dashboard"], apis: [] }
-        ];
-
-        // 模拟批量序列化
-        const serializedRoles = roles.map((role) => serializeArrayFields(role));
-
-        expect(serializedRoles[0].menus).toBe('["/dashboard","/permission/role"]');
-        expect(serializedRoles[1].menus).toBe('["/dashboard"]');
-        expect(serializedRoles[2].menus).toBe('["/dashboard"]');
-        expect(serializedRoles[2].apis).toBe("[]");
-
-        // 模拟批量反序列化
-        const deserializedRoles = serializedRoles.map((role) => deserializeArrayFields(role));
-
-        expect(deserializedRoles[0].menus).toEqual(["/dashboard", "/permission/role"]);
-        expect(deserializedRoles[1].menus).toEqual(["/dashboard"]);
-        expect(deserializedRoles[2].menus).toEqual(["/dashboard"]);
-        expect(deserializedRoles[2].apis).toEqual([]);
-    });
-});

package/tests/dbHelper-array-serialization.test.ts

@@ -1,258 +0,0 @@
-/**
- * 测试数组类型的自动序列化和反序列化
- */
-
-import { describe, expect, test } from "bun:test";
-
-describe("数组类型序列化/反序列化", () => {
-    // 模拟 serializeArrayFields 方法
-    const serializeArrayFields = (data: Record<string, any>): Record<string, any> => {
-        const serialized = { ...data };
-
-        for (const [key, value] of Object.entries(serialized)) {
-            if (value === null || value === undefined) continue;
-
-            if (Array.isArray(value)) {
-                serialized[key] = JSON.stringify(value);
-            }
-        }
-
-        return serialized;
-    };
-
-    // 模拟 deserializeArrayFields 方法
-    const deserializeArrayFields = <T = any>(data: Record<string, any> | null): T | null => {
-        if (!data) return null;
-
-        const deserialized = { ...data };
-
-        for (const [key, value] of Object.entries(deserialized)) {
-            if (typeof value !== "string") continue;
-
-            if (value.startsWith("[") && value.endsWith("]")) {
-                try {
-                    const parsed = JSON.parse(value);
-                    if (Array.isArray(parsed)) {
-                        deserialized[key] = parsed;
-                    }
-                } catch {
-                    // 解析失败则保持原值
-                }
-            }
-        }
-
-        return deserialized as T;
-    };
-
-    // ==================== 序列化测试 ====================
-
-    test("序列化：数字数组应转换为 JSON 字符串", () => {
-        const data = {
-            name: "test",
-            menuIds: [1, 2, 3, 4, 5],
-            apiIds: [10, 20, 30]
-        };
-
-        const result = serializeArrayFields(data);
-
-        expect(result.name).toBe("test");
-        expect(result.menuIds).toBe("[1,2,3,4,5]");
-        expect(result.apiIds).toBe("[10,20,30]");
-    });
-
-    test("序列化：字符串数组应转换为 JSON 字符串", () => {
-        const data = {
-            tags: ["tag1", "tag2", "tag3"]
-        };
-
-        const result = serializeArrayFields(data);
-        expect(result.tags).toBe('["tag1","tag2","tag3"]');
-    });
-
-    test('序列化：空数组应转换为 "[]"', () => {
-        const data = {
-            menuIds: []
-        };
-
-        const result = serializeArrayFields(data);
-        expect(result.menuIds).toBe("[]");
-    });
-
-    test("序列化：null 和 undefined 应保持不变", () => {
-        const data = {
-            menuIds: null,
-            apiIds: undefined,
-            name: "test"
-        };
-
-        const result = serializeArrayFields(data);
-        expect(result.menuIds).toBeNull();
-        expect(result.apiIds).toBeUndefined();
-        expect(result.name).toBe("test");
-    });
-
-    test("序列化：非数组字段应保持不变", () => {
-        const data = {
-            name: "test",
-            age: 25,
-            active: true,
-            menuIds: [1, 2, 3]
-        };
-
-        const result = serializeArrayFields(data);
-        expect(result.name).toBe("test");
-        expect(result.age).toBe(25);
-        expect(result.active).toBe(true);
-        expect(result.menuIds).toBe("[1,2,3]");
-    });
-
-    // ==================== 反序列化测试 ====================
-
-    test("反序列化：JSON 数字数组字符串应转换为数组", () => {
-        const data = {
-            name: "test",
-            menuIds: "[1,2,3,4,5]",
-            apiIds: "[10,20,30]"
-        };
-
-        const result = deserializeArrayFields(data);
-
-        expect(result.name).toBe("test");
-        expect(result.menuIds).toEqual([1, 2, 3, 4, 5]);
-        expect(result.apiIds).toEqual([10, 20, 30]);
-    });
-
-    test("反序列化：JSON 字符串数组应转换为数组", () => {
-        const data = {
-            tags: '["tag1","tag2","tag3"]'
-        };
-
-        const result = deserializeArrayFields(data);
-        expect(result.tags).toEqual(["tag1", "tag2", "tag3"]);
-    });
-
-    test('反序列化："[]" 应转换为空数组', () => {
-        const data = {
-            menuIds: "[]"
-        };
-
-        const result = deserializeArrayFields(data);
-        expect(result.menuIds).toEqual([]);
-    });
-
-    test("反序列化：非 JSON 数组字符串应保持不变", () => {
-        const data = {
-            name: "test",
-            description: "This is a [test] string",
-            url: "https://example.com"
-        };
-
-        const result = deserializeArrayFields(data);
-        expect(result.name).toBe("test");
-        expect(result.description).toBe("This is a [test] string");
-        expect(result.url).toBe("https://example.com");
-    });
-
-    test("反序列化：无效的 JSON 字符串应保持不变", () => {
-        const data = {
-            menuIds: "[1,2,3,", // 无效 JSON
-            apiIds: "[invalid]"
-        };
-
-        const result = deserializeArrayFields(data);
-        expect(result.menuIds).toBe("[1,2,3,");
-        expect(result.apiIds).toBe("[invalid]");
-    });
-
-    test("反序列化：非字符串值应保持不变", () => {
-        const data = {
-            name: "test",
-            age: 25,
-            active: true,
-            count: null
-        };
-
-        const result = deserializeArrayFields(data);
-        expect(result.name).toBe("test");
-        expect(result.age).toBe(25);
-        expect(result.active).toBe(true);
-        expect(result.count).toBeNull();
-    });
-
-    test("反序列化：null 数据应返回 null", () => {
-        const result = deserializeArrayFields(null);
-        expect(result).toBeNull();
-    });
-
-    // ==================== 往返测试 ====================
-
-    test("往返：序列化后反序列化应得到原始数据", () => {
-        const originalData = {
-            name: "test role",
-            menuIds: [1, 2, 3, 4, 5],
-            apiIds: [10, 20, 30, 40],
-            tags: ["tag1", "tag2"],
-            emptyArray: []
-        };
-
-        const serialized = serializeArrayFields(originalData);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.name).toBe(originalData.name);
-        expect(deserialized.menuIds).toEqual(originalData.menuIds);
-        expect(deserialized.apiIds).toEqual(originalData.apiIds);
-        expect(deserialized.tags).toEqual(originalData.tags);
-        expect(deserialized.emptyArray).toEqual(originalData.emptyArray);
-    });
-
-    // ==================== 边界情况测试 ====================
-
-    test("边界情况：包含特殊字符的字符串数组", () => {
-        const data = {
-            items: ['item"1', "item'2", "item[3]", "item,4"]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.items).toEqual(data.items);
-    });
-
-    test("边界情况：嵌套数组（JSON 支持）", () => {
-        const data = {
-            nested: [
-                [1, 2],
-                [3, 4],
-                [5, 6]
-            ]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.nested).toEqual(data.nested);
-    });
-
-    test("边界情况：大数组", () => {
-        const data = {
-            largeArray: Array.from({ length: 1000 }, (_, i) => i)
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.largeArray).toEqual(data.largeArray);
-        expect(deserialized.largeArray.length).toBe(1000);
-    });
-
-    test("边界情况：混合类型数组（JSON 支持）", () => {
-        const data = {
-            mixed: [1, "two", true, null, { key: "value" }]
-        };
-
-        const serialized = serializeArrayFields(data);
-        const deserialized = deserializeArrayFields(serialized);
-
-        expect(deserialized.mixed).toEqual(data.mixed);
-    });
-});

package/tests/dbHelper-batch-write.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-
-import { MySqlDialect } from "../lib/dbDialect.js";
-import { DbHelper } from "../lib/dbHelper.js";
-
-function createRedisMock() {
-    return {
-        getObject: async () => null,
-        setObject: async () => "OK",
-        genTimeID: async () => 1
-    };
-}
-
-describe("DbHelper - batch write helpers", () => {
-    it("delForceBatch: 空数组直接返回 0 且不执行 SQL", async () => {
-        const sqlMock = {
-            unsafe: mock(() => Promise.resolve({ changes: 0 }))
-        };
-
-        const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-        const changes = await (dbHelper as any).delForceBatch("addon_admin_api", []);
-
-        expect(changes).toBe(0);
-        expect(sqlMock.unsafe).toHaveBeenCalledTimes(0);
-    });
-
-    it("delForceBatch: 生成单条 DELETE ... IN 并执行一次", async () => {
-        const sqlMock = {
-            unsafe: mock(() => Promise.resolve({ changes: 2 }))
-        };
-
-        const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-        const changes = await (dbHelper as any).delForceBatch("addon_admin_api", [1, 2]);
-
-        expect(changes).toBe(2);
-        expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
-
-        const call = (sqlMock.unsafe as any).mock.calls[0];
-        expect(call[0]).toBe("DELETE FROM `addon_admin_api` WHERE `id` IN (?,?)");
-        expect(call[1]).toEqual([1, 2]);
-    });
-
-    it("updBatch: 空数组直接返回 0 且不执行 SQL", async () => {
-        const sqlMock = {
-            unsafe: mock(() => Promise.resolve({ changes: 0 }))
-        };
-
-        const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-        const changes = await (dbHelper as any).updBatch("addon_admin_api", []);
-
-        expect(changes).toBe(0);
-        expect(sqlMock.unsafe).toHaveBeenCalledTimes(0);
-    });
-
-    it("updBatch: 生成单条 UPDATE + CASE 并执行一次", async () => {
-        const sqlMock = {
-            unsafe: mock(() => Promise.resolve({ changes: 2 }))
-        };
-
-        const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-        const changes = await (dbHelper as any).updBatch("addon_admin_api", [
-            { id: 1, data: { name: "A", routePath: "/api/a", addonName: "x" } },
-            { id: 2, data: { name: "B", routePath: "/api/b", addonName: "y" } }
-        ]);
-
-        expect(changes).toBe(2);
-        expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
-
-        const call = (sqlMock.unsafe as any).mock.calls[0];
-        const sql = String(call[0]);
-        const params = call[1] as any[];
-
-        expect(sql.startsWith("UPDATE `addon_admin_api` SET")).toBe(true);
-        expect(sql.includes("`name` = CASE `id`")).toBe(true);
-        expect(sql.includes("`route_path` = CASE `id`")).toBe(true);
-        expect(sql.includes("`addon_name` = CASE `id`")).toBe(true);
-        expect(sql.includes("`updated_at` = ?")).toBe(true);
-        expect(sql.endsWith("WHERE `id` IN (?,?) AND `state` > 0")).toBe(true);
-
-        // 参数数量应包含：每个字段 2 行 * (id,value) *3字段 => 12，+ updated_at 1，+ where ids 2 => 15
-        expect(params.length).toBe(15);
-        // 末尾两个参数是 where ids
-        expect(params[params.length - 2]).toBe(1);
-        expect(params[params.length - 1]).toBe(2);
-    });
-});