befly 3.10.1 → 3.10.2

package/tests/syncTable-testkit.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { syncTable } from "../sync/syncTable.js";
-
-describe("syncTable - TestKit 挂载", () => {
-    it("should expose TestKit as a stable object", () => {
-        expect(typeof syncTable).toBe("function");
-        expect(syncTable.TestKit).toBeDefined();
-
-        const descriptor = Object.getOwnPropertyDescriptor(syncTable, "TestKit");
-        expect(descriptor).toBeDefined();
-        expect(descriptor?.writable).toBe(false);
-        expect(descriptor?.configurable).toBe(false);
-        expect(descriptor?.enumerable).toBe(true);
-
-        expect(typeof syncTable.TestKit.quoteIdentifier).toBe("function");
-        expect(typeof syncTable.TestKit.getTypeMapping).toBe("function");
-
-        expect(syncTable.TestKit.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
-
-        const firstRef = syncTable.TestKit;
-        const secondRef = syncTable.TestKit;
-        expect(firstRef).toBe(secondRef);
-    });
-});

package/tests/syncTable-types.test.ts

@@ -1,122 +0,0 @@
-/**
- * syncTable 类型处理模块测试
- *
- * 测试 types.ts 中的函数：
- * - isStringOrArrayType
- * - getSqlType
- * - resolveDefaultValue
- * - generateDefaultSql
- */
-
-import { describe, test, expect } from "bun:test";
-
-import { syncTable } from "../sync/syncTable.js";
-
-describe("isStringOrArrayType", () => {
-    test("string 类型返回 true", () => {
-        expect(syncTable.TestKit.isStringOrArrayType("string")).toBe(true);
-    });
-
-    test("array_string 类型返回 true", () => {
-        expect(syncTable.TestKit.isStringOrArrayType("array_string")).toBe(true);
-    });
-
-    test("number 类型返回 false", () => {
-        expect(syncTable.TestKit.isStringOrArrayType("number")).toBe(false);
-    });
-
-    test("text 类型返回 false", () => {
-        expect(syncTable.TestKit.isStringOrArrayType("text")).toBe(false);
-    });
-
-    test("array_text 类型返回 false", () => {
-        expect(syncTable.TestKit.isStringOrArrayType("array_text")).toBe(false);
-    });
-});
-
-describe("resolveDefaultValue", () => {
-    test("null 值 + string 类型 => 空字符串", () => {
-        expect(syncTable.TestKit.resolveDefaultValue(null, "string")).toBe("");
-    });
-
-    test("null 值 + number 类型 => 0", () => {
-        expect(syncTable.TestKit.resolveDefaultValue(null, "number")).toBe(0);
-    });
-
-    test('"null" 字符串 + number 类型 => 0', () => {
-        expect(syncTable.TestKit.resolveDefaultValue("null", "number")).toBe(0);
-    });
-
-    test('null 值 + array_string 类型 => "[]"', () => {
-        expect(syncTable.TestKit.resolveDefaultValue(null, "array_string")).toBe("[]");
-    });
-
-    test('null 值 + text 类型 => "null"', () => {
-        expect(syncTable.TestKit.resolveDefaultValue(null, "text")).toBe("null");
-    });
-
-    test('null 值 + array_text 类型 => "null"（TEXT 不支持默认值）', () => {
-        expect(syncTable.TestKit.resolveDefaultValue(null, "array_text")).toBe("null");
-    });
-
-    test("有实际值时直接返回", () => {
-        expect(syncTable.TestKit.resolveDefaultValue("admin", "string")).toBe("admin");
-        expect(syncTable.TestKit.resolveDefaultValue(100, "number")).toBe(100);
-        expect(syncTable.TestKit.resolveDefaultValue(0, "number")).toBe(0);
-    });
-});
-
-describe("generateDefaultSql", () => {
-    test("number 类型生成数字默认值", () => {
-        expect(syncTable.TestKit.generateDefaultSql(0, "number")).toBe(" DEFAULT 0");
-        expect(syncTable.TestKit.generateDefaultSql(100, "number")).toBe(" DEFAULT 100");
-    });
-
-    test("string 类型生成带引号默认值", () => {
-        expect(syncTable.TestKit.generateDefaultSql("admin", "string")).toBe(" DEFAULT 'admin'");
-        expect(syncTable.TestKit.generateDefaultSql("", "string")).toBe(" DEFAULT ''");
-    });
-
-    test("text 类型不生成默认值", () => {
-        expect(syncTable.TestKit.generateDefaultSql("null", "text")).toBe("");
-    });
-
-    test("array_string 类型生成 JSON 数组默认值", () => {
-        expect(syncTable.TestKit.generateDefaultSql("[]", "array_string")).toBe(" DEFAULT '[]'");
-    });
-
-    test("array_text 类型不生成默认值（MySQL TEXT 不支持）", () => {
-        expect(syncTable.TestKit.generateDefaultSql("[]", "array_text")).toBe("");
-    });
-
-    test("单引号被正确转义", () => {
-        expect(syncTable.TestKit.generateDefaultSql("it's", "string")).toBe(" DEFAULT 'it''s'");
-    });
-});
-
-describe("getSqlType", () => {
-    test("string 类型带长度", () => {
-        const result = syncTable.TestKit.getSqlType("mysql", "string", 100);
-        expect(result).toBe("VARCHAR(100)");
-    });
-
-    test("array_string 类型带长度", () => {
-        const result = syncTable.TestKit.getSqlType("mysql", "array_string", 500);
-        expect(result).toBe("VARCHAR(500)");
-    });
-
-    test("number 类型无符号", () => {
-        const result = syncTable.TestKit.getSqlType("mysql", "number", null, true);
-        expect(result).toBe("BIGINT UNSIGNED");
-    });
-
-    test("number 类型有符号", () => {
-        const result = syncTable.TestKit.getSqlType("mysql", "number", null, false);
-        expect(result).toBe("BIGINT");
-    });
-
-    test("text 类型", () => {
-        const result = syncTable.TestKit.getSqlType("mysql", "text", null);
-        expect(result).toBe("MEDIUMTEXT");
-    });
-});

package/tests/tableRef-and-deserialize.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-
-import { MySqlDialect } from "../lib/dbDialect.js";
-import { DbHelper } from "../lib/dbHelper.js";
-import { DbUtils } from "../lib/dbUtils.js";
-import { SqlBuilder } from "../lib/sqlBuilder.js";
-
-describe("tableRef normalize + escape", () => {
-    it("DbUtils.normalizeTableRef: 保留 alias，仅 snakeCase 表名", () => {
-        expect(DbUtils.normalizeTableRef("UserProfile up")).toBe("user_profile up");
-        expect(DbUtils.normalizeTableRef("order o")).toBe("order o");
-    });
-
-    it("SqlBuilder.from: 支持 table alias", () => {
-        const sql = new SqlBuilder().select(["*"]).from("order o").toSelectSql().sql;
-        expect(sql).toContain("FROM `order` o");
-    });
-
-    it("SqlBuilder.from: 支持 schema.table alias", () => {
-        const sql = new SqlBuilder().select(["*"]).from("my_db.users u").toSelectSql().sql;
-        expect(sql).toContain("FROM `my_db`.`users` u");
-    });
-
-    it("SqlBuilder.from: 复杂表引用要求显式 fromRaw", () => {
-        expect(() => new SqlBuilder().select(["*"]).from("users u FORCE INDEX (idx_user)")).toThrow();
-    });
-});
-
-describe("DbHelper.getList deserialize", () => {
-    it("getList: 数组字段应被 DbUtils.deserializeArrayFields 反序列化", async () => {
-        const sqlMock = {
-            unsafe: mock(async (sql: string, _params?: any[]) => {
-                if (sql.includes("COUNT(*) as total")) {
-                    return [{ total: 1 }];
-                }
-                return [
-                    {
-                        id: "1",
-                        tags: '["a","b"]',
-                        state: 1,
-                        created_at: 0,
-                        updated_at: 0
-                    }
-                ];
-            })
-        };
-
-        const redisMock = {
-            getObject: mock(async () => null),
-            setObject: mock(async () => "OK"),
-            genTimeID: mock(async () => 1)
-        };
-
-        const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock as any, dialect: new MySqlDialect() });
-
-        const result = await dbHelper.getList<{ id: number; tags: string[] }>({
-            table: "users",
-            fields: ["id", "tags"],
-            where: {}
-        });
-
-        expect(result.total).toBe(1);
-        expect(result.lists.length).toBe(1);
-        expect(Array.isArray(result.lists[0].tags)).toBe(true);
-        expect(result.lists[0].tags).toEqual(["a", "b"]);
-    });
-});

