befly 3.8.25 → 3.8.29

package/tests/syncDb-apply.test.ts

@@ -0,0 +1,288 @@
+/**
+ * syncDb 变更应用模块测试
+ *
+ * 测试 apply.ts 中的函数：
+ * - compareFieldDefinition
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { setDbType } from '../sync/syncDb/constants.js';
+
+// 设置数据库类型为 MySQL
+setDbType('mysql');
+
+let compareFieldDefinition: any;
+
+beforeAll(async () => {
+    const apply = await import('../sync/syncDb/apply.js');
+    compareFieldDefinition = apply.compareFieldDefinition;
+});
+
+describe('compareFieldDefinition', () => {
+    describe('长度变化检测', () => {
+        test('string 类型长度变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 50,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const lengthChange = changes.find((c: any) => c.type === 'length');
+
+            expect(lengthChange).toBeDefined();
+            expect(lengthChange.current).toBe(50);
+            expect(lengthChange.expected).toBe(100);
+        });
+
+        test('长度相同无变化', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const lengthChange = changes.find((c: any) => c.type === 'length');
+
+            expect(lengthChange).toBeUndefined();
+        });
+    });
+
+    describe('注释变化检测', () => {
+        test('注释变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '旧注释'
+            };
+            const fieldDef = {
+                name: '新注释',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const commentChange = changes.find((c: any) => c.type === 'comment');
+
+            expect(commentChange).toBeDefined();
+            expect(commentChange.current).toBe('旧注释');
+            expect(commentChange.expected).toBe('新注释');
+        });
+
+        test('注释相同无变化', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const commentChange = changes.find((c: any) => c.type === 'comment');
+
+            expect(commentChange).toBeUndefined();
+        });
+    });
+
+    describe('数据类型变化检测', () => {
+        test('类型变化被检测到', () => {
+            const existingColumn = {
+                type: 'bigint',
+                max: null,
+                nullable: false,
+                defaultValue: 0,
+                comment: '数量'
+            };
+            const fieldDef = {
+                name: '数量',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const typeChange = changes.find((c: any) => c.type === 'datatype');
+
+            expect(typeChange).toBeDefined();
+            expect(typeChange.current).toBe('bigint');
+            expect(typeChange.expected).toBe('varchar');
+        });
+
+        test('类型相同无变化', () => {
+            const existingColumn = {
+                type: 'bigint',
+                max: null,
+                nullable: false,
+                defaultValue: 0,
+                comment: '数量'
+            };
+            const fieldDef = {
+                name: '数量',
+                type: 'number',
+                max: null,
+                nullable: false,
+                default: 0
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const typeChange = changes.find((c: any) => c.type === 'datatype');
+
+            expect(typeChange).toBeUndefined();
+        });
+    });
+
+    describe('可空性变化检测', () => {
+        test('nullable 变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: true,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const nullableChange = changes.find((c: any) => c.type === 'nullable');
+
+            expect(nullableChange).toBeDefined();
+            expect(nullableChange.current).toBe(false);
+            expect(nullableChange.expected).toBe(true);
+        });
+    });
+
+    describe('默认值变化检测', () => {
+        test('默认值变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: 'old',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: 'new'
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const defaultChange = changes.find((c: any) => c.type === 'default');
+
+            expect(defaultChange).toBeDefined();
+            expect(defaultChange.current).toBe('old');
+            expect(defaultChange.expected).toBe('new');
+        });
+
+        test('null 默认值被正确处理', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null // null 会被解析为空字符串
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const defaultChange = changes.find((c: any) => c.type === 'default');
+
+            // null -> '' (空字符串)，与现有值相同，无变化
+            expect(defaultChange).toBeUndefined();
+        });
+    });
+
+    describe('多变化组合', () => {
+        test('多个变化同时被检测', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 50,
+                nullable: false,
+                defaultValue: 'old',
+                comment: '旧注释'
+            };
+            const fieldDef = {
+                name: '新注释',
+                type: 'string',
+                max: 100,
+                nullable: true,
+                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);
+        });
+
+        test('无变化返回空数组', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+
+            expect(changes.length).toBe(0);
+        });
+    });
+});

package/tests/syncDb-constants.test.ts

@@ -0,0 +1,151 @@
+/**
+ * syncDb 常量模块测试
+ *
+ * 测试 constants.ts 中的常量：
+ * - DB_VERSION_REQUIREMENTS
+ * - SYSTEM_FIELDS
+ * - SYSTEM_INDEX_FIELDS
+ * - CHANGE_TYPE_LABELS
+ * - MYSQL_TABLE_CONFIG
+ * - typeMapping
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { setDbType } from '../sync/syncDb/constants.js';
+
+// 设置数据库类型为 MySQL
+setDbType('mysql');
+
+let constants: any;
+
+beforeAll(async () => {
+    constants = await import('../sync/syncDb/constants.js');
+});
+
+describe('DB_VERSION_REQUIREMENTS', () => {
+    test('MySQL 最低版本为 8', () => {
+        expect(constants.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
+    });
+
+    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');
+    });
+});
+
+describe('SYSTEM_FIELDS', () => {
+    test('包含 id 字段', () => {
+        expect(constants.SYSTEM_FIELDS.ID.name).toBe('id');
+    });
+
+    test('包含 created_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.CREATED_AT.name).toBe('created_at');
+    });
+
+    test('包含 updated_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.UPDATED_AT.name).toBe('updated_at');
+    });
+
+    test('包含 deleted_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.DELETED_AT.name).toBe('deleted_at');
+    });
+
+    test('包含 state 字段', () => {
+        expect(constants.SYSTEM_FIELDS.STATE.name).toBe('state');
+    });
+});
+
+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('包含 state', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain('state');
+    });
+
+    test('共 3 个系统索引字段', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS.length).toBe(3);
+    });
+});
+
+describe('CHANGE_TYPE_LABELS', () => {
+    test('length 对应 "长度"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.length).toBe('长度');
+    });
+
+    test('datatype 对应 "类型"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.datatype).toBe('类型');
+    });
+
+    test('comment 对应 "注释"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.comment).toBe('注释');
+    });
+
+    test('default 对应 "默认值"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.default).toBe('默认值');
+    });
+});
+
+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('COLLATE 为 utf8mb4_0900_ai_ci', () => {
+        expect(constants.MYSQL_TABLE_CONFIG.COLLATE).toBe('utf8mb4_0900_ai_ci');
+    });
+});
+
+describe('typeMapping (MySQL)', () => {
+    test('number 映射为 BIGINT', () => {
+        expect(constants.typeMapping.number).toBe('BIGINT');
+    });
+
+    test('string 映射为 VARCHAR', () => {
+        expect(constants.typeMapping.string).toBe('VARCHAR');
+    });
+
+    test('text 映射为 MEDIUMTEXT', () => {
+        expect(constants.typeMapping.text).toBe('MEDIUMTEXT');
+    });
+
+    test('array_string 映射为 VARCHAR', () => {
+        expect(constants.typeMapping.array_string).toBe('VARCHAR');
+    });
+
+    test('array_text 映射为 MEDIUMTEXT', () => {
+        expect(constants.typeMapping.array_text).toBe('MEDIUMTEXT');
+    });
+});
+
+describe('IS_PLAN', () => {
+    test('IS_PLAN 为 boolean 类型', () => {
+        expect(typeof constants.IS_PLAN).toBe('boolean');
+    });
+});
+
+describe('数据库类型判断 (MySQL)', () => {
+    test('IS_MYSQL 为 true', () => {
+        expect(constants.IS_MYSQL).toBe(true);
+    });
+
+    test('IS_PG 为 false', () => {
+        expect(constants.IS_PG).toBe(false);
+    });
+
+    test('IS_SQLITE 为 false', () => {
+        expect(constants.IS_SQLITE).toBe(false);
+    });
+});

package/tests/syncDb-ddl.test.ts

@@ -0,0 +1,206 @@
+/**
+ * syncDb DDL 构建模块测试
+ *
+ * 测试 ddl.ts 中的函数：
+ * - buildIndexSQL
+ * - buildSystemColumnDefs
+ * - buildBusinessColumnDefs
+ * - generateDDLClause
+ * - isPgCompatibleTypeChange
+ */
+
+import { describe, test, expect, beforeAll } 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 isPgCompatibleTypeChange: any;
+
+beforeAll(async () => {
+    const ddl = await import('../sync/syncDb/ddl.js');
+    buildIndexSQL = ddl.buildIndexSQL;
+    buildSystemColumnDefs = ddl.buildSystemColumnDefs;
+    buildBusinessColumnDefs = ddl.buildBusinessColumnDefs;
+    generateDDLClause = ddl.generateDDLClause;
+    isPgCompatibleTypeChange = ddl.isPgCompatibleTypeChange;
+});
+
+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`');
+    });
+});
+
+describe('buildSystemColumnDefs (MySQL)', () => {
+    test('返回 5 个系统字段定义', () => {
+        const defs = buildSystemColumnDefs();
+        expect(defs.length).toBe(5);
+    });
+
+    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');
+    });
+
+    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');
+    });
+
+    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 0');
+    });
+});
+
+describe('buildBusinessColumnDefs (MySQL)', () => {
+    test('生成 string 类型字段', () => {
+        const fields = {
+            userName: {
+                name: '用户名',
+                type: 'string',
+                max: 50,
+                default: null,
+                unique: false,
+                nullable: false,
+                unsigned: true
+            }
+        };
+        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("DEFAULT ''");
+        expect(defs[0]).toContain('COMMENT "用户名"');
+    });
+
+    test('生成 number 类型字段', () => {
+        const fields = {
+            age: {
+                name: '年龄',
+                type: 'number',
+                max: null,
+                default: 0,
+                unique: false,
+                nullable: false,
+                unsigned: true
+            }
+        };
+        const defs = buildBusinessColumnDefs(fields);
+        expect(defs[0]).toContain('`age`');
+        expect(defs[0]).toContain('BIGINT UNSIGNED');
+        expect(defs[0]).toContain('DEFAULT 0');
+    });
+
+    test('生成 unique 字段', () => {
+        const fields = {
+            email: {
+                name: '邮箱',
+                type: 'string',
+                max: 100,
+                default: null,
+                unique: true,
+                nullable: false,
+                unsigned: true
+            }
+        };
+        const defs = buildBusinessColumnDefs(fields);
+        expect(defs[0]).toContain('UNIQUE');
+    });
+
+    test('生成 nullable 字段', () => {
+        const fields = {
+            remark: {
+                name: '备注',
+                type: 'string',
+                max: 200,
+                default: null,
+                unique: false,
+                nullable: true,
+                unsigned: true
+            }
+        };
+        const defs = buildBusinessColumnDefs(fields);
+        expect(defs[0]).toContain('NULL');
+        expect(defs[0]).not.toContain('NOT NULL');
+    });
+});
+
+describe('generateDDLClause (MySQL)', () => {
+    test('生成 ADD COLUMN 子句', () => {
+        const fieldDef = {
+            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)');
+    });
+
+    test('生成 MODIFY COLUMN 子句', () => {
+        const fieldDef = {
+            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)');
+    });
+});
+
+describe('isPgCompatibleTypeChange', () => {
+    test('varchar -> text 是兼容变更', () => {
+        expect(isPgCompatibleTypeChange('character varying', 'text')).toBe(true);
+    });
+
+    test('text -> varchar 不是兼容变更', () => {
+        expect(isPgCompatibleTypeChange('text', 'character varying')).toBe(false);
+    });
+
+    test('相同类型不是变更', () => {
+        expect(isPgCompatibleTypeChange('text', 'text')).toBe(false);
+    });
+
+    test('空值处理', () => {
+        expect(isPgCompatibleTypeChange(null, 'text')).toBe(false);
+        expect(isPgCompatibleTypeChange('text', null)).toBe(false);
+    });
+});