befly 3.8.19 → 3.8.20

package/plugins/cache.ts

@@ -11,9 +11,7 @@ import type { BeflyContext } from '../types/befly.js';
  * 缓存插件
  */
 const cachePlugin: Plugin = {
-    name: '_cache',
-    after: ['_db', '_redis'],
-
+    after: ['db', 'redis'],
     async onInit(befly: BeflyContext): Promise<CacheHelper> {
         return new CacheHelper(befly);
     }

package/plugins/db.ts

@@ -3,7 +3,6 @@
  * 初始化数据库连接和 SQL 管理器
  */
 
-import { Env } from '../env.js';
 import { Logger } from '../lib/logger.js';
 import { Database } from '../lib/database.js';
 import { DbHelper } from '../lib/dbHelper.js';
@@ -14,21 +13,19 @@ import type { BeflyContext } from '../types/befly.js';
  * 数据库插件
  */
 const dbPlugin: Plugin = {
-    name: '_db',
-    after: ['_redis'],
-
-    async onInit(befly: BeflyContext): Promise<DbHelper | Record<string, never>> {
+    after: ['redis'],
+    async onInit(this: Plugin, befly: BeflyContext): Promise<DbHelper | Record<string, never>> {
         let sql: any = null;
+        const config = this.config || {};
 
         try {
-            if (Env.DATABASE_ENABLE === 1) {
+            // 默认启用，除非显式禁用
+            if (config.enable !== 0) {
                 // 创建 Bun SQL 客户端（内置连接池），并确保连接验证成功后再继续
-                // 从环境变量读取连接超时配置
-                const connectionTimeout = Env.DB_CONNECTION_TIMEOUT ? parseInt(Env.DB_CONNECTION_TIMEOUT) : 30000;
+                // 从配置读取连接超时配置
+                // const connectionTimeout = config.connectionTimeout ? parseInt(config.connectionTimeout) : 30000;
 
-                sql = await Database.connectSql({
-                    connectionTimeout
-                });
+                sql = await Database.connectSql(config);
 
                 // 创建数据库管理器实例，直接传入 sql 对象
                 const dbManager = new DbHelper(befly, sql);

package/plugins/logger.ts

@@ -11,11 +11,13 @@ import type { BeflyContext } from '../types/befly.js';
  * 日志插件
  */
 const loggerPlugin: Plugin = {
-    name: '_logger',
     after: [],
-
-    async onInit(befly: BeflyContext): Promise<typeof Logger> {
+    async onInit(this: Plugin, befly: BeflyContext): Promise<typeof Logger> {
         try {
+            // 配置 Logger
+            if (this.config) {
+                Logger.configure(this.config);
+            }
             return Logger;
         } catch (error: any) {
             // 插件内禁止直接退出进程，抛出异常交由主流程统一处理

package/plugins/redis.ts

@@ -3,7 +3,6 @@
  * 初始化 Redis 连接和助手工具
  */
 
-import { Env } from '../env.js';
 import { Logger } from '../lib/logger.js';
 import { RedisHelper } from '../lib/redisHelper.js';
 import { Database } from '../lib/database.js';
@@ -14,21 +13,18 @@ import type { BeflyContext } from '../types/befly.js';
  * Redis 插件
  */
 const redisPlugin: Plugin = {
-    name: '_redis',
-    after: ['_logger'],
-
-    async onInit(befly: BeflyContext): Promise<RedisHelper | Record<string, never>> {
+    after: ['logger'],
+    async onInit(this: Plugin, befly: BeflyContext): Promise<RedisHelper | Record<string, never>> {
+        const config = this.config || {};
         try {
-            if (Env.DATABASE_ENABLE === 1) {
-                // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
-                await Database.connectRedis();
+            // 默认启用，除非显式禁用 (这里假设只要配置了 redis 插件就启用，或者检查 enable 字段)
+            // 为了兼容性，如果 config 为空，可能意味着使用默认值连接本地 redis
+
+            // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
+            await Database.connectRedis(config);
 
-                // 返回 RedisHelper 实例
-                return new RedisHelper();
-            } else {
-                Logger.warn('Redis 未启用，跳过初始化');
-                return {};
-            }
+            // 返回 RedisHelper 实例
+            return new RedisHelper(config.prefix);
         } catch (error: any) {
             Logger.error('Redis 初始化失败', error);
 

package/router/api.ts

@@ -3,129 +3,83 @@
  * 处理 /api/* 路径的请求
  */
 
-import { Logger } from '../lib/logger.js';
-import { No } from '../util.js';
-import { setCorsOptions, handleOptionsRequest, authenticate, parseGetParams, parsePostParams, checkPermission, validateParams, executePluginHooks, logRequest } from '../lib/middleware.js';
-import { Env } from '../env.js';
-import type { RequestContext } from '../util.js';
+// 相对导入
+import { compose, JsonResponse } from '../util.js';
+
+// 类型导入
+import type { RequestContext } from '../types/context.js';
 import type { ApiRoute } from '../types/api.js';
-import type { Plugin } from '../types/plugin.js';
+import type { Hook } from '../types/hook.js';
 import type { BeflyContext } from '../types/befly.js';
 
 /**
  * API处理器工厂函数
  * @param apiRoutes - API路由映射表
- * @param pluginLists - 插件列表
+ * @param hookLists - 钩子列表
  * @param appContext - 应用上下文
  */
-export function apiHandler(apiRoutes: Map<string, ApiRoute>, pluginLists: Plugin[], appContext: BeflyContext) {
-    return async (req: Request): Promise<Response> => {
-        const corsOptions = setCorsOptions(req);
-        let ctx: RequestContext | null = null;
-        let api: ApiRoute | undefined;
-        let apiPath = '';
-
-        try {
-            // 1. OPTIONS预检请求
-            if (req.method === 'OPTIONS') {
-                return handleOptionsRequest(corsOptions);
-            }
-
-            // 2. 创建请求上下文
-            ctx = {
-                body: {},
-                user: {},
-                request: req,
-                startTime: Date.now()
-            };
+export function apiHandler(apiRoutes: Map<string, ApiRoute>, hookLists: Hook[], appContext: BeflyContext) {
+    // 提取所有钩子的处理函数
+    const middleware = hookLists.map((h) => h.handler);
 
-            // 3. 获取API路由
-            const url = new URL(req.url);
-            apiPath = `${req.method}${url.pathname}`;
-            api = apiRoutes.get(apiPath);
+    // 组合钩子链
+    const fn = compose(middleware);
 
-            if (!api) {
-                return Response.json(No('接口不存在'), {
-                    headers: corsOptions.headers
-                });
-            }
-
-            // 4. 用户认证
-            await authenticate(ctx);
+    return async (req: Request): Promise<Response> => {
+        // 1. 创建请求上下文
+        const url = new URL(req.url);
+        const apiPath = `${req.method}${url.pathname}`;
+
+        const ctx: RequestContext = {
+            body: {},
+            user: {},
+            req: req,
+            now: Date.now(),
+            corsHeaders: {},
+            ip: req.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || req.headers.get('x-real-ip') || 'unknown',
+            route: apiPath
+        };
+
+        // 2. 获取API路由
+        const api = apiRoutes.get(apiPath);
+
+        // 注意：即使 api 不存在，也需要执行插件链（以便处理 CORS OPTIONS 请求或 404 响应）
+        // 如果是 OPTIONS 请求，通常不需要 api 对象
+        if (api) {
+            ctx.api = api;
+        }
 
-            // 5. 参数解析
-            if (req.method === 'GET') {
-                parseGetParams(api, ctx);
-            } else if (req.method === 'POST') {
-                const parseSuccess = await parsePostParams(api, ctx);
-                if (!parseSuccess) {
-                    return Response.json(No('无效的请求参数格式'), {
-                        headers: corsOptions.headers
-                    });
+        // 3. 执行插件链（洋葱模型）
+        // 错误处理已由 errorHandler 插件接管
+        await fn(appContext, ctx, async () => {
+            // 核心执行器：执行 API handler
+            // 如果没有找到 API 且没有被前面的插件拦截（如 CORS），则返回 404
+            if (!ctx.api) {
+                // 只有非 OPTIONS 请求才报 404（OPTIONS 请求通常由 cors 插件处理并返回）
+                if (req.method !== 'OPTIONS') {
+                    ctx.response = JsonResponse(ctx, '接口不存在');
                 }
+                return;
             }
 
-            // 6. 执行插件钩子
-            await executePluginHooks(pluginLists, appContext, ctx);
+            if (ctx.api.handler) {
+                const result = await ctx.api.handler(appContext, ctx, req);
 
-            // 7. 记录请求日志
-            logRequest(apiPath, ctx);
-
-            // 8. 权限验证（使用 Redis Set SISMEMBER 直接判断，提升性能）
-            let hasPermission = false;
-            if (api.auth === true && ctx.user?.roleCode && ctx.user.roleCode !== 'dev') {
-                // 使用 Redis SISMEMBER 直接判断接口是否在角色权限集合中（O(1)复杂度）
-                const roleApisKey = `role:apis:${ctx.user.roleCode}`;
-                const isMember = await appContext.redis.sismember(roleApisKey, apiPath);
-                hasPermission = isMember === 1;
-            }
-
-            const permissionResult = checkPermission(api, ctx, hasPermission);
-            if (permissionResult.code !== 0) {
-                return Response.json(permissionResult, {
-                    headers: corsOptions.headers
-                });
-            }
-
-            // 9. 参数验证
-            const validateResult = validateParams(api, ctx);
-            if (validateResult.code !== 0) {
-                return Response.json(No('无效的请求参数格式', validateResult.fields), {
-                    headers: corsOptions.headers
-                });
-            }
-
-            // 10. 执行API处理器
-            const result = await api.handler(appContext, ctx, req);
-
-            // 11. 返回响应
-            // 🔥 新增：直接返回 Response 对象
-            if (result instanceof Response) {
-                return result;
-            }
-
-            // 12. 返回响应
-            if (result && typeof result === 'object' && 'code' in result) {
-                // 处理 BigInt 序列化问题
-                const jsonString = JSON.stringify(result, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
-                return new Response(jsonString, {
-                    headers: {
-                        ...corsOptions.headers,
-                        'Content-Type': 'application/json'
-                    }
-                });
-            } else {
-                return new Response(result, {
-                    headers: corsOptions.headers
-                });
+                if (result instanceof Response) {
+                    ctx.response = result;
+                } else {
+                    // 将结果存入 ctx.result，由 responseFormatter 插件统一处理
+                    ctx.result = result;
+                }
             }
-        } catch (error: any) {
-            // 记录详细的错误日志
-            Logger.error(api ? `接口 [${api.name}] 执行失败` : '处理接口请求时发生错误', error);
+        });
 
-            return Response.json(No('内部服务器错误'), {
-                headers: corsOptions.headers
-            });
+        // 4. 返回响应
+        if (ctx.response) {
+            return ctx.response;
         }
+
+        // 兜底响应（理论上不应执行到这里，responseFormatter 会处理）
+        return JsonResponse(ctx, 'No response generated');
     };
 }

package/router/root.ts

@@ -3,29 +3,29 @@
  * 处理 / 路径的请求
  */
 
-import { Env } from '../env.js';
-import { setCorsOptions } from '../lib/middleware.js';
+// 相对导入
 import { Logger } from '../lib/logger.js';
-import { No } from '../util.js';
+import { setCorsOptions } from '../util.js';
 
 /**
  * 根路径处理器
  */
 export async function rootHandler(req: Request): Promise<Response> {
-    const corsOptions = setCorsOptions(req);
+    // 设置 CORS 响应头
+    const corsHeaders = setCorsOptions(req);
 
     try {
         return Response.json(
             {
                 code: 0,
-                msg: `${Env.APP_NAME} 接口服务已启动`,
+                msg: `Befly 接口服务已启动`,
                 data: {
-                    mode: Env.NODE_ENV,
+                    mode: process.env.NODE_ENV || 'development',
                     timestamp: Date.now()
                 }
             },
             {
-                headers: corsOptions.headers
+                headers: corsHeaders
             }
         );
     } catch (error: any) {
@@ -37,7 +37,7 @@ export async function rootHandler(req: Request): Promise<Response> {
         let errorDetail = {};
 
         // 开发环境返回详细错误信息
-        if (Env.NODE_ENV === 'development') {
+        if (process.env.NODE_ENV === 'development') {
             errorDetail = {
                 type: error.constructor?.name || 'Error',
                 message: error.message,
@@ -45,9 +45,12 @@ export async function rootHandler(req: Request): Promise<Response> {
             };
         }
 
-        return Response.json(No(errorMessage, errorDetail), {
-            status: 500,
-            headers: corsOptions.headers
-        });
+        return Response.json(
+            { code: 1, msg: errorMessage, data: errorDetail },
+            {
+                status: 500,
+                headers: corsHeaders
+            }
+        );
     }
 }

package/router/static.ts

@@ -3,74 +3,70 @@
  * 处理 /* 路径的静态文件请求
  */
 
+// 外部依赖
 import { join } from 'pathe';
+
+// 相对导入
 import { projectDir } from '../paths.js';
-import { No } from '../util.js';
-import { setCorsOptions } from '../lib/middleware.js';
 import { Logger } from '../lib/logger.js';
-import { Env } from '../env.js';
+import { setCorsOptions } from '../util.js';
+
+// 类型导入
+import type { CorsConfig } from '../types/befly.js';
 
 /**
- * 静态文件处理器
+ * 静态文件处理器工厂
+ * @param corsConfig - CORS 配置
  */
-export async function staticHandler(req: Request): Promise<Response> {
-    const corsOptions = setCorsOptions(req);
-    const url = new URL(req.url);
-    const filePath = join(projectDir, 'public', url.pathname);
+export function staticHandler(corsConfig: CorsConfig = {}) {
+    return async (req: Request): Promise<Response> => {
+        // 设置 CORS 响应头
+        const corsHeaders = setCorsOptions(req, corsConfig);
 
-    try {
-        // OPTIONS预检请求
-        if (req.method === 'OPTIONS') {
-            return new Response(null, {
-                status: 204,
-                headers: corsOptions.headers
-            });
-        }
+        const url = new URL(req.url);
+        const filePath = join(projectDir, 'public', url.pathname);
 
-        const file = Bun.file(filePath);
-        if (await file.exists()) {
-            return new Response(file, {
-                headers: {
-                    'Content-Type': file.type || 'application/octet-stream',
-                    ...corsOptions.headers
-                }
-            });
-        } else {
-            return Response.json(No('文件未找到'), {
-                status: 404,
-                headers: corsOptions.headers
-            });
-        }
-    } catch (error: any) {
-        // 记录详细的错误日志
-        Logger.error('静态文件处理失败', error);
+        try {
+            // OPTIONS预检请求
+            if (req.method === 'OPTIONS') {
+                return new Response(null, {
+                    status: 204,
+                    headers: corsHeaders
+                });
+            }
 
-        // 根据错误类型返回不同的错误信息
-        let errorMessage = '文件读取失败';
-        let errorDetail = {};
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+                return new Response(file, {
+                    headers: {
+                        'Content-Type': file.type || 'application/octet-stream',
+                        ...corsHeaders
+                    }
+                });
+            } else {
+                return Response.json(
+                    { code: 1, msg: '文件未找到' },
+                    {
+                        status: 404,
+                        headers: corsHeaders
+                    }
+                );
+            }
+        } catch (error: any) {
+            // 记录详细的错误日志
+            Logger.error('静态文件处理失败', error);
 
-        // 权限错误
-        if (error.message?.includes('EACCES') || error.message?.includes('permission')) {
-            errorMessage = '文件访问权限不足';
-        }
-        // 路径错误
-        else if (error.message?.includes('ENOENT') || error.message?.includes('not found')) {
-            errorMessage = '文件路径不存在';
-        }
+            // 根据错误类型返回不同的错误信息
+            let errorMessage = '文件读取失败';
+            let errorDetail = {};
 
-        // 开发环境返回详细错误信息
-        if (Env.NODE_ENV === 'development') {
-            errorDetail = {
-                type: error.constructor?.name || 'Error',
-                message: error.message,
-                stack: error.stack,
-                filePath: filePath
-            };
+            return Response.json(
+                { code: 1, msg: errorMessage, data: errorDetail },
+                {
+                    status: 500,
+                    headers: corsHeaders
+                }
+            );
         }
-
-        return Response.json(No(errorMessage, errorDetail), {
-            status: 500,
-            headers: corsOptions.headers
-        });
-    }
+    };
 }

package/sync/syncAll.ts

@@ -0,0 +1,58 @@
+/**
+ * Sync 命令 - 一次性执行所有同步操作
+ * 按顺序执行：syncDb → syncApi → syncMenu → syncDev
+ */
+
+import { checkApp } from '../checks/checkApp.js';
+import { Logger } from '../lib/logger.js';
+import { syncDbCommand } from './syncDb.js';
+import { syncApiCommand } from './syncApi.js';
+import { syncMenuCommand } from './syncMenu.js';
+import { syncDevCommand } from './syncDev.js';
+import type { SyncOptions, BeflyOptions } from '../types/index.js';
+
+export async function syncAllCommand(config: BeflyOptions, options: SyncOptions = {}) {
+    try {
+        const startTime = Date.now();
+
+        // 0. 检查项目结构
+        Logger.debug('🔍 正在检查项目结构...');
+        const checkResult = await checkApp();
+        if (!checkResult) {
+            Logger.error('项目结构检查失败，程序退出');
+            throw new Error('项目结构检查失败');
+        }
+        Logger.debug(`✓ 项目结构检查完成\n`);
+
+        Logger.debug('开始执行同步任务...\n');
+
+        // 1. 同步数据库表结构
+        Logger.debug('📦 正在同步数据库...');
+        await syncDbCommand(config, { dryRun: false, force: options.force || false });
+        Logger.debug(`✓ 数据库同步完成\n`);
+
+        // 2. 同步接口（并缓存）
+        Logger.debug('🔌 正在同步接口...');
+        await syncApiCommand(config);
+        Logger.debug(`✓ 接口同步完成\n`);
+
+        // 3. 同步菜单（并缓存）
+        Logger.debug('📋 正在同步菜单...');
+        await syncMenuCommand(config);
+        Logger.debug(`✓ 菜单同步完成\n`);
+
+        // 4. 同步开发管理员（并缓存角色权限）
+        Logger.debug('👤 正在同步开发账号...');
+        await syncDevCommand(config);
+        Logger.debug(`✓ 开发账号同步完成\n`);
+
+        // 输出总结
+        const totalTimeSeconds = ((Date.now() - startTime) / 1000).toFixed(2);
+        Logger.debug('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        Logger.debug(`✅ 同步完成！总耗时: ${totalTimeSeconds} 秒`);
+        Logger.debug('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    } catch (error: any) {
+        Logger.error('同步过程中发生错误', error);
+        throw error;
+    }
+}