befly 3.8.25 → 3.8.27

package/tests/syncDb-ddl.test.ts

@@ -0,0 +1,205 @@
+/**
+ * syncDb DDL 构建模块测试
+ *
+ * 测试 ddl.ts 中的函数：
+ * - buildIndexSQL
+ * - buildSystemColumnDefs
+ * - buildBusinessColumnDefs
+ * - generateDDLClause
+ * - isPgCompatibleTypeChange
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = '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);
+    });
+});

package/tests/syncDb-helpers.test.ts

@@ -0,0 +1,112 @@
+/**
+ * syncDb 辅助工具模块测试
+ *
+ * 测试 helpers.ts 中的函数：
+ * - quoteIdentifier
+ * - escapeComment
+ * - applyFieldDefaults
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = '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;
+});
+
+describe('quoteIdentifier (MySQL)', () => {
+    test('使用反引号包裹标识符', () => {
+        expect(quoteIdentifier('user_table')).toBe('`user_table`');
+    });
+
+    test('处理普通表名', () => {
+        expect(quoteIdentifier('admin')).toBe('`admin`');
+    });
+
+    test('处理带下划线的表名', () => {
+        expect(quoteIdentifier('addon_admin_menu')).toBe('`addon_admin_menu`');
+    });
+});
+
+describe('escapeComment', () => {
+    test('普通注释不变', () => {
+        expect(escapeComment('用户名称')).toBe('用户名称');
+    });
+
+    test('双引号被转义', () => {
+        expect(escapeComment('用户"昵称"')).toBe('用户\\"昵称\\"');
+    });
+
+    test('空字符串', () => {
+        expect(escapeComment('')).toBe('');
+    });
+});
+
+describe('applyFieldDefaults', () => {
+    test('为空字段定义应用默认值', () => {
+        const fieldDef: any = {
+            name: '用户名',
+            type: 'string'
+        };
+
+        applyFieldDefaults(fieldDef);
+
+        expect(fieldDef.detail).toBe('');
+        expect(fieldDef.min).toBe(0);
+        expect(fieldDef.max).toBe(100);
+        expect(fieldDef.default).toBe(null);
+        expect(fieldDef.index).toBe(false);
+        expect(fieldDef.unique).toBe(false);
+        expect(fieldDef.comment).toBe('');
+        expect(fieldDef.nullable).toBe(false);
+        expect(fieldDef.unsigned).toBe(true);
+        expect(fieldDef.regexp).toBe(null);
+    });
+
+    test('保留已有值', () => {
+        const fieldDef: any = {
+            name: '用户名',
+            type: 'string',
+            max: 200,
+            index: true,
+            unique: true,
+            nullable: true
+        };
+
+        applyFieldDefaults(fieldDef);
+
+        expect(fieldDef.max).toBe(200);
+        expect(fieldDef.index).toBe(true);
+        expect(fieldDef.unique).toBe(true);
+        expect(fieldDef.nullable).toBe(true);
+    });
+
+    test('处理 0 和 false 值', () => {
+        const fieldDef: any = {
+            name: '排序',
+            type: 'number',
+            min: 0,
+            max: 0,
+            default: 0,
+            index: false,
+            unsigned: false
+        };
+
+        applyFieldDefaults(fieldDef);
+
+        expect(fieldDef.min).toBe(0);
+        expect(fieldDef.max).toBe(0);
+        expect(fieldDef.default).toBe(0);
+        expect(fieldDef.index).toBe(false);
+        expect(fieldDef.unsigned).toBe(false);
+    });
+});

package/tests/syncDb-schema.test.ts

@@ -0,0 +1,178 @@
+/**
+ * syncDb 表结构查询模块测试
+ *
+ * 测试 schema.ts 中的函数（纯逻辑测试，不需要数据库连接）：
+ * - tableExists
+ * - getTableColumns
+ * - getTableIndexes
+ *
+ * 注意：这些是模拟测试，实际数据库操作需要集成测试
+ */
+
+import { describe, test, expect, beforeAll, mock } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = 'mysql';
+process.env.DB_NAME = 'test_db';
+
+let tableExists: any;
+let getTableColumns: any;
+let getTableIndexes: any;
+
+beforeAll(async () => {
+    const schema = await import('../sync/syncDb/schema.js');
+    tableExists = schema.tableExists;
+    getTableColumns = schema.getTableColumns;
+    getTableIndexes = schema.getTableIndexes;
+});
+
+describe('tableExists', () => {
+    test('sql 客户端未初始化时抛出错误', async () => {
+        try {
+            await tableExists(null, 'user');
+            expect(true).toBe(false); // 不应该到这里
+        } catch (error: any) {
+            expect(error.message).toBe('SQL 客户端未初始化');
+        }
+    });
+
+    test('传入有效 sql 客户端时正常执行', async () => {
+        // 创建模拟 SQL 客户端
+        const mockSql = Object.assign(
+            async function (strings: TemplateStringsArray, ...values: any[]) {
+                // 模拟 MySQL 查询返回
+                return [{ count: 1 }];
+            },
+            {
+                unsafe: async (query: string) => []
+            }
+        );
+
+        const result = await tableExists(mockSql, 'user', 'test_db');
+        expect(result).toBe(true);
+    });
+
+    test('表不存在时返回 false', async () => {
+        const mockSql = Object.assign(
+            async function (strings: TemplateStringsArray, ...values: any[]) {
+                return [{ count: 0 }];
+            },
+            {
+                unsafe: async (query: string) => []
+            }
+        );
+
+        const result = await tableExists(mockSql, 'nonexistent', 'test_db');
+        expect(result).toBe(false);
+    });
+});
+
+describe('getTableColumns', () => {
+    test('返回正确的列信息结构', async () => {
+        const mockSql = Object.assign(
+            async function (strings: TemplateStringsArray, ...values: any[]) {
+                // 模拟 MySQL information_schema 返回
+                return [
+                    {
+                        COLUMN_NAME: 'id',
+                        DATA_TYPE: 'bigint',
+                        CHARACTER_MAXIMUM_LENGTH: null,
+                        IS_NULLABLE: 'NO',
+                        COLUMN_DEFAULT: null,
+                        COLUMN_COMMENT: '主键ID',
+                        COLUMN_TYPE: 'bigint unsigned'
+                    },
+                    {
+                        COLUMN_NAME: 'user_name',
+                        DATA_TYPE: 'varchar',
+                        CHARACTER_MAXIMUM_LENGTH: 50,
+                        IS_NULLABLE: 'NO',
+                        COLUMN_DEFAULT: '',
+                        COLUMN_COMMENT: '用户名',
+                        COLUMN_TYPE: 'varchar(50)'
+                    },
+                    {
+                        COLUMN_NAME: 'age',
+                        DATA_TYPE: 'bigint',
+                        CHARACTER_MAXIMUM_LENGTH: null,
+                        IS_NULLABLE: 'YES',
+                        COLUMN_DEFAULT: '0',
+                        COLUMN_COMMENT: '年龄',
+                        COLUMN_TYPE: 'bigint'
+                    }
+                ];
+            },
+            {
+                unsafe: async (query: string) => []
+            }
+        );
+
+        const columns = await getTableColumns(mockSql, 'user', 'test_db');
+
+        expect(columns.id).toBeDefined();
+        expect(columns.id.type).toBe('bigint');
+        expect(columns.id.nullable).toBe(false);
+        expect(columns.id.comment).toBe('主键ID');
+
+        expect(columns.user_name).toBeDefined();
+        expect(columns.user_name.type).toBe('varchar');
+        expect(columns.user_name.max).toBe(50);
+        expect(columns.user_name.nullable).toBe(false);
+        expect(columns.user_name.defaultValue).toBe('');
+
+        expect(columns.age).toBeDefined();
+        expect(columns.age.nullable).toBe(true);
+        expect(columns.age.defaultValue).toBe('0');
+    });
+});
+
+describe('getTableIndexes', () => {
+    test('返回正确的索引信息结构', async () => {
+        const mockSql = Object.assign(
+            async function (strings: TemplateStringsArray, ...values: any[]) {
+                // 模拟 MySQL information_schema.STATISTICS 返回
+                // 注意：PRIMARY 索引被排除
+                return [
+                    { INDEX_NAME: 'idx_created_at', COLUMN_NAME: 'created_at' },
+                    { INDEX_NAME: 'idx_user_name', COLUMN_NAME: 'user_name' }
+                ];
+            },
+            {
+                unsafe: async (query: string) => []
+            }
+        );
+
+        const indexes = await getTableIndexes(mockSql, 'user', 'test_db');
+
+        // PRIMARY 索引被排除，不应存在
+        expect(indexes.PRIMARY).toBeUndefined();
+
+        expect(indexes.idx_created_at).toBeDefined();
+        expect(indexes.idx_created_at).toContain('created_at');
+
+        expect(indexes.idx_user_name).toBeDefined();
+        expect(indexes.idx_user_name).toContain('user_name');
+    });
+
+    test('复合索引包含多个列', async () => {
+        const mockSql = Object.assign(
+            async function (strings: TemplateStringsArray, ...values: any[]) {
+                // 模拟复合索引，同一索引名包含多个列
+                return [
+                    { INDEX_NAME: 'idx_composite', COLUMN_NAME: 'user_id' },
+                    { INDEX_NAME: 'idx_composite', COLUMN_NAME: 'created_at' }
+                ];
+            },
+            {
+                unsafe: async (query: string) => []
+            }
+        );
+
+        const indexes = await getTableIndexes(mockSql, 'user', 'test_db');
+
+        expect(indexes.idx_composite).toBeDefined();
+        expect(indexes.idx_composite.length).toBe(2);
+        expect(indexes.idx_composite).toContain('user_id');
+        expect(indexes.idx_composite).toContain('created_at');
+    });
+});

