befly 3.9.38 → 3.9.40

package/tests/syncDb-apply.test.ts

@@ -5,183 +5,184 @@
  * - compareFieldDefinition
  */
 
-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 compareFieldDefinition: any;
 
 beforeAll(async () => {
-    const apply = await import('../sync/syncDb/apply.js');
+    const apply = await import("../sync/syncDb/apply.js");
     compareFieldDefinition = apply.compareFieldDefinition;
 });
 
-describe('compareFieldDefinition', () => {
-    describe('长度变化检测', () => {
-        test('string 类型长度变化被检测到', () => {
+describe("compareFieldDefinition", () => {
+    describe("长度变化检测", () => {
+        test("string 类型长度变化被检测到", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 50,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const lengthChange = changes.find((c: any) => c.type === 'length');
+            const lengthChange = changes.find((c: any) => c.type === "length");
 
             expect(lengthChange).toBeDefined();
             expect(lengthChange.current).toBe(50);
             expect(lengthChange.expected).toBe(100);
         });
 
-        test('长度相同无变化', () => {
+        test("长度相同无变化", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const lengthChange = changes.find((c: any) => c.type === 'length');
+            const lengthChange = changes.find((c: any) => c.type === "length");
 
             expect(lengthChange).toBeUndefined();
         });
     });
 
-    describe('注释变化检测', () => {
-        test('注释变化被检测到', () => {
+    describe("注释变化检测", () => {
+        test("注释变化被检测到", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '旧注释'
+                defaultValue: "",
+                comment: "旧注释"
             };
             const fieldDef = {
-                name: '新注释',
-                type: 'string',
+                name: "新注释",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const commentChange = changes.find((c: any) => c.type === 'comment');
+            const commentChange = changes.find((c: any) => c.type === "comment");
 
             expect(commentChange).toBeDefined();
-            expect(commentChange.current).toBe('旧注释');
-            expect(commentChange.expected).toBe('新注释');
+            expect(commentChange.current).toBe("旧注释");
+            expect(commentChange.expected).toBe("新注释");
         });
 
-        test('注释相同无变化', () => {
+        test("注释相同无变化", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const commentChange = changes.find((c: any) => c.type === 'comment');
+            const commentChange = changes.find((c: any) => c.type === "comment");
 
             expect(commentChange).toBeUndefined();
         });
     });
 
-    describe('数据类型变化检测', () => {
-        test('类型变化被检测到', () => {
+    describe("数据类型变化检测", () => {
+        test("类型变化被检测到", () => {
             const existingColumn = {
-                type: 'bigint',
+                type: "bigint",
                 max: null,
                 nullable: false,
                 defaultValue: 0,
-                comment: '数量'
+                comment: "数量"
             };
             const fieldDef = {
-                name: '数量',
-                type: 'string',
+                name: "数量",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const typeChange = changes.find((c: any) => c.type === 'datatype');
+            const typeChange = changes.find((c: any) => c.type === "datatype");
 
             expect(typeChange).toBeDefined();
-            expect(typeChange.current).toBe('bigint');
-            expect(typeChange.expected).toBe('varchar');
+            expect(typeChange.current).toBe("bigint");
+            expect(typeChange.expected).toBe("varchar");
         });
 
-        test('类型相同无变化', () => {
+        test("类型相同无变化", () => {
             const existingColumn = {
-                type: 'bigint',
+                type: "bigint",
                 max: null,
                 nullable: false,
                 defaultValue: 0,
-                comment: '数量'
+                comment: "数量"
             };
             const fieldDef = {
-                name: '数量',
-                type: 'number',
+                name: "数量",
+                type: "number",
                 max: null,
                 nullable: false,
                 default: 0
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const typeChange = changes.find((c: any) => c.type === 'datatype');
+            const typeChange = changes.find((c: any) => c.type === "datatype");
 
             expect(typeChange).toBeUndefined();
         });
     });
 
-    describe('可空性变化检测', () => {
-        test('nullable 变化被检测到', () => {
+    describe("可空性变化检测", () => {
+        test("nullable 变化被检测到", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: true,
                 default: null
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const nullableChange = changes.find((c: any) => c.type === 'nullable');
+            const nullableChange = changes.find((c: any) => c.type === "nullable");
 
             expect(nullableChange).toBeDefined();
             expect(nullableChange.current).toBe(false);
@@ -189,92 +190,92 @@ describe('compareFieldDefinition', () => {
         });
     });
 
-    describe('默认值变化检测', () => {
-        test('默认值变化被检测到', () => {
+    describe("默认值变化检测", () => {
+        test("默认值变化被检测到", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: 'old',
-                comment: '用户名'
+                defaultValue: "old",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
-                default: 'new'
+                default: "new"
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const defaultChange = changes.find((c: any) => c.type === 'default');
+            const defaultChange = changes.find((c: any) => c.type === "default");
 
             expect(defaultChange).toBeDefined();
-            expect(defaultChange.current).toBe('old');
-            expect(defaultChange.expected).toBe('new');
+            expect(defaultChange.current).toBe("old");
+            expect(defaultChange.expected).toBe("new");
         });
 
-        test('null 默认值被正确处理', () => {
+        test("null 默认值被正确处理", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null // null 会被解析为空字符串
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
-            const defaultChange = changes.find((c: any) => c.type === 'default');
+            const defaultChange = changes.find((c: any) => c.type === "default");
 
             // null -> '' (空字符串)，与现有值相同，无变化
             expect(defaultChange).toBeUndefined();
         });
     });
 
-    describe('多变化组合', () => {
-        test('多个变化同时被检测', () => {
+    describe("多变化组合", () => {
+        test("多个变化同时被检测", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 50,
                 nullable: false,
-                defaultValue: 'old',
-                comment: '旧注释'
+                defaultValue: "old",
+                comment: "旧注释"
             };
             const fieldDef = {
-                name: '新注释',
-                type: 'string',
+                name: "新注释",
+                type: "string",
                 max: 100,
                 nullable: true,
-                default: 'new'
+                default: "new"
             };
 
             const changes = compareFieldDefinition(existingColumn, fieldDef);
 
             expect(changes.length).toBe(4); // length, comment, nullable, default
-            expect(changes.some((c: any) => c.type === 'length')).toBe(true);
-            expect(changes.some((c: any) => c.type === 'comment')).toBe(true);
-            expect(changes.some((c: any) => c.type === 'nullable')).toBe(true);
-            expect(changes.some((c: any) => c.type === 'default')).toBe(true);
+            expect(changes.some((c: any) => c.type === "length")).toBe(true);
+            expect(changes.some((c: any) => c.type === "comment")).toBe(true);
+            expect(changes.some((c: any) => c.type === "nullable")).toBe(true);
+            expect(changes.some((c: any) => c.type === "default")).toBe(true);
         });
 
-        test('无变化返回空数组', () => {
+        test("无变化返回空数组", () => {
             const existingColumn = {
-                type: 'varchar',
+                type: "varchar",
                 max: 100,
                 nullable: false,
-                defaultValue: '',
-                comment: '用户名'
+                defaultValue: "",
+                comment: "用户名"
             };
             const fieldDef = {
-                name: '用户名',
-                type: 'string',
+                name: "用户名",
+                type: "string",
                 max: 100,
                 nullable: false,
                 default: null

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

@@ -0,0 +1,160 @@
+/**
+ * 测试 syncDb 对 array_number_string 和 array_number_text 类型的支持
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { getSqlType, resolveDefaultValue, generateDefaultSql, isStringOrArrayType } from "../sync/syncDb/types.js";
+
+describe("syncDb - array_number 类型支持", () => {
+    // ==================== 类型判断测试 ====================
+
+    test("isStringOrArrayType: array_number_string 需要长度", () => {
+        expect(isStringOrArrayType("array_number_string")).toBe(true);
+    });
+
+    test("isStringOrArrayType: array_number_text 不需要长度", () => {
+        expect(isStringOrArrayType("array_number_text")).toBe(false);
+    });
+
+    // ==================== SQL 类型映射测试 ====================
+
+    test("getSqlType: array_number_string 生成 VARCHAR(max)", () => {
+        const sqlType = getSqlType("array_number_string", 500);
+        expect(sqlType).toMatch(/VARCHAR\(500\)/i);
+    });
+
+    test("getSqlType: array_number_text 生成 TEXT/MEDIUMTEXT", () => {
+        const sqlType = getSqlType("array_number_text", null);
+        expect(sqlType).toMatch(/TEXT/i);
+    });
+
+    test("getSqlType: array_number_string 使用 max 参数", () => {
+        const sqlType1 = getSqlType("array_number_string", 200);
+        const sqlType2 = getSqlType("array_number_string", 1000);
+
+        expect(sqlType1).toMatch(/VARCHAR\(200\)/i);
+        expect(sqlType2).toMatch(/VARCHAR\(1000\)/i);
+    });
+
+    // ==================== 默认值处理测试 ====================
+
+    test('resolveDefaultValue: array_number_string null 时返回 "[]"', () => {
+        const result = resolveDefaultValue(null, "array_number_string");
+        expect(result).toBe("[]");
+    });
+
+    test("resolveDefaultValue: array_number_string 有默认值时保留", () => {
+        const result = resolveDefaultValue("[1,2,3]", "array_number_string");
+        expect(result).toBe("[1,2,3]");
+    });
+
+    test('resolveDefaultValue: array_number_text null 时返回 "null"', () => {
+        const result = resolveDefaultValue(null, "array_number_text");
+        expect(result).toBe("null");
+    });
+
+    test("resolveDefaultValue: array_number_text 有默认值时保留", () => {
+        const result = resolveDefaultValue("[100,200]", "array_number_text");
+        expect(result).toBe("[100,200]");
+    });
+
+    test('resolveDefaultValue: 字符串 "null" 也视为 null', () => {
+        const result1 = resolveDefaultValue("null", "array_number_string");
+        const result2 = resolveDefaultValue("null", "array_number_text");
+
+        expect(result1).toBe("[]");
+        expect(result2).toBe("null");
+    });
+
+    // ==================== SQL DEFAULT 子句测试 ====================
+
+    test("generateDefaultSql: array_number_string 生成 DEFAULT 子句", () => {
+        const sql = generateDefaultSql("[]", "array_number_string");
+        expect(sql).toBe(" DEFAULT '[]'");
+    });
+
+    test("generateDefaultSql: array_number_string 自定义默认值", () => {
+        const sql = generateDefaultSql("[10,20,30]", "array_number_string");
+        expect(sql).toBe(" DEFAULT '[10,20,30]'");
+    });
+
+    test("generateDefaultSql: array_number_text 不生成 DEFAULT", () => {
+        const sql = generateDefaultSql("[]", "array_number_text");
+        expect(sql).toBe("");
+    });
+
+    test("generateDefaultSql: array_number_text null 时不生成 DEFAULT", () => {
+        const sql = generateDefaultSql("null", "array_number_text");
+        expect(sql).toBe("");
+    });
+
+    // ==================== 单引号转义测试 ====================
+
+    test("generateDefaultSql: 默认值包含单引号时正确转义", () => {
+        const sql = generateDefaultSql("[1,'test',2]", "array_number_string");
+        expect(sql).toBe(" DEFAULT '[1,''test'',2]'");
+    });
+
+    // ==================== 完整流程测试 ====================
+
+    test("完整流程: array_number_string 字段定义", () => {
+        // 模拟字段定义："标签ID|array_number_string|0|500|[]|0"
+        const fieldType = "array_number_string";
+        const fieldMax = 500;
+        const fieldDefault = null;
+
+        // 1. 判断是否需要长度
+        expect(isStringOrArrayType(fieldType)).toBe(true);
+
+        // 2. 获取 SQL 类型
+        const sqlType = getSqlType(fieldType, fieldMax);
+        expect(sqlType).toMatch(/VARCHAR\(500\)/i);
+
+        // 3. 处理默认值
+        const actualDefault = resolveDefaultValue(fieldDefault, fieldType);
+        expect(actualDefault).toBe("[]");
+
+        // 4. 生成 DEFAULT 子句
+        const defaultSql = generateDefaultSql(actualDefault, fieldType);
+        expect(defaultSql).toBe(" DEFAULT '[]'");
+    });
+
+    test("完整流程: array_number_text 字段定义", () => {
+        // 模拟字段定义："关联ID|array_number_text|||null|0"
+        const fieldType = "array_number_text";
+        const fieldMax = null;
+        const fieldDefault = null;
+
+        // 1. 判断是否需要长度
+        expect(isStringOrArrayType(fieldType)).toBe(false);
+
+        // 2. 获取 SQL 类型
+        const sqlType = getSqlType(fieldType, fieldMax);
+        expect(sqlType).toMatch(/TEXT/i);
+
+        // 3. 处理默认值
+        const actualDefault = resolveDefaultValue(fieldDefault, fieldType);
+        expect(actualDefault).toBe("null");
+
+        // 4. 生成 DEFAULT 子句（TEXT 类型不支持）
+        const defaultSql = generateDefaultSql(actualDefault, fieldType);
+        expect(defaultSql).toBe("");
+    });
+
+    test("完整流程: array_number_string 自定义默认值", () => {
+        // 模拟字段定义："分数|array_number_string|2|10|[60,70,80]|0"
+        const fieldType = "array_number_string";
+        const fieldMax = 10;
+        const fieldDefault = "[60,70,80]";
+
+        const sqlType = getSqlType(fieldType, fieldMax);
+        expect(sqlType).toMatch(/VARCHAR\(10\)/i);
+
+        const actualDefault = resolveDefaultValue(fieldDefault, fieldType);
+        expect(actualDefault).toBe("[60,70,80]");
+
+        const defaultSql = generateDefaultSql(actualDefault, fieldType);
+        expect(defaultSql).toBe(" DEFAULT '[60,70,80]'");
+    });
+});