befly 3.8.25 → 3.8.27

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;

package/hooks/responseFormatter.ts

@@ -1,64 +0,0 @@
-// 相对导入
-import { JsonResponse } from '../util.js';
-
-// 类型导入
-import type { Hook } from '../types/hook.js';
-
-const hook: Hook = {
-    after: ['requestId'],
-    order: 100,
-    handler: async (befly, ctx, next) => {
-        await next();
-
-        // 如果已经有 response，直接返回
-        if (ctx.response) {
-            return;
-        }
-
-        // 如果有 result，格式化为 JSON 响应
-        if (ctx.result !== undefined) {
-            let result = ctx.result;
-
-            // 1. 如果是字符串，自动包裹为成功响应
-            if (typeof result === 'string') {
-                result = {
-                    code: 0,
-                    msg: result,
-                    data: {}
-                };
-            }
-            // 2. 如果是对象，自动补充 code: 0
-            else if (result && typeof result === 'object') {
-                if (!('code' in result)) {
-                    result = {
-                        code: 0,
-                        ...result
-                    };
-                }
-            }
-
-            // 处理 BigInt 序列化问题
-            if (result && typeof result === 'object') {
-                const jsonString = JSON.stringify(result, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
-                ctx.response = new Response(jsonString, {
-                    headers: {
-                        ...ctx.corsHeaders,
-                        'Content-Type': 'application/json'
-                    }
-                });
-            } else {
-                // 简单类型直接返回
-                ctx.response = Response.json(result, {
-                    headers: ctx.corsHeaders
-                });
-            }
-            return;
-        }
-
-        // 如果还没有响应，且不是 OPTIONS 请求，则设置默认 JSON 响应
-        if (ctx.req.method !== 'OPTIONS' && !ctx.response) {
-            ctx.response = JsonResponse(ctx, 'No response generated');
-        }
-    }
-};
-export default hook;

package/router/root.ts

@@ -1,56 +0,0 @@
-/**
- * 根路径路由处理器
- * 处理 / 路径的请求
- */
-
-// 相对导入
-import { Logger } from '../lib/logger.js';
-import { setCorsOptions } from '../util.js';
-
-/**
- * 根路径处理器
- */
-export async function rootHandler(req: Request): Promise<Response> {
-    // 设置 CORS 响应头
-    const corsHeaders = setCorsOptions(req);
-
-    try {
-        return Response.json(
-            {
-                code: 0,
-                msg: `Befly 接口服务已启动`,
-                data: {
-                    mode: process.env.NODE_ENV || 'development',
-                    timestamp: Date.now()
-                }
-            },
-            {
-                headers: corsHeaders
-            }
-        );
-    } catch (error: any) {
-        // 记录详细的错误日志
-        Logger.error('根路径处理失败', error);
-
-        // 根据错误类型返回不同的错误信息
-        let errorMessage = '服务异常';
-        let errorDetail = {};
-
-        // 开发环境返回详细错误信息
-        if (process.env.NODE_ENV === 'development') {
-            errorDetail = {
-                type: error.constructor?.name || 'Error',
-                message: error.message,
-                stack: error.stack
-            };
-        }
-
-        return Response.json(
-            { code: 1, msg: errorMessage, data: errorDetail },
-            {
-                status: 500,
-                headers: corsHeaders
-            }
-        );
-    }
-}

package/sync/syncDb/index.ts

@@ -1,164 +0,0 @@
-/**
- * syncDb 主入口文件
- *
- * 功能：
- * - 协调所有模块，执行数据库表结构同步
- * - 处理核心表、项目表、addon 表
- * - 提供统计信息和错误处理
- */
-
-import { basename, resolve } from 'pathe';
-import { existsSync } from 'node:fs';
-import { snakeCase } from 'es-toolkit/string';
-import { Database } from '../../lib/database.js';
-import { RedisHelper } from '../../lib/redisHelper.js';
-import { checkTable } from '../../checks/checkTable.js';
-import { scanFiles, scanAddons, addonDirExists, getAddonDir } from 'befly-util';
-import { Logger } from '../../lib/logger.js';
-import { projectDir } from '../../paths.js';
-
-// 导入模块化的功能
-import { ensureDbVersion } from './version.js';
-import { tableExists } from './schema.js';
-import { modifyTable } from './table.js';
-import { createTable } from './tableCreate.js';
-import { applyFieldDefaults } from './helpers.js';
-import type { SQL } from 'bun';
-import type { BeflyOptions, SyncDbOptions } from '../../types/index.js';
-
-// 全局 SQL 客户端实例
-let sql: SQL | null = null;
-
-// 记录处理过的表名（用于清理缓存）
-const processedTables: string[] = [];
-
-/**
- * 主同步函数
- *
- * 流程：
- * 1. 验证表定义文件
- * 2. 建立数据库连接并检查版本
- * 3. 扫描表定义文件（核心表、项目表、addon表）
- * 4. 对比并应用表结构变更
- */
-export const SyncDb = async (config: BeflyOptions, options: SyncDbOptions = {}): Promise<void> => {
-    try {
-        // 清空处理记录
-        processedTables.length = 0;
-
-        // 验证表定义文件
-        await checkTable();
-
-        // 建立数据库连接并检查版本
-        sql = await Database.connectSql({ max: 1 });
-        await ensureDbVersion(sql);
-
-        // 初始化 Redis 连接（用于清理缓存）
-        await Database.connectRedis();
-
-        // 扫描表定义文件
-        const directories: Array<{ path: string; type: 'app' | 'addon'; addonName?: string; addonNameSnake?: string }> = [];
-
-        // 1. 项目表（无前缀）- 如果 tables 目录存在
-        const projectTablesDir = resolve(projectDir, 'tables');
-        if (existsSync(projectTablesDir)) {
-            directories.push({ path: projectTablesDir, type: 'app' });
-        }
-
-        // 添加所有 addon 的 tables 目录（addon_{name}_ 前缀）
-        const addons = scanAddons();
-        for (const addon of addons) {
-            if (addonDirExists(addon, 'tables')) {
-                directories.push({
-                    path: getAddonDir(addon, 'tables'),
-                    type: 'addon',
-                    addonName: addon,
-                    addonNameSnake: snakeCase(addon) // 提前转换，避免每个文件都转换
-                });
-            }
-        }
-
-        // 处理表文件
-        for (const dirConfig of directories) {
-            const { path: dir, type, addonName } = dirConfig;
-            const dirType = type === 'addon' ? `组件${addonName}` : '项目';
-
-            const files = await scanFiles(dir, '*.json');
-
-            for (const { filePath: file, fileName } of files) {
-                // 确定表名：
-                // - addon 表：{addonName}_{表名}
-                //   例如：admin addon 的 user.json → admin_user
-                // - 项目表：{表名}
-                //   例如：user.json → user
-                let tableName = snakeCase(fileName);
-                if (type === 'addon' && dirConfig.addonNameSnake) {
-                    // addon 表，使用提前转换好的名称
-                    tableName = `addon_${dirConfig.addonNameSnake}_${tableName}`;
-                }
-
-                // 如果指定了表名，则只同步该表
-                if (options.table && options.table !== tableName) {
-                    continue;
-                }
-
-                const tableDefinitionModule = await import(file, { with: { type: 'json' } });
-                const tableDefinition = tableDefinitionModule.default;
-
-                // 为字段属性设置默认值
-                for (const fieldDef of Object.values(tableDefinition)) {
-                    applyFieldDefaults(fieldDef);
-                }
-
-                const dbName = config.plugins?.db?.database;
-                const existsTable = await tableExists(sql!, tableName, dbName);
-
-                // 读取 force 参数
-                const force = options.force || false;
-
-                if (existsTable) {
-                    await modifyTable(sql!, tableName, tableDefinition, force, dbName);
-                } else {
-                    await createTable(sql!, tableName, tableDefinition);
-                }
-
-                // 记录处理过的表名（用于清理缓存）
-                processedTables.push(tableName);
-            }
-        }
-
-        // 清理 Redis 缓存（如果有表被处理）
-        if (processedTables.length > 0) {
-            Logger.debug(`🧹 清理 ${processedTables.length} 个表的字段缓存...`);
-
-            const redisHelper = new RedisHelper();
-            for (const tableName of processedTables) {
-                const cacheKey = `table:columns:${tableName}`;
-                try {
-                    await redisHelper.del(cacheKey);
-                } catch (error: any) {
-                    Logger.warn(`清理表 ${tableName} 的缓存失败: ${error.message}`);
-                }
-            }
-
-            Logger.debug(`✓ 已清理表字段缓存`);
-        }
-    } catch (error: any) {
-        Logger.error(`数据库同步失败`, error);
-        throw error;
-    } finally {
-        if (sql) {
-            try {
-                await Database.disconnectSql();
-            } catch (error: any) {
-                Logger.warn(`关闭数据库连接时出错: ${error.message}`);
-            }
-        }
-
-        try {
-            await Database.disconnectRedis();
-        } catch (error: any) {
-            Logger.warn(`关闭 Redis 连接时出错: ${error.message}`);
-        }
-    }
-};