befly 3.8.25 → 3.8.27

package/loader/loadPlugins.ts

@@ -12,29 +12,24 @@ import { sortModules, scanModules } from '../util.js';
 import type { Plugin } from '../types/plugin.js';
 import type { BeflyContext } from '../types/befly.js';
 
-export async function loadPlugins(befly: {
-    //
-    pluginLists: Plugin[];
-    appContext: BeflyContext;
-    pluginsConfig?: Record<string, any>;
-}): Promise<void> {
+export async function loadPlugins(config: Record<string, any> | undefined, plugins: Plugin[], context: BeflyContext): Promise<void> {
     try {
         const allPlugins: Plugin[] = [];
 
         // 1. 扫描核心插件
-        const corePlugins = await scanModules<Plugin>(corePluginDir, 'core', '插件', befly.pluginsConfig);
+        const corePlugins = await scanModules<Plugin>(corePluginDir, 'core', '插件', config);
 
         // 2. 扫描组件插件
         const addonPlugins: Plugin[] = [];
         const addons = scanAddons();
         for (const addon of addons) {
             const dir = getAddonDir(addon, 'plugins');
-            const plugins = await scanModules<Plugin>(dir, 'addon', '插件', befly.pluginsConfig, addon);
+            const plugins = await scanModules<Plugin>(dir, 'addon', '插件', config, addon);
             addonPlugins.push(...plugins);
         }
 
         // 3. 扫描项目插件
-        const appPlugins = await scanModules<Plugin>(projectPluginDir, 'app', '插件', befly.pluginsConfig);
+        const appPlugins = await scanModules<Plugin>(projectPluginDir, 'app', '插件', config);
 
         // 4. 合并所有插件
         allPlugins.push(...corePlugins);
@@ -42,7 +37,7 @@ export async function loadPlugins(befly: {
         allPlugins.push(...appPlugins);
 
         // 5. 过滤禁用的插件
-        const disablePlugins = (befly as any).config?.disablePlugins || [];
+        const disablePlugins = (config as any)?.disablePlugins || [];
         const enabledPlugins = allPlugins.filter((plugin) => !disablePlugins.includes(plugin.name));
 
         if (disablePlugins.length > 0) {
@@ -58,13 +53,12 @@ export async function loadPlugins(befly: {
 
         for (const plugin of sortedPlugins) {
             try {
-                befly.pluginLists.push(plugin);
+                plugins.push(plugin);
 
-                if (typeof plugin.handler === 'function') {
-                    befly.appContext[plugin.name!] = await plugin.handler(befly.appContext);
-                } else {
-                    befly.appContext[plugin.name!] = {};
-                }
+                const pluginInstance = typeof plugin.handler === 'function' ? await plugin.handler(context, config) : {};
+
+                // 直接挂载到 befly 下
+                (context as any)[plugin.name!] = pluginInstance;
             } catch (error: any) {
                 Logger.error(`插件 ${plugin.name} 初始化失败`, error);
                 process.exit(1);

package/main.ts

@@ -10,13 +10,12 @@ import { calcPerfTime } from 'befly-util';
 import { Logger } from './lib/logger.js';
 import { Cipher } from './lib/cipher.js';
 import { Jwt } from './lib/jwt.js';
-import { Database } from './lib/database.js';
+import { Connect } from './lib/connect.js';
 import { DbHelper } from './lib/dbHelper.js';
 import { RedisHelper } from './lib/redisHelper.js';
 import { loadPlugins } from './loader/loadPlugins.js';
 import { loadHooks } from './loader/loadHooks.js';
 import { loadApis } from './loader/loadApis.js';
-import { rootHandler } from './router/root.js';
 import { apiHandler } from './router/api.js';
 import { staticHandler } from './router/static.js';
 import { checkApp } from './checks/checkApp.js';
@@ -25,6 +24,7 @@ import { checkApi } from './checks/checkApi.js';
 import { syncAllCommand } from './sync/syncAll.js';
 import { coreDir } from './paths.js';
 import { defaultOptions } from './config.js';
+import { isPrimaryProcess, getProcessRole } from './util.js';
 
 // ========== 类型导入 ==========
 import type { Server } from 'bun';
@@ -38,24 +38,22 @@ import type { ApiRoute } from './types/api.js';
  */
 export class Befly {
     /** API 路由映射表 */
-    private apiRoutes: Map<string, ApiRoute> = new Map();
+    private apis: Map<string, ApiRoute> = new Map();
 
     /** 插件列表 */
-    private pluginLists: Plugin[] = [];
+    private plugins: Plugin[] = [];
 
     /** 钩子列表 */
-    private hookLists: Hook[] = [];
+    private hooks: Hook[] = [];
 
     /** 应用上下文 */
-    public appContext: BeflyContext;
+    public context: BeflyContext = {};
 
     /** 最终配置（合并默认值后） */
-    public config: BeflyOptions;
+    public config: BeflyOptions = { ...defaultOptions };
 
     constructor(options: BeflyOptions = {}) {
-        this.appContext = {};
-        // 合并配置：用户配置 > 默认配置（最多 2 级）
-        this.config = { ...defaultOptions };
+        // 合并用户配置：用户配置 > 默认配置（最多 2 级）
         for (const key in options) {
             const value = options[key as keyof BeflyOptions];
             if (value !== undefined && value !== null) {
@@ -82,32 +80,27 @@ export class Befly {
             await checkApi();
 
             // 4. 加载插件
-            await loadPlugins({
-                pluginLists: this.pluginLists,
-                appContext: this.appContext,
-                pluginsConfig: this.config as any
-            });
+            await loadPlugins(this.config as any, this.plugins, this.context);
 
             // 5. 加载钩子
-            await loadHooks({
-                hookLists: this.hookLists,
-                pluginsConfig: this.config as any
-            });
+            await loadHooks(this.config as any, this.hooks);
 
             // 6. 加载所有 API
-            await loadApis(this.apiRoutes);
+            await loadApis(this.apis);
 
-            // 7. 自动同步 (默认开启)
-            await syncAllCommand(this.config);
+            // 7. 自动同步 (仅主进程执行，避免集群模式下重复执行)
+            if (isPrimaryProcess()) {
+                await syncAllCommand(this.config);
+            }
 
             // 8. 启动 HTTP 服务器
             const server = Bun.serve({
                 port: this.config.appPort,
                 hostname: this.config.appHost,
                 routes: {
-                    '/': rootHandler,
-                    '/api/*': apiHandler(this.apiRoutes, this.hookLists, this.appContext),
-                    '/*': staticHandler(this.config.cors)
+                    '/': () => Response.json({ code: 0, msg: `${this.config.appName} 接口服务已启动` }),
+                    '/api/*': apiHandler(this.apis, this.hooks, this.context),
+                    '/*': staticHandler(this.config)
                 },
                 error: (error: Error) => {
                     Logger.error('服务启动时发生错误', error);
@@ -116,7 +109,11 @@ export class Befly {
             });
 
             const finalStartupTime = calcPerfTime(serverStartTime);
-            Logger.info(`${this.config.appName} 启动成功! `);
+            const processRole = getProcessRole();
+            const roleLabel = processRole.role === 'primary' ? '主进程' : `工作进程 #${processRole.instanceId}`;
+            const envLabel = processRole.env === 'standalone' ? '' : ` [${processRole.env}]`;
+
+            Logger.info(`${this.config.appName} 启动成功! (${roleLabel}${envLabel})`);
             Logger.info(`服务器启动耗时: ${finalStartupTime}`);
             Logger.info(`服务器监听地址: http://${this.config.appHost}:${this.config.appPort}`);
 
@@ -128,7 +125,7 @@ export class Befly {
 
                 // 关闭数据库连接
                 try {
-                    await Database.disconnect();
+                    await Connect.disconnect();
                     Logger.info('数据库连接已关闭');
                 } catch (error: any) {
                     Logger.error('关闭数据库连接时出错:', error);
@@ -143,7 +140,7 @@ export class Befly {
 
             return server;
         } catch (error: any) {
-            Logger.error('Befly 启动失败', error);
+            Logger.error('项目启动失败', error);
             process.exit(1);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.25",
+    "version": "3.8.27",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -66,12 +66,12 @@
         "bun": ">=1.3.0"
     },
     "dependencies": {
-        "befly-util": "^1.0.4",
+        "befly-util": "^1.0.6",
         "chalk": "^5.6.2",
         "es-toolkit": "^1.41.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "998b9fd60b5f183796eaac89a47c2d5374aa308a",
+    "gitHead": "54c0f11f65a56f7df036fdf386b72329496777b4",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/plugins/cache.ts

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

package/plugins/cipher.ts

@@ -0,0 +1,15 @@
+/**
+ * Cipher 插件
+ * 提供加密解密功能
+ */
+
+import { Cipher } from '../lib/cipher.js';
+
+import type { Plugin } from '../types/plugin.js';
+
+export default {
+    name: 'cipher',
+    handler: (context, config) => {
+        return Cipher;
+    }
+} as Plugin;

package/plugins/config.ts

@@ -0,0 +1,16 @@
+/**
+ * 配置插件
+ * 提供访问项目配置的能力
+ */
+
+// 类型导入
+import type { Plugin } from '../types/plugin.js';
+
+const plugin: Plugin = {
+    handler: (context, config) => {
+        // 直接返回第二个参数中的配置
+        return config || {};
+    }
+};
+
+export default plugin;

package/plugins/db.ts

@@ -4,7 +4,7 @@
  */
 
 import { Logger } from '../lib/logger.js';
-import { Database } from '../lib/database.js';
+import { Connect } from '../lib/connect.js';
 import { DbHelper } from '../lib/dbHelper.js';
 import type { Plugin } from '../types/plugin.js';
 import type { BeflyContext } from '../types/befly.js';
@@ -13,28 +13,18 @@ import type { BeflyContext } from '../types/befly.js';
  * 数据库插件
  */
 const dbPlugin: Plugin = {
-    after: ['redis'],
-    async onInit(this: Plugin, befly: BeflyContext): Promise<DbHelper | Record<string, never>> {
+    after: ['logger'],
+    async handler(this: Plugin, befly: BeflyContext): Promise<DbHelper> {
         let sql: any = null;
         const config = this.config || {};
 
         try {
-            // 默认启用，除非显式禁用
-            if (config.enable !== 0) {
-                // 创建 Bun SQL 客户端（内置连接池），并确保连接验证成功后再继续
-                // 从配置读取连接超时配置
-                // const connectionTimeout = config.connectionTimeout ? parseInt(config.connectionTimeout) : 30000;
+            sql = await Connect.connectSql(config);
 
-                sql = await Database.connectSql(config);
+            // 创建数据库管理器实例，直接传入 sql 对象
+            const dbManager = new DbHelper(befly, sql);
 
-                // 创建数据库管理器实例，直接传入 sql 对象
-                const dbManager = new DbHelper(befly, sql);
-
-                return dbManager;
-            } else {
-                Logger.warn('数据库未启用，跳过初始化');
-                return {};
-            }
+            return dbManager;
         } catch (error: any) {
             Logger.error('数据库初始化失败', error);
 

package/plugins/jwt.ts

@@ -0,0 +1,15 @@
+/**
+ * JWT 插件
+ * 提供 JSON Web Token 签名和验证功能
+ */
+
+import { Jwt } from '../lib/jwt.js';
+
+import type { Plugin } from '../types/plugin.js';
+
+export default {
+    name: 'jwt',
+    handler: (context, config) => {
+        return Jwt;
+    }
+} as Plugin;

package/plugins/logger.ts

@@ -12,7 +12,7 @@ import type { BeflyContext } from '../types/befly.js';
  */
 const loggerPlugin: Plugin = {
     after: [],
-    async onInit(this: Plugin, befly: BeflyContext): Promise<typeof Logger> {
+    async handler(this: Plugin, befly: BeflyContext): Promise<typeof Logger> {
         try {
             // 配置 Logger
             if (this.config) {

package/plugins/redis.ts

@@ -4,8 +4,8 @@
  */
 
 import { Logger } from '../lib/logger.js';
+import { Connect } from '../lib/connect.js';
 import { RedisHelper } from '../lib/redisHelper.js';
-import { Database } from '../lib/database.js';
 import type { Plugin } from '../types/plugin.js';
 import type { BeflyContext } from '../types/befly.js';
 
@@ -14,14 +14,14 @@ import type { BeflyContext } from '../types/befly.js';
  */
 const redisPlugin: Plugin = {
     after: ['logger'],
-    async onInit(this: Plugin, befly: BeflyContext): Promise<RedisHelper | Record<string, never>> {
+    async handler(this: Plugin, befly: BeflyContext): Promise<RedisHelper | Record<string, never>> {
         const config = this.config || {};
         try {
             // 默认启用，除非显式禁用 (这里假设只要配置了 redis 插件就启用，或者检查 enable 字段)
             // 为了兼容性，如果 config 为空，可能意味着使用默认值连接本地 redis
 
-            // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
-            await Database.connectRedis(config);
+            // 初始化 Redis 客户端（统一使用 connect.ts 的连接管理）
+            await Connect.connectRedis(config);
 
             // 返回 RedisHelper 实例
             return new RedisHelper(config.prefix);

package/plugins/tool.ts

@@ -0,0 +1,50 @@
+/**
+ * 工具插件
+ * 提供常用的工具函数
+ */
+
+// 类型导入
+import type { Plugin } from '../types/plugin.js';
+
+/**
+ * 成功响应
+ * @param msg - 消息
+ * @param data - 数据（可选）
+ * @param other - 其他字段（可选）
+ * @returns 成功响应对象
+ */
+export function Yes(msg: string, data: any = {}, other: Record<string, any> = {}) {
+    return {
+        code: 0,
+        msg: msg,
+        data: data,
+        ...other
+    };
+}
+
+/**
+ * 失败响应
+ * @param msg - 消息
+ * @param data - 数据（可选）
+ * @param other - 其他字段（可选）
+ * @returns 失败响应对象
+ */
+export function No(msg: string, data: any = null, other: Record<string, any> = {}) {
+    return {
+        code: 1,
+        msg: msg,
+        data: data,
+        ...other
+    };
+}
+
+const plugin: Plugin = {
+    handler: () => {
+        return {
+            Yes: Yes,
+            No: No
+        };
+    }
+};
+
+export default plugin;

package/router/api.ts

@@ -3,8 +3,12 @@
  * 处理 /api/* 路径的请求
  */
 
+// 外部依赖
+import { genShortId } from 'befly-util';
+
 // 相对导入
-import { compose, JsonResponse } from '../util.js';
+import { FinalResponse } from '../util.js';
+import { Logger } from '../lib/logger.js';
 
 // 类型导入
 import type { RequestContext } from '../types/context.js';
@@ -14,72 +18,82 @@ import type { BeflyContext } from '../types/befly.js';
 
 /**
  * API处理器工厂函数
- * @param apiRoutes - API路由映射表
- * @param hookLists - 钩子列表
- * @param appContext - 应用上下文
+ * @param apis - API路由映射表
+ * @param hooks - 钩子列表
+ * @param context - 应用上下文
  */
-export function apiHandler(apiRoutes: Map<string, ApiRoute>, hookLists: Hook[], appContext: BeflyContext) {
-    // 提取所有钩子的处理函数
-    const middleware = hookLists.map((h) => h.handler);
-
-    // 组合钩子链
-    const fn = compose(middleware);
-
+export function apiHandler(apis: Map<string, ApiRoute>, hooks: Hook[], context: BeflyContext) {
     return async (req: Request): Promise<Response> => {
-        // 1. 创建请求上下文
+        // 1. 生成请求 ID
+        const requestId = genShortId();
+
+        // 2. 创建请求上下文
         const url = new URL(req.url);
         const apiPath = `${req.method}${url.pathname}`;
+        const clientIp = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || req.headers.get('x-real-ip') || 'unknown';
 
         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
+            ip: clientIp,
+            headers: req.headers,
+            route: apiPath,
+            requestId: requestId,
+            corsHeaders: {
+                'X-Request-ID': requestId
+            },
+            api: apis.get(apiPath),
+            response: undefined,
+            result: undefined
         };
 
-        // 2. 获取API路由
-        const api = apiRoutes.get(apiPath);
+        try {
+            // 4. 串联执行所有钩子
+            for (const hook of hooks) {
+                await hook.handler(context, ctx);
 
-        // 注意：即使 api 不存在，也需要执行插件链（以便处理 CORS OPTIONS 请求或 404 响应）
-        // 如果是 OPTIONS 请求，通常不需要 api 对象
-        if (api) {
-            ctx.api = api;
-        }
+                // 如果钩子已经设置了 response，停止执行
+                if (ctx.response) {
+                    return ctx.response;
+                }
+            }
 
-        // 3. 执行插件链（洋葱模型）
-        // 错误处理已由 errorHandler 插件接管
-        await fn(appContext, ctx, async () => {
-            // 核心执行器：执行 API handler
-            // 如果没有找到 API 且没有被前面的插件拦截（如 CORS），则返回 404
+            // 5. 执行 API handler
             if (!ctx.api) {
-                // 只有非 OPTIONS 请求才报 404（OPTIONS 请求通常由 cors 插件处理并返回）
                 if (req.method !== 'OPTIONS') {
-                    ctx.response = JsonResponse(ctx, '接口不存在');
+                    ctx.response = Response.json(
+                        {
+                            code: 1,
+                            msg: '接口不存在'
+                        },
+                        {
+                            headers: ctx.corsHeaders
+                        }
+                    );
                 }
-                return;
-            }
-
-            if (ctx.api.handler) {
-                const result = await ctx.api.handler(appContext, ctx, req);
+            } else if (ctx.api.handler) {
+                const result = await ctx.api.handler(context, ctx);
 
                 if (result instanceof Response) {
                     ctx.response = result;
                 } else {
-                    // 将结果存入 ctx.result，由 responseFormatter 插件统一处理
                     ctx.result = result;
                 }
             }
-        });
 
-        // 4. 返回响应
-        if (ctx.response) {
-            return ctx.response;
+            // 6. 返回响应（自动处理 response/result/日志）
+            return FinalResponse(ctx);
+        } catch (err: any) {
+            // 全局错误处理
+            const errorPath = ctx.api ? apiPath : req.url;
+            Logger.error(`请求错误: ${errorPath}`, err);
+            ctx.result = {
+                code: 1,
+                msg: '内部服务错误'
+            };
+            return FinalResponse(ctx);
         }
-
-        // 兜底响应（理论上不应执行到这里，responseFormatter 会处理）
-        return JsonResponse(ctx, 'No response generated');
     };
 }

package/router/static.ts

@@ -12,16 +12,16 @@ import { Logger } from '../lib/logger.js';
 import { setCorsOptions } from '../util.js';
 
 // 类型导入
-import type { CorsConfig } from '../types/befly.js';
+import type { BeflyOptions } from '../types/befly.js';
 
 /**
  * 静态文件处理器工厂
- * @param corsConfig - CORS 配置
+ * @param config - Befly 配置
  */
-export function staticHandler(corsConfig: CorsConfig = {}) {
+export function staticHandler(config: BeflyOptions) {
     return async (req: Request): Promise<Response> => {
         // 设置 CORS 响应头
-        const corsHeaders = setCorsOptions(req, corsConfig);
+        const corsHeaders = setCorsOptions(req, config.cors);
 
         const url = new URL(req.url);
         const filePath = join(projectDir, 'public', url.pathname);
@@ -45,9 +45,11 @@ export function staticHandler(corsConfig: CorsConfig = {}) {
                 });
             } else {
                 return Response.json(
-                    { code: 1, msg: '文件未找到' },
                     {
-                        status: 404,
+                        code: 1,
+                        msg: '文件未找到'
+                    },
+                    {
                         headers: corsHeaders
                     }
                 );
@@ -56,14 +58,12 @@ export function staticHandler(corsConfig: CorsConfig = {}) {
             // 记录详细的错误日志
             Logger.error('静态文件处理失败', error);
 
-            // 根据错误类型返回不同的错误信息
-            let errorMessage = '文件读取失败';
-            let errorDetail = {};
-
             return Response.json(
-                { code: 1, msg: errorMessage, data: errorDetail },
                 {
-                    status: 500,
+                    code: 1,
+                    msg: '文件读取失败'
+                },
+                {
                     headers: corsHeaders
                 }
             );

package/sync/syncAll.ts

@@ -16,41 +16,23 @@ export async function syncAllCommand(config: BeflyOptions, options: SyncOptions
         const startTime = Date.now();
 
         // 0. 检查项目结构
-        Logger.debug('🔍 正在检查项目结构...');
-        const checkResult = await checkApp();
-        if (!checkResult) {
-            Logger.error('项目结构检查失败，程序退出');
-            throw new Error('项目结构检查失败');
-        }
-        Logger.debug(`✓ 项目结构检查完成\n`);
-
-        Logger.debug('开始执行同步任务...\n');
+        await checkApp();
 
         // 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');
+        Logger.info(`同步完成 (耗时 ${totalTimeSeconds}s)`);
     } catch (error: any) {
         Logger.error('同步过程中发生错误', error);
         throw error;