package/tests/util.test.ts

@@ -1,100 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { arrayKeysToCamel } from "../utils/arrayKeysToCamel.js";
-import { calcPerfTime } from "../utils/calcPerfTime.js";
-import { fieldClear } from "../utils/fieldClear.js";
-import { keysToCamel } from "../utils/keysToCamel.js";
-import { keysToSnake } from "../utils/keysToSnake.js";
-
-describe("Util - keysToCamel", () => {
-    test("转换对象键名为驼峰", () => {
-        const result = keysToCamel({ user_name: "John", user_id: 123 });
-        expect(result.userName).toBe("John");
-        expect(result.userId).toBe(123);
-    });
-
-    test("保持已有驼峰格式", () => {
-        const result = keysToCamel({ userName: "John", userId: 123 });
-        expect(result.userName).toBe("John");
-        expect(result.userId).toBe(123);
-    });
-
-    test("处理空对象", () => {
-        const result = keysToCamel({});
-        expect(Object.keys(result).length).toBe(0);
-    });
-
-    test("处理嵌套对象", () => {
-        const result = keysToCamel({ user_info: { first_name: "John" } });
-        expect(result.userInfo).toBeDefined();
-    });
-});
-
-describe("Util - keysToSnake", () => {
-    test("转换对象键名为下划线", () => {
-        const result = keysToSnake({ userName: "John", userId: 123 });
-        expect(result.user_name).toBe("John");
-        expect(result.user_id).toBe(123);
-    });
-
-    test("保持已有下划线格式", () => {
-        const result = keysToSnake({ user_name: "John", user_id: 123 });
-        expect(result.user_name).toBe("John");
-        expect(result.user_id).toBe(123);
-    });
-
-    test("处理空对象", () => {
-        const result = keysToSnake({});
-        expect(Object.keys(result).length).toBe(0);
-    });
-});
-
-describe("Util - arrayKeysToCamel", () => {
-    test("转换数组中对象键名为驼峰", () => {
-        const result = arrayKeysToCamel([
-            { user_name: "John", user_id: 1 },
-            { user_name: "Jane", user_id: 2 }
-        ]);
-        expect(result[0].userName).toBe("John");
-        expect(result[0].userId).toBe(1);
-        expect(result[1].userName).toBe("Jane");
-        expect(result[1].userId).toBe(2);
-    });
-
-    test("处理空数组", () => {
-        const result = arrayKeysToCamel([]);
-        expect(result.length).toBe(0);
-    });
-});
-
-describe("Util - fieldClear", () => {
-    test("移除 null 和 undefined", () => {
-        const result = fieldClear({ a: 1, b: null, c: undefined, d: "test" }, { excludeValues: [null, undefined] });
-        expect(result.a).toBe(1);
-        expect(result.b).toBeUndefined();
-        expect(result.c).toBeUndefined();
-        expect(result.d).toBe("test");
-    });
-
-    test("保留指定值", () => {
-        const result = fieldClear({ a: 1, b: null, c: 0 }, { excludeValues: [null, undefined], keepMap: { c: 0 } });
-        expect(result.a).toBe(1);
-        expect(result.b).toBeUndefined();
-        expect(result.c).toBe(0);
-    });
-
-    test("处理空对象", () => {
-        const result = fieldClear({});
-        expect(Object.keys(result).length).toBe(0);
-    });
-});
-
-describe("Util - calcPerfTime", () => {
-    test("计算性能时间", () => {
-        const start = Bun.nanoseconds();
-        const result = calcPerfTime(start);
-        expect(result).toContain("毫秒");
-        expect(typeof result).toBe("string");
-        expect(result).toMatch(/\d+(\.\d+)?\s*毫秒/);
-    });
-});

