befly 3.9.37 → 3.9.39

package/tests/syncDb-constants.test.ts

@@ -10,120 +10,121 @@
  * - typeMapping
  */
 
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { setDbType } from '../sync/syncDb/constants.js';
+import { describe, test, expect, beforeAll } from "bun:test";
+
+import { setDbType } from "../sync/syncDb/constants.js";
 
 // 设置数据库类型为 MySQL
-setDbType('mysql');
+setDbType("mysql");
 
 let constants: any;
 
 beforeAll(async () => {
-    constants = await import('../sync/syncDb/constants.js');
+    constants = await import("../sync/syncDb/constants.js");
 });
 
-describe('DB_VERSION_REQUIREMENTS', () => {
-    test('MySQL 最低版本为 8', () => {
+describe("DB_VERSION_REQUIREMENTS", () => {
+    test("MySQL 最低版本为 8", () => {
         expect(constants.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
     });
 
-    test('PostgreSQL 最低版本为 17', () => {
+    test("PostgreSQL 最低版本为 17", () => {
         expect(constants.DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR).toBe(17);
     });
 
-    test('SQLite 最低版本为 3.50.0', () => {
-        expect(constants.DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION).toBe('3.50.0');
+    test("SQLite 最低版本为 3.50.0", () => {
+        expect(constants.DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION).toBe("3.50.0");
     });
 });
 
-describe('SYSTEM_INDEX_FIELDS', () => {
-    test('包含 created_at', () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain('created_at');
+describe("SYSTEM_INDEX_FIELDS", () => {
+    test("包含 created_at", () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain("created_at");
     });
 
-    test('包含 updated_at', () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain('updated_at');
+    test("包含 updated_at", () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain("updated_at");
     });
 
-    test('包含 state', () => {
-        expect(constants.SYSTEM_INDEX_FIELDS).toContain('state');
+    test("包含 state", () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain("state");
     });
 
-    test('共 3 个系统索引字段', () => {
+    test("共 3 个系统索引字段", () => {
         expect(constants.SYSTEM_INDEX_FIELDS.length).toBe(3);
     });
 });
 
-describe('CHANGE_TYPE_LABELS', () => {
+describe("CHANGE_TYPE_LABELS", () => {
     test('length 对应 "长度"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.length).toBe('长度');
+        expect(constants.CHANGE_TYPE_LABELS.length).toBe("长度");
     });
 
     test('datatype 对应 "类型"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.datatype).toBe('类型');
+        expect(constants.CHANGE_TYPE_LABELS.datatype).toBe("类型");
     });
 
     test('comment 对应 "注释"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.comment).toBe('注释');
+        expect(constants.CHANGE_TYPE_LABELS.comment).toBe("注释");
     });
 
     test('default 对应 "默认值"', () => {
-        expect(constants.CHANGE_TYPE_LABELS.default).toBe('默认值');
+        expect(constants.CHANGE_TYPE_LABELS.default).toBe("默认值");
     });
 });
 
-describe('MYSQL_TABLE_CONFIG', () => {
-    test('ENGINE 为 InnoDB', () => {
-        expect(constants.MYSQL_TABLE_CONFIG.ENGINE).toBe('InnoDB');
+describe("MYSQL_TABLE_CONFIG", () => {
+    test("ENGINE 为 InnoDB", () => {
+        expect(constants.MYSQL_TABLE_CONFIG.ENGINE).toBe("InnoDB");
     });
 
-    test('CHARSET 为 utf8mb4', () => {
-        expect(constants.MYSQL_TABLE_CONFIG.CHARSET).toBe('utf8mb4');
+    test("CHARSET 为 utf8mb4", () => {
+        expect(constants.MYSQL_TABLE_CONFIG.CHARSET).toBe("utf8mb4");
     });
 
-    test('COLLATE 为 utf8mb4_0900_ai_ci', () => {
-        expect(constants.MYSQL_TABLE_CONFIG.COLLATE).toBe('utf8mb4_0900_ai_ci');
+    test("COLLATE 为 utf8mb4_0900_ai_ci", () => {
+        expect(constants.MYSQL_TABLE_CONFIG.COLLATE).toBe("utf8mb4_0900_ai_ci");
     });
 });
 
-describe('getTypeMapping (MySQL)', () => {
-    test('number 映射为 BIGINT', () => {
-        expect(constants.getTypeMapping().number).toBe('BIGINT');
+describe("getTypeMapping (MySQL)", () => {
+    test("number 映射为 BIGINT", () => {
+        expect(constants.getTypeMapping().number).toBe("BIGINT");
     });
 
-    test('string 映射为 VARCHAR', () => {
-        expect(constants.getTypeMapping().string).toBe('VARCHAR');
+    test("string 映射为 VARCHAR", () => {
+        expect(constants.getTypeMapping().string).toBe("VARCHAR");
     });
 
-    test('text 映射为 MEDIUMTEXT', () => {
-        expect(constants.getTypeMapping().text).toBe('MEDIUMTEXT');
+    test("text 映射为 MEDIUMTEXT", () => {
+        expect(constants.getTypeMapping().text).toBe("MEDIUMTEXT");
     });
 
-    test('array_string 映射为 VARCHAR', () => {
-        expect(constants.getTypeMapping().array_string).toBe('VARCHAR');
+    test("array_string 映射为 VARCHAR", () => {
+        expect(constants.getTypeMapping().array_string).toBe("VARCHAR");
     });
 
-    test('array_text 映射为 MEDIUMTEXT', () => {
-        expect(constants.getTypeMapping().array_text).toBe('MEDIUMTEXT');
+    test("array_text 映射为 MEDIUMTEXT", () => {
+        expect(constants.getTypeMapping().array_text).toBe("MEDIUMTEXT");
     });
 });
 
-describe('IS_PLAN', () => {
-    test('IS_PLAN 为 boolean 类型', () => {
-        expect(typeof constants.IS_PLAN).toBe('boolean');
+describe("IS_PLAN", () => {
+    test("IS_PLAN 为 boolean 类型", () => {
+        expect(typeof constants.IS_PLAN).toBe("boolean");
     });
 });
 
-describe('数据库类型判断 (MySQL)', () => {
-    test('isMySQL 为 true', () => {
+describe("数据库类型判断 (MySQL)", () => {
+    test("isMySQL 为 true", () => {
         expect(constants.isMySQL()).toBe(true);
     });
 
-    test('isPG 为 false', () => {
+    test("isPG 为 false", () => {
         expect(constants.isPG()).toBe(false);
     });
 
-    test('isSQLite 为 false', () => {
+    test("isSQLite 为 false", () => {
         expect(constants.isSQLite()).toBe(false);
     });
 });

package/tests/syncDb-ddl.test.ts

@@ -9,11 +9,12 @@
  * - isCompatibleTypeChange
  */
 
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { setDbType } from '../sync/syncDb/constants.js';
+import { describe, test, expect, beforeAll } from "bun:test";
+
+import { setDbType } from "../sync/syncDb/constants.js";
 
 // 设置数据库类型为 MySQL
-setDbType('mysql');
+setDbType("mysql");
 
 let buildIndexSQL: any;
 let buildSystemColumnDefs: any;
@@ -22,7 +23,7 @@ let generateDDLClause: any;
 let isCompatibleTypeChange: any;
 
 beforeAll(async () => {
-    const ddl = await import('../sync/syncDb/ddl.js');
+    const ddl = await import("../sync/syncDb/ddl.js");
     buildIndexSQL = ddl.buildIndexSQL;
     buildSystemColumnDefs = ddl.buildSystemColumnDefs;
     buildBusinessColumnDefs = ddl.buildBusinessColumnDefs;
@@ -30,60 +31,60 @@ beforeAll(async () => {
     isCompatibleTypeChange = ddl.isCompatibleTypeChange;
 });
 
-describe('buildIndexSQL (MySQL)', () => {
-    test('创建索引 SQL', () => {
-        const sql = buildIndexSQL('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`)');
-        expect(sql).toContain('ALGORITHM=INPLACE');
-        expect(sql).toContain('LOCK=NONE');
+describe("buildIndexSQL (MySQL)", () => {
+    test("创建索引 SQL", () => {
+        const sql = buildIndexSQL("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`)");
+        expect(sql).toContain("ALGORITHM=INPLACE");
+        expect(sql).toContain("LOCK=NONE");
     });
 
-    test('删除索引 SQL', () => {
-        const sql = buildIndexSQL('user', 'idx_created_at', 'created_at', 'drop');
-        expect(sql).toContain('ALTER TABLE `user`');
-        expect(sql).toContain('DROP INDEX `idx_created_at`');
+    test("删除索引 SQL", () => {
+        const sql = buildIndexSQL("user", "idx_created_at", "created_at", "drop");
+        expect(sql).toContain("ALTER TABLE `user`");
+        expect(sql).toContain("DROP INDEX `idx_created_at`");
     });
 });
 
-describe('buildSystemColumnDefs (MySQL)', () => {
-    test('返回 5 个系统字段定义', () => {
+describe("buildSystemColumnDefs (MySQL)", () => {
+    test("返回 5 个系统字段定义", () => {
         const defs = buildSystemColumnDefs();
         expect(defs.length).toBe(5);
     });
 
-    test('包含 id 主键', () => {
+    test("包含 id 主键", () => {
         const defs = buildSystemColumnDefs();
-        const idDef = defs.find((d: string) => d.includes('`id`'));
-        expect(idDef).toContain('PRIMARY KEY');
-        expect(idDef).toContain('AUTO_INCREMENT');
-        expect(idDef).toContain('BIGINT UNSIGNED');
+        const idDef = defs.find((d: string) => d.includes("`id`"));
+        expect(idDef).toContain("PRIMARY KEY");
+        expect(idDef).toContain("AUTO_INCREMENT");
+        expect(idDef).toContain("BIGINT UNSIGNED");
     });
 
-    test('包含 created_at 字段', () => {
+    test("包含 created_at 字段", () => {
         const defs = buildSystemColumnDefs();
-        const def = defs.find((d: string) => d.includes('`created_at`'));
-        expect(def).toContain('BIGINT UNSIGNED');
-        expect(def).toContain('NOT NULL');
-        expect(def).toContain('DEFAULT 0');
+        const def = defs.find((d: string) => d.includes("`created_at`"));
+        expect(def).toContain("BIGINT UNSIGNED");
+        expect(def).toContain("NOT NULL");
+        expect(def).toContain("DEFAULT 0");
     });
 
-    test('包含 state 字段', () => {
+    test("包含 state 字段", () => {
         const defs = buildSystemColumnDefs();
-        const def = defs.find((d: string) => d.includes('`state`'));
-        expect(def).toContain('BIGINT UNSIGNED');
-        expect(def).toContain('NOT NULL');
-        expect(def).toContain('DEFAULT 1');
+        const def = defs.find((d: string) => d.includes("`state`"));
+        expect(def).toContain("BIGINT UNSIGNED");
+        expect(def).toContain("NOT NULL");
+        expect(def).toContain("DEFAULT 1");
     });
 });
 
-describe('buildBusinessColumnDefs (MySQL)', () => {
-    test('生成 string 类型字段', () => {
+describe("buildBusinessColumnDefs (MySQL)", () => {
+    test("生成 string 类型字段", () => {
         const fields = {
             userName: {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 50,
                 default: null,
                 unique: false,
@@ -93,18 +94,18 @@ describe('buildBusinessColumnDefs (MySQL)', () => {
         };
         const defs = buildBusinessColumnDefs(fields);
         expect(defs.length).toBe(1);
-        expect(defs[0]).toContain('`user_name`');
-        expect(defs[0]).toContain('VARCHAR(50)');
-        expect(defs[0]).toContain('NOT NULL');
+        expect(defs[0]).toContain("`user_name`");
+        expect(defs[0]).toContain("VARCHAR(50)");
+        expect(defs[0]).toContain("NOT NULL");
         expect(defs[0]).toContain("DEFAULT ''");
         expect(defs[0]).toContain('COMMENT "用户名"');
     });
 
-    test('生成 number 类型字段', () => {
+    test("生成 number 类型字段", () => {
         const fields = {
             age: {
-                name: '年龄',
-                type: 'number',
+                name: "年龄",
+                type: "number",
                 max: null,
                 default: 0,
                 unique: false,
@@ -113,16 +114,16 @@ describe('buildBusinessColumnDefs (MySQL)', () => {
             }
         };
         const defs = buildBusinessColumnDefs(fields);
-        expect(defs[0]).toContain('`age`');
-        expect(defs[0]).toContain('BIGINT UNSIGNED');
-        expect(defs[0]).toContain('DEFAULT 0');
+        expect(defs[0]).toContain("`age`");
+        expect(defs[0]).toContain("BIGINT UNSIGNED");
+        expect(defs[0]).toContain("DEFAULT 0");
     });
 
-    test('生成 unique 字段', () => {
+    test("生成 unique 字段", () => {
         const fields = {
             email: {
-                name: '邮箱',
-                type: 'string',
+                name: "邮箱",
+                type: "string",
                 max: 100,
                 default: null,
                 unique: true,
@@ -131,14 +132,14 @@ describe('buildBusinessColumnDefs (MySQL)', () => {
             }
         };
         const defs = buildBusinessColumnDefs(fields);
-        expect(defs[0]).toContain('UNIQUE');
+        expect(defs[0]).toContain("UNIQUE");
     });
 
-    test('生成 nullable 字段', () => {
+    test("生成 nullable 字段", () => {
         const fields = {
             remark: {
-                name: '备注',
-                type: 'string',
+                name: "备注",
+                type: "string",
                 max: 200,
                 default: null,
                 unique: false,
@@ -147,84 +148,84 @@ describe('buildBusinessColumnDefs (MySQL)', () => {
             }
         };
         const defs = buildBusinessColumnDefs(fields);
-        expect(defs[0]).toContain('NULL');
-        expect(defs[0]).not.toContain('NOT NULL');
+        expect(defs[0]).toContain("NULL");
+        expect(defs[0]).not.toContain("NOT NULL");
     });
 });
 
-describe('generateDDLClause (MySQL)', () => {
-    test('生成 ADD COLUMN 子句', () => {
+describe("generateDDLClause (MySQL)", () => {
+    test("生成 ADD COLUMN 子句", () => {
         const fieldDef = {
-            name: '用户名',
-            type: 'string',
+            name: "用户名",
+            type: "string",
             max: 50,
             default: null,
             unique: false,
             nullable: false,
             unsigned: true
         };
-        const clause = generateDDLClause('userName', fieldDef, true);
-        expect(clause).toContain('ADD COLUMN');
-        expect(clause).toContain('`user_name`');
-        expect(clause).toContain('VARCHAR(50)');
+        const clause = generateDDLClause("userName", fieldDef, true);
+        expect(clause).toContain("ADD COLUMN");
+        expect(clause).toContain("`user_name`");
+        expect(clause).toContain("VARCHAR(50)");
     });
 
-    test('生成 MODIFY COLUMN 子句', () => {
+    test("生成 MODIFY COLUMN 子句", () => {
         const fieldDef = {
-            name: '用户名',
-            type: 'string',
+            name: "用户名",
+            type: "string",
             max: 100,
             default: null,
             unique: false,
             nullable: false,
             unsigned: true
         };
-        const clause = generateDDLClause('userName', fieldDef, false);
-        expect(clause).toContain('MODIFY COLUMN');
-        expect(clause).toContain('`user_name`');
-        expect(clause).toContain('VARCHAR(100)');
+        const clause = generateDDLClause("userName", fieldDef, false);
+        expect(clause).toContain("MODIFY COLUMN");
+        expect(clause).toContain("`user_name`");
+        expect(clause).toContain("VARCHAR(100)");
     });
 });
 
-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);
+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);
     });
 
-    test('text -> varchar 不是兼容变更', () => {
-        expect(isCompatibleTypeChange('text', 'character varying')).toBe(false);
-        expect(isCompatibleTypeChange('text', 'varchar(100)')).toBe(false);
+    test("text -> varchar 不是兼容变更", () => {
+        expect(isCompatibleTypeChange("text", "character varying")).toBe(false);
+        expect(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);
+    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);
     });
 
-    test('bigint -> int 不是兼容变更（收缩）', () => {
-        expect(isCompatibleTypeChange('bigint', 'int')).toBe(false);
-        expect(isCompatibleTypeChange('int', 'tinyint')).toBe(false);
+    test("bigint -> int 不是兼容变更（收缩）", () => {
+        expect(isCompatibleTypeChange("bigint", "int")).toBe(false);
+        expect(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);
+    test("PG integer -> bigint 是兼容变更", () => {
+        expect(isCompatibleTypeChange("integer", "bigint")).toBe(true);
+        expect(isCompatibleTypeChange("smallint", "integer")).toBe(true);
+        expect(isCompatibleTypeChange("smallint", "bigint")).toBe(true);
     });
 
-    test('相同类型不是变更', () => {
-        expect(isCompatibleTypeChange('text', 'text')).toBe(false);
-        expect(isCompatibleTypeChange('bigint', 'bigint')).toBe(false);
+    test("相同类型不是变更", () => {
+        expect(isCompatibleTypeChange("text", "text")).toBe(false);
+        expect(isCompatibleTypeChange("bigint", "bigint")).toBe(false);
     });
 
-    test('空值处理', () => {
-        expect(isCompatibleTypeChange(null, 'text')).toBe(false);
-        expect(isCompatibleTypeChange('text', null)).toBe(false);
+    test("空值处理", () => {
+        expect(isCompatibleTypeChange(null, "text")).toBe(false);
+        expect(isCompatibleTypeChange("text", null)).toBe(false);
     });
 });

package/tests/syncDb-helpers.test.ts

@@ -7,61 +7,62 @@
  * - applyFieldDefaults
  */
 
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { setDbType } from '../sync/syncDb/constants.js';
+import { describe, test, expect, beforeAll } from "bun:test";
+
+import { setDbType } from "../sync/syncDb/constants.js";
 
 // 设置数据库类型为 MySQL
-setDbType('mysql');
+setDbType("mysql");
 
 let quoteIdentifier: any;
 let escapeComment: any;
 let applyFieldDefaults: any;
 
 beforeAll(async () => {
-    const helpers = await import('../sync/syncDb/helpers.js');
+    const helpers = await import("../sync/syncDb/helpers.js");
     quoteIdentifier = helpers.quoteIdentifier;
     escapeComment = helpers.escapeComment;
     applyFieldDefaults = helpers.applyFieldDefaults;
 });
 
-describe('quoteIdentifier (MySQL)', () => {
-    test('使用反引号包裹标识符', () => {
-        expect(quoteIdentifier('user_table')).toBe('`user_table`');
+describe("quoteIdentifier (MySQL)", () => {
+    test("使用反引号包裹标识符", () => {
+        expect(quoteIdentifier("user_table")).toBe("`user_table`");
     });
 
-    test('处理普通表名', () => {
-        expect(quoteIdentifier('admin')).toBe('`admin`');
+    test("处理普通表名", () => {
+        expect(quoteIdentifier("admin")).toBe("`admin`");
     });
 
-    test('处理带下划线的表名', () => {
-        expect(quoteIdentifier('addon_admin_menu')).toBe('`addon_admin_menu`');
+    test("处理带下划线的表名", () => {
+        expect(quoteIdentifier("addon_admin_menu")).toBe("`addon_admin_menu`");
     });
 });
 
-describe('escapeComment', () => {
-    test('普通注释不变', () => {
-        expect(escapeComment('用户名称')).toBe('用户名称');
+describe("escapeComment", () => {
+    test("普通注释不变", () => {
+        expect(escapeComment("用户名称")).toBe("用户名称");
     });
 
-    test('双引号被转义', () => {
+    test("双引号被转义", () => {
         expect(escapeComment('用户"昵称"')).toBe('用户\\"昵称\\"');
     });
 
-    test('空字符串', () => {
-        expect(escapeComment('')).toBe('');
+    test("空字符串", () => {
+        expect(escapeComment("")).toBe("");
     });
 });
 
-describe('applyFieldDefaults', () => {
-    test('为空字段定义应用默认值', () => {
+describe("applyFieldDefaults", () => {
+    test("为空字段定义应用默认值", () => {
         const fieldDef: any = {
-            name: '用户名',
-            type: 'string'
+            name: "用户名",
+            type: "string"
         };
 
         applyFieldDefaults(fieldDef);
 
-        expect(fieldDef.detail).toBe('');
+        expect(fieldDef.detail).toBe("");
         expect(fieldDef.min).toBe(0);
         expect(fieldDef.max).toBe(100);
         expect(fieldDef.default).toBe(null);
@@ -72,10 +73,10 @@ describe('applyFieldDefaults', () => {
         expect(fieldDef.regexp).toBe(null);
     });
 
-    test('保留已有值', () => {
+    test("保留已有值", () => {
         const fieldDef: any = {
-            name: '用户名',
-            type: 'string',
+            name: "用户名",
+            type: "string",
             max: 200,
             index: true,
             unique: true,
@@ -90,10 +91,10 @@ describe('applyFieldDefaults', () => {
         expect(fieldDef.nullable).toBe(true);
     });
 
-    test('处理 0 和 false 值', () => {
+    test("处理 0 和 false 值", () => {
         const fieldDef: any = {
-            name: '排序',
-            type: 'number',
+            name: "排序",
+            type: "number",
             min: 0,
             max: 0,
             default: 0,