befly 3.8.25 → 3.8.29

package/tests/syncDb-helpers.test.ts

@@ -0,0 +1,113 @@
+/**
+ * syncDb 辅助工具模块测试
+ *
+ * 测试 helpers.ts 中的函数：
+ * - quoteIdentifier
+ * - escapeComment
+ * - applyFieldDefaults
+ */
+
+import { describe, test, expect, beforeAll } 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;
+});
+
+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';
+import { setDbType } from '../sync/syncDb/constants.js';
+
+// 设置数据库类型为 MySQL
+setDbType('mysql');
+
+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,130 @@
+/**
+ * syncDb 类型处理模块测试
+ *
+ * 测试 types.ts 中的函数：
+ * - isStringOrArrayType
+ * - getSqlType
+ * - resolveDefaultValue
+ * - generateDefaultSql
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { setDbType } from '../sync/syncDb/constants.js';
+
+// 设置数据库类型为 MySQL
+setDbType('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;
 
 /**
  * 字段规则定义

package/types/befly.d.ts

@@ -146,32 +146,34 @@ export interface BeflyOptions {
  * 包含所有插件挂载的实例
  */
 export interface BeflyContext extends KeyValue {
-    // ========== 核心插件（带下划线前缀） ==========
-    /** 数据库助手 (db 插件) */
-    _db?: DbHelper;
-
-    /** Redis 助手 (redis 插件) */
-    _redis?: RedisHelper;
-
-    /** 日志器 (logger 插件) */
-    _logger?: typeof Logger;
-
-    /** 缓存助手 (cache 插件) */
-    _cache?: CacheHelper;
-
-    // ========== 核心插件便捷访问（无前缀） ==========
-    /** 数据库助手便捷访问 */
+    // ========== 核心插件 ==========
+    /** 数据库助手 */
     db?: DbHelper;
 
-    /** Redis 助手便捷访问 */
+    /** Redis 助手 */
     redis?: RedisHelper;
 
-    /** 日志器便捷访问 */
+    /** 日志器 */
     logger?: typeof Logger;
 
-    /** 缓存助手便捷访问 */
+    /** 缓存助手 */
     cache?: CacheHelper;
 
+    /** 工具函数 */
+    tool?: {
+        Yes: (msg: string, data?: any, other?: Record<string, any>) => { code: 0; msg: string; data: any };
+        No: (msg: string, data?: any, other?: Record<string, any>) => { code: 1; msg: string; data: any };
+    };
+
+    /** 加密解密 */
+    cipher?: typeof Cipher;
+
+    /** JWT 令牌 */
+    jwt?: typeof Jwt;
+
+    /** 项目配置 */
+    config?: BeflyOptions;
+
     // ========== 动态插件 ==========
     /** 组件插件：addon_{addonName}_{pluginName} */
     /** 项目插件：app_{pluginName} */
@@ -183,13 +185,13 @@ export interface BeflyContext extends KeyValue {
  */
 export interface Befly {
     /** API 路由映射 */
-    apiRoutes: Map<string, ApiRoute>;
+    apis: Map<string, ApiRoute>;
 
     /** 插件列表 */
-    pluginLists: Plugin[];
+    plugins: Plugin[];
 
     /** 应用上下文 */
-    appContext: KeyValue;
+    context: KeyValue;
 
     /** 应用选项 */
     appOptions: BeflyOptions;

package/types/common.d.ts

@@ -128,35 +128,6 @@ export interface LoggerConfig {
     };
 }
 
-/**
- * 环境变量类型
- */
-export interface EnvConfig {
-    // 服务配置
-    appName: string;
-    appHost: string;
-    appPort: number;
-
-    // 数据库配置
-    mysqlHost: string;
-    mysqlPort: number;
-    mysqlUsername: string;
-    mysqlPassword: string;
-    mysqlDatabase: string;
-
-    // Redis 配置
-    redisHost?: string;
-    redisPort?: number;
-    redisPassword?: string;
-
-    // JWT 配置
-    jwtSecret: string;
-    jwtExpires?: string;
-
-    // 其他配置
-    [key: string]: any;
-}
-
 /**
  * 工具函数返回类型
  */

package/types/context.d.ts

@@ -17,17 +17,19 @@ export interface RequestContext {
     /** 请求开始时间（毫秒） */
     now: number;
     /** 客户端 IP 地址 */
-    ip?: string;
+    ip: string;
+    /** 请求头 */
+    headers: Headers;
     /** API 路由路径（如 POST/api/user/login） */
-    route?: string;
+    route: string;
+    /** 请求唯一 ID */
+    requestId: string;
+    /** CORS 响应头 */
+    corsHeaders: Record<string, string>;
     /** 当前请求的 API 路由对象 */
     api?: ApiRoute;
     /** 响应对象（如果设置了此属性，将直接返回该响应） */
     response?: Response;
     /** 原始处理结果（未转换为 Response 对象前） */
     result?: any;
-    /** 请求唯一 ID */
-    requestId?: string;
-    /** CORS 响应头 */
-    corsHeaders?: Record<string, string>;
 }

package/types/hook.d.ts

@@ -6,10 +6,9 @@ import type { BeflyContext } from './befly.js';
 import type { RequestContext } from './context.js';
 
 /**
- * 钩子处理函数类型
+ * 钩子处理函数类型（串联模式，无 next 参数）
  */
-export type Next = () => Promise<void>;
-export type HookHandler = (befly: BeflyContext, ctx: RequestContext, next: Next) => Promise<void> | void;
+export type HookHandler = (befly: BeflyContext, ctx: RequestContext) => Promise<void> | void;
 
 /**
  * 钩子配置类型
@@ -21,7 +20,7 @@ export interface Hook {
     /** 依赖的钩子列表（在这些钩子之后执行） */
     after?: string[];
 
-    /** 执行顺序（数字越小越先执行，同级别时使用） */
+    /** 执行顺序（数字越小越先执行） */
     order?: number;
 
     /** 钩子处理函数 */

package/types/plugin.d.ts

@@ -28,6 +28,9 @@ export interface Plugin {
     after?: string[];
 
     /** 插件初始化函数 */
+    handler?: (context: BeflyContext, config?: Record<string, any>) => any | Promise<any>;
+
+    /** @deprecated use handler instead */
     onInit?: PluginInitFunction;
 
     /** 插件配置 */

package/hooks/errorHandler.ts

@@ -1,23 +0,0 @@
-// 相对导入
-import { Logger } from '../lib/logger.js';
-import { JsonResponse } from '../util.js';
-
-// 类型导入
-import type { Hook } from '../types/hook.js';
-
-const hook: Hook = {
-    order: 1,
-    handler: async (befly, ctx, next) => {
-        try {
-            await next();
-        } catch (err: any) {
-            // 记录错误信息
-            const apiPath = ctx.api ? `${ctx.req.method}${new URL(ctx.req.url).pathname}` : ctx.req.url;
-            Logger.error(`Request Error: ${apiPath}`, err);
-
-            // 设置错误响应
-            ctx.response = JsonResponse(ctx, '内部服务错误');
-        }
-    }
-};
-export default hook;

package/hooks/requestId.ts

@@ -1,24 +0,0 @@
-import type { Hook } from '../types/hook.js';
-import { logContextStorage } from '../lib/logger.js';
-
-const hook: Hook = {
-    after: ['errorHandler'],
-    order: 3,
-    handler: async (befly, ctx, next) => {
-        // 生成唯一请求 ID
-        const requestId = crypto.randomUUID();
-        ctx.requestId = requestId;
-
-        // 添加到 CORS 响应头
-        if (!ctx.corsHeaders) {
-            ctx.corsHeaders = {};
-        }
-        ctx.corsHeaders['X-Request-ID'] = requestId;
-
-        // 在 AsyncLocalStorage 上下文中执行后续钩子
-        await logContextStorage.run({ requestId }, async () => {
-            await next();
-        });
-    }
-};
-export default hook;

package/hooks/requestLogger.ts

@@ -1,25 +0,0 @@
-// 相对导入
-import { Logger } from '../lib/logger.js';
-
-// 类型导入
-import type { Hook } from '../types/hook.js';
-
-/**
- * 请求日志记录钩子
- * 记录请求方法、路径、用户信息和响应时间
- */
-const hook: Hook = {
-    after: ['parser'],
-    order: 30,
-    handler: async (befly, ctx, next) => {
-        await next();
-
-        if (ctx.api) {
-            const apiPath = `${ctx.req.method}${new URL(ctx.req.url).pathname}`;
-            const duration = Date.now() - ctx.now;
-            const user = ctx.user?.userId ? `[User:${ctx.user.userId}]` : '[Guest]';
-            Logger.info(`[${ctx.req.method}] ${apiPath} ${user} ${duration}ms`);
-        }
-    }
-};
-export default hook;