package/tests/validator-array-number.test.ts

@@ -1,310 +0,0 @@
-/**
- * 测试 Validator 对 array_number_string 和 array_number_text 类型的支持
- */
-
-import type { FieldDefinition } from "befly/types/validate";
-
-import { describe, expect, test } from "bun:test";
-
-import { Validator } from "../lib/validator.js";
-
-describe("Validator - array_number 类型验证", () => {
-    // ==================== 类型转换测试 ====================
-
-    test("array_number_string: 接受数字数组", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single([1, 2, 3], field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([1, 2, 3]);
-    });
-
-    test("array_number_string: 拒绝字符串数组", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single(["1", "2", "3"], field);
-        expect(result.error).toBe("数组元素必须是数字");
-        expect(result.value).toBeNull();
-    });
-
-    test("array_number_string: 拒绝混合类型数组", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single([1, "2", 3], field);
-        expect(result.error).toBe("数组元素必须是数字");
-    });
-
-    test("array_number_string: 拒绝非数组值", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single("123", field);
-        expect(result.error).toBe("必须是数组");
-    });
-
-    test("array_number_text: 接受数字数组", () => {
-        const field: FieldDefinition = {
-            name: "长数字数组",
-            type: "array_number_text",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single([100, 200, 300], field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([100, 200, 300]);
-    });
-
-    test("array_number_text: 拒绝 NaN 和 Infinity", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_text",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result1 = Validator.single([1, NaN, 3], field);
-        expect(result1.error).toBe("数组元素必须是数字");
-
-        const result2 = Validator.single([1, Infinity, 3], field);
-        expect(result2.error).toBe("数组元素必须是数字");
-    });
-
-    // ==================== 规则验证测试 ====================
-
-    test("array_number_string: min 规则验证", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: 2,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result1 = Validator.single([1], field);
-        expect(result1.error).toBe("至少需要2个元素");
-
-        const result2 = Validator.single([1, 2], field);
-        expect(result2.error).toBeNull();
-
-        const result3 = Validator.single([1, 2, 3], field);
-        expect(result3.error).toBeNull();
-    });
-
-    test("array_number_string: max 规则验证", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: 3,
-            default: null,
-            regexp: null
-        };
-
-        const result1 = Validator.single([1, 2, 3], field);
-        expect(result1.error).toBeNull();
-
-        const result2 = Validator.single([1, 2, 3, 4], field);
-        expect(result2.error).toBe("最多只能有3个元素");
-    });
-
-    test("array_number_text: min + max 规则验证", () => {
-        const field: FieldDefinition = {
-            name: "长数字数组",
-            type: "array_number_text",
-            min: 1,
-            max: 5,
-            default: null,
-            regexp: null
-        };
-
-        const result1 = Validator.single([], field);
-        expect(result1.error).toBe("至少需要1个元素");
-
-        const result2 = Validator.single([1, 2, 3], field);
-        expect(result2.error).toBeNull();
-
-        const result3 = Validator.single([1, 2, 3, 4, 5, 6], field);
-        expect(result3.error).toBe("最多只能有5个元素");
-    });
-
-    // ==================== 默认值测试 ====================
-
-    test("array_number_string: 无 default 时返回空数组", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result1 = Validator.single(undefined, field);
-        expect(result1.error).toBeNull();
-        expect(result1.value).toEqual([]);
-
-        const result2 = Validator.single(null, field);
-        expect(result2.error).toBeNull();
-        expect(result2.value).toEqual([]);
-
-        const result3 = Validator.single("", field);
-        expect(result3.error).toBeNull();
-        expect(result3.value).toEqual([]);
-    });
-
-    test("array_number_string: 有 default 时返回自定义默认值", () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: [10, 20, 30],
-            regexp: null
-        };
-
-        const result = Validator.single(undefined, field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([10, 20, 30]);
-    });
-
-    test('array_number_string: default 为字符串 "[]" 时返回空数组', () => {
-        const field: FieldDefinition = {
-            name: "数字数组",
-            type: "array_number_string",
-            min: null,
-            max: null,
-            default: "[]",
-            regexp: null
-        };
-
-        const result = Validator.single(null, field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([]);
-    });
-
-    test("array_number_text: 无 default 时返回空数组", () => {
-        const field: FieldDefinition = {
-            name: "长数字数组",
-            type: "array_number_text",
-            min: null,
-            max: null,
-            default: null,
-            regexp: null
-        };
-
-        const result = Validator.single(undefined, field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([]);
-    });
-
-    test("array_number_text: 有 default 时返回自定义默认值", () => {
-        const field: FieldDefinition = {
-            name: "长数字数组",
-            type: "array_number_text",
-            min: null,
-            max: null,
-            default: [100, 200],
-            regexp: null
-        };
-
-        const result = Validator.single(undefined, field);
-        expect(result.error).toBeNull();
-        expect(result.value).toEqual([100, 200]);
-    });
-
-    // ==================== validate 方法测试 ====================
-
-    test("validate: array_number_string 字段验证", () => {
-        const rules = {
-            tags: {
-                name: "标签ID",
-                type: "array_number_string",
-                min: 1,
-                max: 10,
-                default: null,
-                regexp: null
-            }
-        };
-
-        const result1 = Validator.validate({ tags: [1, 2, 3] }, rules as any, ["tags"]);
-        expect(result1.failed).toBe(false);
-
-        const result2 = Validator.validate({ tags: [] }, rules as any, ["tags"]);
-        expect(result2.failed).toBe(true);
-        expect(result2.firstError).toBe("标签ID至少需要1个元素");
-
-        const result3 = Validator.validate({ tags: ["1", "2"] }, rules as any, ["tags"]);
-        expect(result3.failed).toBe(true);
-        expect(result3.firstError).toBe("标签ID数组元素必须是数字");
-    });
-
-    test("validate: array_number_text 字段验证", () => {
-        const rules = {
-            ids: {
-                name: "关联ID",
-                type: "array_number_text",
-                min: null,
-                max: null,
-                default: null,
-                regexp: null
-            }
-        };
-
-        const result1 = Validator.validate({ ids: [100, 200, 300] }, rules as any, []);
-        expect(result1.failed).toBe(false);
-
-        const result2 = Validator.validate({ ids: "not-array" }, rules as any, []);
-        expect(result2.failed).toBe(true);
-        expect(result2.firstError).toBe("关联ID必须是数组");
-    });
-
-    test("validate: undefined 参数跳过验证", () => {
-        const rules = {
-            tags: {
-                name: "标签",
-                type: "array_number_string",
-                min: 1,
-                max: null,
-                default: null,
-                regexp: null
-            }
-        };
-
-        // undefined 且不是必填字段，应跳过验证
-        const result = Validator.validate({ other: "value" }, rules as any, []);
-        expect(result.failed).toBe(false);
-    });
-});