package/tests/syncDb-types.test.ts

@@ -0,0 +1,129 @@
+/**
+ * syncDb 类型处理模块测试
+ *
+ * 测试 types.ts 中的函数：
+ * - isStringOrArrayType
+ * - getSqlType
+ * - resolveDefaultValue
+ * - generateDefaultSql
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = 'mysql';
+
+// 动态导入以确保环境变量生效
+let isStringOrArrayType: any;
+let getSqlType: any;
+let resolveDefaultValue: any;
+let generateDefaultSql: any;
+
+beforeAll(async () => {
+    const types = await import('../sync/syncDb/types.js');
+    isStringOrArrayType = types.isStringOrArrayType;
+    getSqlType = types.getSqlType;
+    resolveDefaultValue = types.resolveDefaultValue;
+    generateDefaultSql = types.generateDefaultSql;
+});
+
+describe('isStringOrArrayType', () => {
+    test('string 类型返回 true', () => {
+        expect(isStringOrArrayType('string')).toBe(true);
+    });
+
+    test('array_string 类型返回 true', () => {
+        expect(isStringOrArrayType('array_string')).toBe(true);
+    });
+
+    test('number 类型返回 false', () => {
+        expect(isStringOrArrayType('number')).toBe(false);
+    });
+
+    test('text 类型返回 false', () => {
+        expect(isStringOrArrayType('text')).toBe(false);
+    });
+
+    test('array_text 类型返回 false', () => {
+        expect(isStringOrArrayType('array_text')).toBe(false);
+    });
+});
+
+describe('resolveDefaultValue', () => {
+    test('null 值 + string 类型 => 空字符串', () => {
+        expect(resolveDefaultValue(null, 'string')).toBe('');
+    });
+
+    test('null 值 + number 类型 => 0', () => {
+        expect(resolveDefaultValue(null, 'number')).toBe(0);
+    });
+
+    test('"null" 字符串 + number 类型 => 0', () => {
+        expect(resolveDefaultValue('null', 'number')).toBe(0);
+    });
+
+    test('null 值 + array 类型 => "[]"', () => {
+        expect(resolveDefaultValue(null, 'array')).toBe('[]');
+    });
+
+    test('null 值 + text 类型 => "null"', () => {
+        expect(resolveDefaultValue(null, 'text')).toBe('null');
+    });
+
+    test('有实际值时直接返回', () => {
+        expect(resolveDefaultValue('admin', 'string')).toBe('admin');
+        expect(resolveDefaultValue(100, 'number')).toBe(100);
+        expect(resolveDefaultValue(0, 'number')).toBe(0);
+    });
+});
+
+describe('generateDefaultSql', () => {
+    test('number 类型生成数字默认值', () => {
+        expect(generateDefaultSql(0, 'number')).toBe(' DEFAULT 0');
+        expect(generateDefaultSql(100, 'number')).toBe(' DEFAULT 100');
+    });
+
+    test('string 类型生成带引号默认值', () => {
+        expect(generateDefaultSql('admin', 'string')).toBe(" DEFAULT 'admin'");
+        expect(generateDefaultSql('', 'string')).toBe(" DEFAULT ''");
+    });
+
+    test('text 类型不生成默认值', () => {
+        expect(generateDefaultSql('null', 'text')).toBe('');
+    });
+
+    test('array 类型生成 JSON 数组默认值', () => {
+        expect(generateDefaultSql('[]', 'array')).toBe(" DEFAULT '[]'");
+    });
+
+    test('单引号被正确转义', () => {
+        expect(generateDefaultSql("it's", 'string')).toBe(" DEFAULT 'it''s'");
+    });
+});
+
+describe('getSqlType', () => {
+    test('string 类型带长度', () => {
+        const result = getSqlType('string', 100);
+        expect(result).toBe('VARCHAR(100)');
+    });
+
+    test('array_string 类型带长度', () => {
+        const result = getSqlType('array_string', 500);
+        expect(result).toBe('VARCHAR(500)');
+    });
+
+    test('number 类型无符号', () => {
+        const result = getSqlType('number', null, true);
+        expect(result).toBe('BIGINT UNSIGNED');
+    });
+
+    test('number 类型有符号', () => {
+        const result = getSqlType('number', null, false);
+        expect(result).toBe('BIGINT');
+    });
+
+    test('text 类型', () => {
+        const result = getSqlType('text', null);
+        expect(result).toBe('MEDIUMTEXT');
+    });
+});

package/tsconfig.json

@@ -17,8 +17,8 @@
         "alwaysStrict": true,
 
         // 额外检查
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
         "noImplicitReturns": true,
         "noFallthroughCasesInSwitch": true,
         "noUncheckedIndexedAccess": false,

package/types/api.d.ts

@@ -35,7 +35,7 @@ export type AuthType = boolean | 'admin' | 'user' | string[];
 /**
  * API 处理器函数类型
  */
-export type ApiHandler<T = any, R = any> = (befly: BeflyContext, ctx: RequestContext, req?: Request) => Promise<Response | R> | Response | R;
+export type ApiHandler<T = any, R = any> = (befly: BeflyContext, ctx: RequestContext) => Promise<Response | R> | Response | R;
 
 /**
  * 字段规则定义