befly 3.9.40 → 3.10.0

package/tests/syncTable-constants.test.ts

@@ -0,0 +1,101 @@
+/**
+ * syncTable 常量模块测试
+ *
+ * 测试 constants.ts 中的常量：
+ * - DB_VERSION_REQUIREMENTS
+ * - SYSTEM_INDEX_FIELDS
+ * - SYSTEM_INDEX_FIELDS
+ * - CHANGE_TYPE_LABELS
+ * - MYSQL_TABLE_CONFIG
+ * - typeMapping
+ */
+
+import { describe, test, expect } from "bun:test";
+
+import { syncTable } from "../sync/syncTable.js";
+
+describe("DB_VERSION_REQUIREMENTS", () => {
+    test("MySQL 最低版本为 8", () => {
+        expect(syncTable.TestKit.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
+    });
+
+    test("PostgreSQL 最低版本为 17", () => {
+        expect(syncTable.TestKit.DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR).toBe(17);
+    });
+
+    test("SQLite 最低版本为 3.50.0", () => {
+        expect(syncTable.TestKit.DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION).toBe("3.50.0");
+    });
+});
+
+describe("SYSTEM_INDEX_FIELDS", () => {
+    test("包含 created_at", () => {
+        expect(syncTable.TestKit.SYSTEM_INDEX_FIELDS).toContain("created_at");
+    });
+
+    test("包含 updated_at", () => {
+        expect(syncTable.TestKit.SYSTEM_INDEX_FIELDS).toContain("updated_at");
+    });
+
+    test("包含 state", () => {
+        expect(syncTable.TestKit.SYSTEM_INDEX_FIELDS).toContain("state");
+    });
+
+    test("共 3 个系统索引字段", () => {
+        expect(syncTable.TestKit.SYSTEM_INDEX_FIELDS.length).toBe(3);
+    });
+});
+
+describe("CHANGE_TYPE_LABELS", () => {
+    test('length 对应 "长度"', () => {
+        expect((syncTable.TestKit.CHANGE_TYPE_LABELS as any).length).toBe("长度");
+    });
+
+    test('datatype 对应 "类型"', () => {
+        expect(syncTable.TestKit.CHANGE_TYPE_LABELS.datatype).toBe("类型");
+    });
+
+    test('comment 对应 "注释"', () => {
+        expect(syncTable.TestKit.CHANGE_TYPE_LABELS.comment).toBe("注释");
+    });
+
+    test('default 对应 "默认值"', () => {
+        expect(syncTable.TestKit.CHANGE_TYPE_LABELS.default).toBe("默认值");
+    });
+});
+
+describe("MYSQL_TABLE_CONFIG", () => {
+    test("ENGINE 为 InnoDB", () => {
+        expect(syncTable.TestKit.MYSQL_TABLE_CONFIG.ENGINE).toBe("InnoDB");
+    });
+
+    test("CHARSET 为 utf8mb4", () => {
+        expect(syncTable.TestKit.MYSQL_TABLE_CONFIG.CHARSET).toBe("utf8mb4");
+    });
+
+    test("COLLATE 为 utf8mb4_0900_ai_ci", () => {
+        expect(syncTable.TestKit.MYSQL_TABLE_CONFIG.COLLATE).toBe("utf8mb4_0900_ai_ci");
+    });
+});
+
+describe("getTypeMapping (MySQL)", () => {
+    test("number 映射为 BIGINT", () => {
+        expect(syncTable.TestKit.getTypeMapping("mysql").number).toBe("BIGINT");
+    });
+
+    test("string 映射为 VARCHAR", () => {
+        expect(syncTable.TestKit.getTypeMapping("mysql").string).toBe("VARCHAR");
+    });
+
+    test("text 映射为 MEDIUMTEXT", () => {
+        expect(syncTable.TestKit.getTypeMapping("mysql").text).toBe("MEDIUMTEXT");
+    });
+
+    test("array_string 映射为 VARCHAR", () => {
+        expect(syncTable.TestKit.getTypeMapping("mysql").array_string).toBe("VARCHAR");
+    });
+
+    test("array_text 映射为 MEDIUMTEXT", () => {
+        expect(syncTable.TestKit.getTypeMapping("mysql").array_text).toBe("MEDIUMTEXT");
+    });
+});

package/tests/syncTable-db-integration.test.ts

@@ -0,0 +1,237 @@
+/**
+ * syncTable 端到端行为测试（纯 mock，不连接真实数据库）
+ */
+
+import type { FieldDefinition } from "../types/validate.js";
+import type { ScanFileResult } from "../utils/scanFiles.js";
+import type { MockSqliteState } from "./_mocks/mockSqliteDb.js";
+
+import { describe, expect, test } from "bun:test";
+
+import { CacheKeys } from "../lib/cacheKeys.js";
+import { syncTable } from "../sync/syncTable.js";
+import { createMockSqliteDb } from "./_mocks/mockSqliteDb.js";
+
+function buildTableItem(options: { tableFileName: string; content: any }): ScanFileResult {
+    return {
+        source: "app",
+        type: "table",
+        sourceName: "项目",
+        filePath: "",
+        relativePath: options.tableFileName,
+        fileName: options.tableFileName,
+        moduleName: `app_${options.tableFileName}`,
+        addonName: "",
+        fileBaseName: "",
+        fileDir: "",
+        content: options.content
+    } as any;
+}
+
+function fdString(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
+    return {
+        name: options.name,
+        type: "string",
+        min: options.min,
+        max: options.max,
+        default: options.defaultValue,
+        nullable: options.nullable
+    } as any;
+}
+
+function fdNumber(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
+    return {
+        name: options.name,
+        type: "number",
+        min: options.min,
+        max: options.max,
+        default: options.defaultValue,
+        nullable: options.nullable
+    } as any;
+}
+
+function fdText(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
+    return {
+        name: options.name,
+        type: "text",
+        min: options.min,
+        max: options.max,
+        default: options.defaultValue,
+        nullable: options.nullable
+    } as any;
+}
+
+describe("syncTable(ctx, items) - mock sqlite", () => {
+    test("首次同步：应创建表并包含系统字段 + 业务字段，同时清理 columns 缓存", async () => {
+        const state: MockSqliteState = {
+            executedSql: [],
+            tables: {}
+        };
+
+        const db = createMockSqliteDb(state);
+
+        const redisCalls: Array<{ keys: string[] }> = [];
+        const ctx = {
+            db: db,
+            redis: {
+                delBatch: async (keys: string[]) => {
+                    redisCalls.push({ keys: keys });
+                    return keys.length;
+                }
+            },
+            config: {
+                db: { type: "sqlite", database: "" }
+            }
+        } as any;
+
+        const tableFileName = "test_sync_table_integration_user";
+        const item = buildTableItem({
+            tableFileName: tableFileName,
+            content: {
+                email: fdString({ name: "邮箱", min: 0, max: 100, defaultValue: null, nullable: false }),
+                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true }),
+                age: fdNumber({ name: "年龄", min: 0, max: 999, defaultValue: 0, nullable: true })
+            }
+        });
+
+        await syncTable(ctx, [item]);
+
+        expect(state.executedSql.some((s) => s.includes("CREATE TABLE") && s.includes(tableFileName))).toBe(true);
+
+        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
+        const exists = await syncTable.TestKit.tableExistsRuntime(runtime, tableFileName);
+        expect(exists).toBe(true);
+
+        const columns = await syncTable.TestKit.getTableColumnsRuntime(runtime, tableFileName);
+
+        expect(columns.id).toBeDefined();
+        expect(columns.created_at).toBeDefined();
+        expect(columns.updated_at).toBeDefined();
+        expect(columns.state).toBeDefined();
+
+        expect(columns.email).toBeDefined();
+        expect(columns.nickname).toBeDefined();
+        expect(columns.age).toBeDefined();
+
+        expect(redisCalls.length).toBe(1);
+        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
+    });
+
+    test("二次同步：新增字段应落库（ADD COLUMN），同时清理 columns 缓存", async () => {
+        const state: MockSqliteState = {
+            executedSql: [],
+            tables: {}
+        };
+
+        const db = createMockSqliteDb(state);
+
+        const redisCalls: Array<{ keys: string[] }> = [];
+        const ctx = {
+            db: db,
+            redis: {
+                delBatch: async (keys: string[]) => {
+                    redisCalls.push({ keys: keys });
+                    return keys.length;
+                }
+            },
+            config: {
+                db: { type: "sqlite", database: "" }
+            }
+        } as any;
+
+        const tableFileName = "test_sync_table_integration_profile";
+
+        const itemV1 = buildTableItem({
+            tableFileName: tableFileName,
+            content: {
+                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true })
+            }
+        });
+
+        await syncTable(ctx, [itemV1]);
+
+        const itemV2 = buildTableItem({
+            tableFileName: tableFileName,
+            content: {
+                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true }),
+                bio: fdText({ name: "简介", min: 0, max: 200, defaultValue: null, nullable: true })
+            }
+        });
+
+        await syncTable(ctx, [itemV2]);
+
+        expect(state.executedSql.some((s) => s.includes("ALTER TABLE") && s.includes(tableFileName) && s.includes("ADD COLUMN") && s.includes("bio"))).toBe(true);
+
+        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
+        const columns = await syncTable.TestKit.getTableColumnsRuntime(runtime, tableFileName);
+        expect(columns.nickname).toBeDefined();
+        expect(columns.bio).toBeDefined();
+
+        // 两次同步，每次都会清一次缓存
+        expect(redisCalls.length).toBe(2);
+        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
+        expect(redisCalls[1].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
+    });
+
+    test("索引变更：仅删除单列索引；复合索引不会被误删", async () => {
+        const tableFileName = "test_sync_table_integration_indexes";
+
+        const state: MockSqliteState = {
+            executedSql: [],
+            tables: {
+                [tableFileName]: {
+                    columns: {
+                        id: { name: "id", type: "INTEGER", notnull: 1, dflt_value: null },
+                        created_at: { name: "created_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
+                        updated_at: { name: "updated_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
+                        deleted_at: { name: "deleted_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
+                        state: { name: "state", type: "INTEGER", notnull: 1, dflt_value: "1" },
+                        user_id: { name: "user_id", type: "INTEGER", notnull: 1, dflt_value: "0" },
+                        user_name: { name: "user_name", type: "TEXT", notnull: 1, dflt_value: "''" }
+                    },
+                    indexes: {
+                        // 单列索引：应该能被识别并在 index=false 时被 drop
+                        idx_user_name: ["user_name"],
+                        // 复合索引：即使名字像单列索引，也因为多列而被 runtime 忽略，因此不会被 drop
+                        idx_user_id: ["user_id", "created_at"]
+                    }
+                }
+            }
+        };
+
+        const db = createMockSqliteDb(state);
+
+        const redisCalls: Array<{ keys: string[] }> = [];
+        const ctx = {
+            db: db,
+            redis: {
+                delBatch: async (keys: string[]) => {
+                    redisCalls.push({ keys: keys });
+                    return keys.length;
+                }
+            },
+            config: {
+                db: { type: "sqlite", database: "" }
+            }
+        } as any;
+
+        const item = buildTableItem({
+            tableFileName: tableFileName,
+            content: {
+                userId: fdNumber({ name: "用户ID", min: 0, max: 999999999, defaultValue: 0, nullable: false }),
+                userName: fdString({ name: "用户名", min: 0, max: 50, defaultValue: "", nullable: false })
+            }
+        });
+
+        await syncTable(ctx, [item]);
+
+        const dropUserName = state.executedSql.some((s) => s.includes("DROP INDEX") && s.includes("idx_user_name"));
+        expect(dropUserName).toBe(true);
+
+        const dropUserIdComposite = state.executedSql.some((s) => s.includes("DROP INDEX") && s.includes("idx_user_id"));
+        expect(dropUserIdComposite).toBe(false);
+
+        expect(redisCalls.length).toBe(1);
+        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
+    });
+});

package/tests/{syncDb-ddl.test.ts → syncTable-ddl.test.ts}

@@ -1,5 +1,5 @@
 /**
- * syncDb DDL 构建模块测试
+ * syncTable DDL 构建模块测试
  *
  * 测试 ddl.ts 中的函数：
  * - buildIndexSQL
@@ -9,31 +9,13 @@
  * - isCompatibleTypeChange
  */
 
-import { describe, test, expect, beforeAll } from "bun:test";
+import { describe, test, expect } from "bun:test";
 
-import { setDbType } from "../sync/syncDb/constants.js";
-
-// 设置数据库类型为 MySQL
-setDbType("mysql");
-
-let buildIndexSQL: any;
-let buildSystemColumnDefs: any;
-let buildBusinessColumnDefs: any;
-let generateDDLClause: any;
-let isCompatibleTypeChange: any;
-
-beforeAll(async () => {
-    const ddl = await import("../sync/syncDb/ddl.js");
-    buildIndexSQL = ddl.buildIndexSQL;
-    buildSystemColumnDefs = ddl.buildSystemColumnDefs;
-    buildBusinessColumnDefs = ddl.buildBusinessColumnDefs;
-    generateDDLClause = ddl.generateDDLClause;
-    isCompatibleTypeChange = ddl.isCompatibleTypeChange;
-});
+import { syncTable } from "../sync/syncTable.js";
 
 describe("buildIndexSQL (MySQL)", () => {
     test("创建索引 SQL", () => {
-        const sql = buildIndexSQL("user", "idx_created_at", "created_at", "create");
+        const sql = syncTable.TestKit.buildIndexSQL("mysql", "user", "idx_created_at", "created_at", "create");
         expect(sql).toContain("ALTER TABLE `user`");
         expect(sql).toContain("ADD INDEX `idx_created_at`");
         expect(sql).toContain("(`created_at`)");
@@ -42,7 +24,7 @@ describe("buildIndexSQL (MySQL)", () => {
     });
 
     test("删除索引 SQL", () => {
-        const sql = buildIndexSQL("user", "idx_created_at", "created_at", "drop");
+        const sql = syncTable.TestKit.buildIndexSQL("mysql", "user", "idx_created_at", "created_at", "drop");
         expect(sql).toContain("ALTER TABLE `user`");
         expect(sql).toContain("DROP INDEX `idx_created_at`");
     });
@@ -50,12 +32,12 @@ describe("buildIndexSQL (MySQL)", () => {
 
 describe("buildSystemColumnDefs (MySQL)", () => {
     test("返回 5 个系统字段定义", () => {
-        const defs = buildSystemColumnDefs();
+        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
         expect(defs.length).toBe(5);
     });
 
     test("包含 id 主键", () => {
-        const defs = buildSystemColumnDefs();
+        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
         const idDef = defs.find((d: string) => d.includes("`id`"));
         expect(idDef).toContain("PRIMARY KEY");
         expect(idDef).toContain("AUTO_INCREMENT");
@@ -63,7 +45,7 @@ describe("buildSystemColumnDefs (MySQL)", () => {
     });
 
     test("包含 created_at 字段", () => {
-        const defs = buildSystemColumnDefs();
+        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
         const def = defs.find((d: string) => d.includes("`created_at`"));
         expect(def).toContain("BIGINT UNSIGNED");
         expect(def).toContain("NOT NULL");
@@ -71,7 +53,7 @@ describe("buildSystemColumnDefs (MySQL)", () => {
     });
 
     test("包含 state 字段", () => {
-        const defs = buildSystemColumnDefs();
+        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
         const def = defs.find((d: string) => d.includes("`state`"));
         expect(def).toContain("BIGINT UNSIGNED");
         expect(def).toContain("NOT NULL");
@@ -79,6 +61,38 @@ describe("buildSystemColumnDefs (MySQL)", () => {
     });
 });
 
+describe("buildSystemColumnDefs (PostgreSQL)", () => {
+    test("返回 5 个系统字段定义", () => {
+        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
+        expect(defs.length).toBe(5);
+    });
+
+    test("包含 id 主键 identity", () => {
+        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
+        const idDef = defs.find((d: string) => d.includes('"id"'));
+        expect(idDef).toContain("BIGINT");
+        expect(idDef).toContain("PRIMARY KEY");
+        expect(idDef).toContain("GENERATED");
+        expect(idDef).toContain("IDENTITY");
+    });
+
+    test("包含 created_at BIGINT 默认值", () => {
+        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
+        const def = defs.find((d: string) => d.includes('"created_at"'));
+        expect(def).toContain("BIGINT");
+        expect(def).toContain("NOT NULL");
+        expect(def).toContain("DEFAULT 0");
+    });
+
+    test("包含 state BIGINT 默认值", () => {
+        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
+        const def = defs.find((d: string) => d.includes('"state"'));
+        expect(def).toContain("BIGINT");
+        expect(def).toContain("NOT NULL");
+        expect(def).toContain("DEFAULT 1");
+    });
+});
+
 describe("buildBusinessColumnDefs (MySQL)", () => {
     test("生成 string 类型字段", () => {
         const fields = {
@@ -92,7 +106,7 @@ describe("buildBusinessColumnDefs (MySQL)", () => {
                 unsigned: true
             }
         };
-        const defs = buildBusinessColumnDefs(fields);
+        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
         expect(defs.length).toBe(1);
         expect(defs[0]).toContain("`user_name`");
         expect(defs[0]).toContain("VARCHAR(50)");
@@ -113,7 +127,7 @@ describe("buildBusinessColumnDefs (MySQL)", () => {
                 unsigned: true
             }
         };
-        const defs = buildBusinessColumnDefs(fields);
+        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
         expect(defs[0]).toContain("`age`");
         expect(defs[0]).toContain("BIGINT UNSIGNED");
         expect(defs[0]).toContain("DEFAULT 0");
@@ -131,7 +145,7 @@ describe("buildBusinessColumnDefs (MySQL)", () => {
                 unsigned: true
             }
         };
-        const defs = buildBusinessColumnDefs(fields);
+        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
         expect(defs[0]).toContain("UNIQUE");
     });
 
@@ -147,7 +161,7 @@ describe("buildBusinessColumnDefs (MySQL)", () => {
                 unsigned: true
             }
         };
-        const defs = buildBusinessColumnDefs(fields);
+        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
         expect(defs[0]).toContain("NULL");
         expect(defs[0]).not.toContain("NOT NULL");
     });
@@ -164,7 +178,7 @@ describe("generateDDLClause (MySQL)", () => {
             nullable: false,
             unsigned: true
         };
-        const clause = generateDDLClause("userName", fieldDef, true);
+        const clause = syncTable.TestKit.generateDDLClause("mysql", "userName", fieldDef as any, true);
         expect(clause).toContain("ADD COLUMN");
         expect(clause).toContain("`user_name`");
         expect(clause).toContain("VARCHAR(50)");
@@ -180,7 +194,7 @@ describe("generateDDLClause (MySQL)", () => {
             nullable: false,
             unsigned: true
         };
-        const clause = generateDDLClause("userName", fieldDef, false);
+        const clause = syncTable.TestKit.generateDDLClause("mysql", "userName", fieldDef as any, false);
         expect(clause).toContain("MODIFY COLUMN");
         expect(clause).toContain("`user_name`");
         expect(clause).toContain("VARCHAR(100)");
@@ -189,43 +203,43 @@ describe("generateDDLClause (MySQL)", () => {
 
 describe("isCompatibleTypeChange", () => {
     test("varchar -> text 是兼容变更", () => {
-        expect(isCompatibleTypeChange("character varying", "text")).toBe(true);
-        expect(isCompatibleTypeChange("varchar(100)", "text")).toBe(true);
-        expect(isCompatibleTypeChange("varchar(100)", "mediumtext")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("character varying", "text")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("varchar(100)", "text")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("varchar(100)", "mediumtext")).toBe(true);
     });
 
     test("text -> varchar 不是兼容变更", () => {
-        expect(isCompatibleTypeChange("text", "character varying")).toBe(false);
-        expect(isCompatibleTypeChange("text", "varchar(100)")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("text", "character varying")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("text", "varchar(100)")).toBe(false);
     });
 
     test("int -> bigint 是兼容变更", () => {
-        expect(isCompatibleTypeChange("int", "bigint")).toBe(true);
-        expect(isCompatibleTypeChange("int unsigned", "bigint unsigned")).toBe(true);
-        expect(isCompatibleTypeChange("tinyint", "int")).toBe(true);
-        expect(isCompatibleTypeChange("tinyint", "bigint")).toBe(true);
-        expect(isCompatibleTypeChange("smallint", "int")).toBe(true);
-        expect(isCompatibleTypeChange("mediumint", "bigint")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("int", "bigint")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("int unsigned", "bigint unsigned")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("tinyint", "int")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("tinyint", "bigint")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "int")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("mediumint", "bigint")).toBe(true);
     });
 
     test("bigint -> int 不是兼容变更（收缩）", () => {
-        expect(isCompatibleTypeChange("bigint", "int")).toBe(false);
-        expect(isCompatibleTypeChange("int", "tinyint")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("bigint", "int")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("int", "tinyint")).toBe(false);
     });
 
     test("PG integer -> bigint 是兼容变更", () => {
-        expect(isCompatibleTypeChange("integer", "bigint")).toBe(true);
-        expect(isCompatibleTypeChange("smallint", "integer")).toBe(true);
-        expect(isCompatibleTypeChange("smallint", "bigint")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("integer", "bigint")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "integer")).toBe(true);
+        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "bigint")).toBe(true);
     });
 
     test("相同类型不是变更", () => {
-        expect(isCompatibleTypeChange("text", "text")).toBe(false);
-        expect(isCompatibleTypeChange("bigint", "bigint")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("text", "text")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("bigint", "bigint")).toBe(false);
     });
 
     test("空值处理", () => {
-        expect(isCompatibleTypeChange(null, "text")).toBe(false);
-        expect(isCompatibleTypeChange("text", null)).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange(null as any, "text")).toBe(false);
+        expect(syncTable.TestKit.isCompatibleTypeChange("text", null as any)).toBe(false);
     });
 });

package/tests/{syncDb-helpers.test.ts → syncTable-helpers.test.ts}

@@ -1,5 +1,5 @@
 /**
- * syncDb 辅助工具模块测试
+ * syncTable 辅助工具模块测试
  *
  * 测试 helpers.ts 中的函数：
  * - quoteIdentifier
@@ -7,49 +7,35 @@
  * - applyFieldDefaults
  */
 
-import { describe, test, expect, beforeAll } from "bun:test";
+import { describe, test, expect } from "bun:test";
 
-import { setDbType } from "../sync/syncDb/constants.js";
-
-// 设置数据库类型为 MySQL
-setDbType("mysql");
-
-let quoteIdentifier: any;
-let escapeComment: any;
-let applyFieldDefaults: any;
-
-beforeAll(async () => {
-    const helpers = await import("../sync/syncDb/helpers.js");
-    quoteIdentifier = helpers.quoteIdentifier;
-    escapeComment = helpers.escapeComment;
-    applyFieldDefaults = helpers.applyFieldDefaults;
-});
+import { syncTable } from "../sync/syncTable.js";
 
 describe("quoteIdentifier (MySQL)", () => {
     test("使用反引号包裹标识符", () => {
-        expect(quoteIdentifier("user_table")).toBe("`user_table`");
+        expect(syncTable.TestKit.quoteIdentifier("mysql", "user_table")).toBe("`user_table`");
     });
 
     test("处理普通表名", () => {
-        expect(quoteIdentifier("admin")).toBe("`admin`");
+        expect(syncTable.TestKit.quoteIdentifier("mysql", "admin")).toBe("`admin`");
     });
 
     test("处理带下划线的表名", () => {
-        expect(quoteIdentifier("addon_admin_menu")).toBe("`addon_admin_menu`");
+        expect(syncTable.TestKit.quoteIdentifier("mysql", "addon_admin_menu")).toBe("`addon_admin_menu`");
     });
 });
 
 describe("escapeComment", () => {
     test("普通注释不变", () => {
-        expect(escapeComment("用户名称")).toBe("用户名称");
+        expect(syncTable.TestKit.escapeComment("用户名称")).toBe("用户名称");
     });
 
     test("双引号被转义", () => {
-        expect(escapeComment('用户"昵称"')).toBe('用户\\"昵称\\"');
+        expect(syncTable.TestKit.escapeComment('用户"昵称"')).toBe('用户\\"昵称\\"');
     });
 
     test("空字符串", () => {
-        expect(escapeComment("")).toBe("");
+        expect(syncTable.TestKit.escapeComment("")).toBe("");
     });
 });
 
@@ -60,7 +46,7 @@ describe("applyFieldDefaults", () => {
             type: "string"
         };
 
-        applyFieldDefaults(fieldDef);
+        syncTable.TestKit.applyFieldDefaults(fieldDef);
 
         expect(fieldDef.detail).toBe("");
         expect(fieldDef.min).toBe(0);
@@ -83,7 +69,7 @@ describe("applyFieldDefaults", () => {
             nullable: true
         };
 
-        applyFieldDefaults(fieldDef);
+        syncTable.TestKit.applyFieldDefaults(fieldDef);
 
         expect(fieldDef.max).toBe(200);
         expect(fieldDef.index).toBe(true);
@@ -102,7 +88,7 @@ describe("applyFieldDefaults", () => {
             unsigned: false
         };
 
-        applyFieldDefaults(fieldDef);
+        syncTable.TestKit.applyFieldDefaults(fieldDef);
 
         expect(fieldDef.min).toBe(0);
         expect(fieldDef.max).toBe(0);