befly 3.8.25 → 3.8.27

package/config.ts

@@ -6,14 +6,14 @@ import type { BeflyOptions } from './types/befly.js';
 
 export const defaultOptions: Required<Omit<BeflyOptions, 'devPassword'>> = {
     // ========== 核心参数 ==========
-    nodeEnv: 'development',
-    appName: 'Befly App',
+    nodeEnv: (process.env.NODE_ENV as any) || 'development',
+    appName: '野蜂飞舞',
     appPort: 3000,
     appHost: '127.0.0.1',
     devEmail: 'dev@qq.com',
+    devPassword: 'beflydev123456',
     bodyLimit: 1048576, // 1MB
     tz: 'Asia/Shanghai',
-    dbCache: 0,
 
     // ========== 日志配置 ==========
     logger: {
@@ -26,14 +26,13 @@ export const defaultOptions: Required<Omit<BeflyOptions, 'devPassword'>> = {
 
     // ========== 数据库配置 ==========
     db: {
-        enable: 0,
-        type: 'sqlite',
+        type: 'mysql',
         host: '127.0.0.1',
         port: 3306,
         username: 'root',
-        password: '',
-        database: 'befly',
-        poolMax: 1
+        password: 'root',
+        database: 'befly_demo',
+        poolMax: 10
     },
 
     // ========== Redis 配置 ==========
@@ -43,7 +42,7 @@ export const defaultOptions: Required<Omit<BeflyOptions, 'devPassword'>> = {
         username: '',
         password: '',
         db: 0,
-        prefix: 'befly:'
+        prefix: 'befly_demo:'
     },
 
     // ========== 认证配置 ==========

package/hooks/{rateLimit.ts → _rateLimit.ts}

@@ -1,6 +1,6 @@
 // 相对导入
 import { Logger } from '../lib/logger.js';
-import { JsonResponse } from '../util.js';
+import { ErrorResponse } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
@@ -14,16 +14,13 @@ import type { Hook } from '../types/hook.js';
  * 3. 针对每个用户(userId)或IP进行限制
  */
 const hook: Hook = {
-    // 必须在 auth 之后（获取 userId），但在业务逻辑之前
-    after: ['parser'],
-    order: 25,
-
-    handler: async (befly, ctx, next) => {
+    order: 7,
+    handler: async (befly, ctx) => {
         const { api } = ctx;
 
         // 1. 检查配置
         if (!api || !api.rateLimit || !befly.redis) {
-            return next();
+            return;
         }
 
         // 2. 解析配置 "10/60" -> count=10, seconds=60
@@ -33,12 +30,12 @@ const hook: Hook = {
 
         if (isNaN(limitCount) || isNaN(limitSeconds)) {
             Logger.warn(`[RateLimit] Invalid config: ${api.rateLimit}`);
-            return next();
+            return;
         }
 
         // 3. 生成 Key
         // 优先使用 userId，否则使用 IP
-        const identifier = ctx.user?.userId || ctx.ip || 'unknown';
+        const identifier = ctx.user?.id || ctx.ip || 'unknown';
         const apiPath = ctx.route || `${ctx.req.method}${new URL(ctx.req.url).pathname}`;
         const key = `rate_limit:${apiPath}:${identifier}`;
 
@@ -54,15 +51,12 @@ const hook: Hook = {
 
             // 6. 判断是否超限
             if (current > limitCount) {
-                ctx.response = JsonResponse(ctx, '请求过于频繁，请稍后再试', 429);
+                ctx.response = ErrorResponse(ctx, '请求过于频繁，请稍后再试');
                 return;
             }
-
-            return next();
         } catch (err) {
             Logger.error('[RateLimit] Redis error:', err);
             // Redis 故障时，默认放行，避免阻塞业务
-            return next();
         }
     }
 };

package/hooks/auth.ts

@@ -1,22 +1,15 @@
 import type { Hook } from '../types/hook.js';
-import { Jwt } from '../lib/jwt.js';
 
 const hook: Hook = {
-    after: ['cors'],
-    order: 5,
-    handler: async (befly, ctx, next) => {
-        // 初始化配置（如果有）
-        // 注意：Hook 没有 onInit，如果需要初始化，可以在 handler 首次执行时做，或者保留 Plugin 机制专门做初始化
-        // 这里 auth 插件原本有 onInit 来配置 Jwt，现在需要迁移
-        // 临时方案：直接在 handler 里判断是否配置过，或者让 Jwt 自身处理配置
-
+    order: 3,
+    handler: async (befly, ctx) => {
         const authHeader = ctx.req.headers.get('authorization');
 
         if (authHeader && authHeader.startsWith('Bearer ')) {
             const token = authHeader.substring(7);
 
             try {
-                const payload = await Jwt.verify(token);
+                const payload = await befly.jwt.verify(token);
                 ctx.user = payload;
             } catch (error: any) {
                 ctx.user = {};
@@ -24,7 +17,6 @@ const hook: Hook = {
         } else {
             ctx.user = {};
         }
-        await next();
     }
 };
 export default hook;

package/hooks/cors.ts

@@ -10,9 +10,8 @@ import type { CorsConfig } from '../types/befly.js';
  * 设置跨域响应头并处理 OPTIONS 预检请求
  */
 const hook: Hook = {
-    after: ['errorHandler'],
     order: 2,
-    handler: async (befly, ctx, next) => {
+    handler: async (befly, ctx) => {
         const req = ctx.req;
 
         // 合并默认配置和用户配置
@@ -41,8 +40,6 @@ const hook: Hook = {
             });
             return;
         }
-
-        await next();
     }
 };
 export default hook;

package/hooks/parser.ts

@@ -4,7 +4,7 @@ import { pickFields } from 'befly-util';
 
 // 相对导入
 import { Xml } from '../lib/xml.js';
-import { JsonResponse } from '../util.js';
+import { ErrorResponse } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
@@ -16,10 +16,9 @@ import type { Hook } from '../types/hook.js';
  * - 根据 API 定义的 fields 过滤字段
  */
 const hook: Hook = {
-    after: ['auth'],
-    order: 10,
-    handler: async (befly, ctx, next) => {
-        if (!ctx.api) return next();
+    order: 4,
+    handler: async (befly, ctx) => {
+        if (!ctx.api) return;
 
         // GET 请求：解析查询参数
         if (ctx.req.method === 'GET') {
@@ -52,16 +51,15 @@ const hook: Hook = {
                     }
                 } else {
                     // 不支持的 Content-Type
-                    ctx.response = JsonResponse(ctx, '无效的请求参数格式');
+                    ctx.response = ErrorResponse(ctx, '无效的请求参数格式');
                     return;
                 }
             } catch (e) {
                 // 解析失败
-                ctx.response = JsonResponse(ctx, '无效的请求参数格式');
+                ctx.response = ErrorResponse(ctx, '无效的请求参数格式');
                 return;
             }
         }
-        await next();
     }
 };
 export default hook;

package/hooks/permission.ts

@@ -1,5 +1,5 @@
 // 相对导入
-import { JsonResponse } from '../util.js';
+import { ErrorResponse } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
@@ -12,25 +12,24 @@ import type { Hook } from '../types/hook.js';
  * - 其他角色：检查 Redis 中的角色权限集合
  */
 const hook: Hook = {
-    after: ['parser'],
-    order: 20,
-    handler: async (befly, ctx, next) => {
-        if (!ctx.api) return next();
+    order: 6,
+    handler: async (befly, ctx) => {
+        if (!ctx.api) return;
 
         // 1. 接口无需权限
         if (ctx.api.auth === false) {
-            return next();
+            return;
         }
 
         // 2. 用户未登录
-        if (!ctx.user || !ctx.user.userId) {
-            ctx.response = JsonResponse(ctx, '未登录', 401);
+        if (!ctx.user || !ctx.user.id) {
+            ctx.response = ErrorResponse(ctx, '未登录');
             return;
         }
 
         // 3. 开发者权限（最高权限）
         if (ctx.user.roleCode === 'dev') {
-            return next();
+            return;
         }
 
         // 4. 角色权限检查
@@ -44,11 +43,9 @@ const hook: Hook = {
         }
 
         if (!hasPermission) {
-            ctx.response = JsonResponse(ctx, '无权访问', 403);
+            ctx.response = ErrorResponse(ctx, '无权访问');
             return;
         }
-
-        await next();
     }
 };
 export default hook;

package/hooks/validator.ts

@@ -1,6 +1,6 @@
 // 相对导入
 import { Validator } from '../lib/validator.js';
-import { JsonResponse } from '../util.js';
+import { ErrorResponse } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
@@ -10,25 +10,22 @@ import type { Hook } from '../types/hook.js';
  * 根据 API 定义的 fields 和 required 验证请求参数
  */
 const hook: Hook = {
-    after: ['parser'],
-    order: 15,
-    handler: async (befly, ctx, next) => {
-        if (!ctx.api) return next();
+    order: 5,
+    handler: async (befly, ctx) => {
+        if (!ctx.api) return;
 
         // 无需验证
         if (!ctx.api.fields) {
-            return next();
+            return;
         }
 
         // 验证参数
         const result = Validator.validate(ctx.body, ctx.api.fields, ctx.api.required || []);
 
         if (result.code !== 0) {
-            ctx.response = JsonResponse(ctx, '无效的请求参数格式', 1, result.fields);
+            ctx.response = ErrorResponse(ctx, '无效的请求参数格式', 1, result.fields);
             return;
         }
-
-        await next();
     }
 };
 export default hook;

package/lib/cacheHelper.ts

@@ -153,8 +153,6 @@ export class CacheHelper {
      * 缓存所有数据
      */
     async cacheAll(): Promise<void> {
-        Logger.info('========== 开始缓存数据到 Redis ==========');
-
         // 1. 缓存接口
         await this.cacheApis();
 
@@ -163,8 +161,6 @@ export class CacheHelper {
 
         // 3. 缓存角色权限
         await this.cacheRolePermissions();
-
-        Logger.info('========== 数据缓存完成 ==========\n');
     }
 
     /**

package/lib/{database.ts → connect.ts}

@@ -7,18 +7,23 @@ import { SQL, RedisClient } from 'bun';
 import { Logger } from './logger.js';
 import { DbHelper } from './dbHelper.js';
 import { RedisHelper } from './redisHelper.js';
-import type { BeflyContext, DatabaseConfig, RedisConfig } from '../types/befly.js';
+import type { BeflyContext, BeflyOptions, DatabaseConfig, RedisConfig } from '../types/befly.js';
 import type { SqlClientOptions } from '../types/database.js';
 
 /**
  * 数据库连接管理器
  * 使用静态方法管理全局单例连接
  */
-export class Database {
+export class Connect {
     private static sqlClient: SQL | null = null;
     private static redisClient: RedisClient | null = null;
     private static dbHelper: DbHelper | null = null;
 
+    // 连接统计信息
+    private static sqlConnectedAt: number | null = null;
+    private static redisConnectedAt: number | null = null;
+    private static sqlPoolMax: number = 1;
+
     // ========================================
     // SQL 连接管理
     // ========================================
@@ -86,11 +91,11 @@ export class Database {
             const version = await Promise.race([healthCheckPromise, timeoutPromise]);
 
             this.sqlClient = sql;
+            this.sqlConnectedAt = Date.now();
+            this.sqlPoolMax = config.poolMax ?? 1;
             return sql;
         } catch (error: any) {
-            console.log(finalUrl);
-            Logger.error('数据库连接测试失败', error);
-
+            Logger.error('[Connect] SQL 连接失败', error);
             try {
                 await sql?.close();
             } catch (cleanupError) {}
@@ -107,9 +112,10 @@ export class Database {
             try {
                 await this.sqlClient.close();
             } catch (error: any) {
-                Logger.error('关闭 SQL 连接时出错', error);
+                Logger.error('[Connect] 关闭 SQL 连接时出错', error);
             }
             this.sqlClient = null;
+            this.sqlConnectedAt = null;
         }
 
         if (this.dbHelper) {
@@ -123,7 +129,7 @@ export class Database {
      */
     static getSql(): SQL {
         if (!this.sqlClient) {
-            throw new Error('SQL 客户端未连接，请先调用 Database.connectSql()');
+            throw new Error('SQL 客户端未连接，请先调用 Connect.connectSql()');
         }
         return this.sqlClient;
     }
@@ -135,7 +141,7 @@ export class Database {
     static getDbHelper(befly?: BeflyContext): DbHelper {
         if (!this.dbHelper) {
             if (!this.sqlClient) {
-                throw new Error('SQL 客户端未连接，请先调用 Database.connectSql()');
+                throw new Error('SQL 客户端未连接，请先调用 Connect.connectSql()');
             }
             // 创建临时 befly 上下文（仅用于 DbHelper）
             const ctx = befly || {
@@ -188,9 +194,10 @@ export class Database {
             await redis.ping();
 
             this.redisClient = redis;
+            this.redisConnectedAt = Date.now();
             return redis;
         } catch (error: any) {
-            Logger.error('Redis 连接失败', error);
+            Logger.error('[Connect] Redis 连接失败', error);
             throw new Error(`Redis 连接失败: ${error.message}`);
         }
     }
@@ -202,8 +209,9 @@ export class Database {
         if (this.redisClient) {
             try {
                 this.redisClient.close();
+                this.redisConnectedAt = null;
             } catch (error: any) {
-                Logger.error('关闭 Redis 连接时出错', error);
+                Logger.error('[Connect] 关闭 Redis 连接时出错', error);
             }
             this.redisClient = null;
         }
@@ -215,7 +223,7 @@ export class Database {
      */
     static getRedis(): RedisClient {
         if (!this.redisClient) {
-            throw new Error('Redis 客户端未连接，请先调用 Database.connectRedis()');
+            throw new Error('Redis 客户端未连接，请先调用 Connect.connectRedis()');
         }
         return this.redisClient;
     }
@@ -226,17 +234,21 @@ export class Database {
 
     /**
      * 连接所有数据库（SQL + Redis）
-     * @param options - 配置选项
+     * @param config - Befly 配置对象（可选）
+     * @param options - 连接选项
      */
-    static async connect(options?: { sql?: SqlClientOptions; redis?: boolean }): Promise<void> {
+    static async connect(config?: BeflyOptions, options?: { sql?: SqlClientOptions; redis?: boolean }): Promise<void> {
         try {
-            if (options?.sql !== false) {
-                await this.connectSql(options?.sql);
+            // 如果 sql 参数不是 false，则连接 SQL
+            // 优先级：options.sql > config.db > 跳过
+            const sqlConfig = options?.db || {};
+            if (sqlConfig) {
+                await this.connectSql(sqlConfig);
             }
 
-            if (options?.redis !== false) {
-                await this.connectRedis();
-            }
+            // 如果 redis 参数不是 false，则连接 Redis
+            const redisConfig = config?.redis || {};
+            await this.connectRedis(redisConfig);
         } catch (error: any) {
             Logger.error('数据库初始化失败', error);
             await this.disconnect();
@@ -262,6 +274,38 @@ export class Database {
         };
     }
 
+    /**
+     * 获取连接状态详细信息（用于监控和调试）
+     */
+    static getStatus(): {
+        sql: {
+            connected: boolean;
+            connectedAt: number | null;
+            uptime: number | null;
+            poolMax: number;
+        };
+        redis: {
+            connected: boolean;
+            connectedAt: number | null;
+            uptime: number | null;
+        };
+    } {
+        const now = Date.now();
+        return {
+            sql: {
+                connected: this.sqlClient !== null,
+                connectedAt: this.sqlConnectedAt,
+                uptime: this.sqlConnectedAt ? now - this.sqlConnectedAt : null,
+                poolMax: this.sqlPoolMax
+            },
+            redis: {
+                connected: this.redisClient !== null,
+                connectedAt: this.redisConnectedAt,
+                uptime: this.redisConnectedAt ? now - this.redisConnectedAt : null
+            }
+        };
+    }
+
     // ========================================
     // 测试辅助方法
     // ========================================
@@ -287,5 +331,8 @@ export class Database {
         this.sqlClient = null;
         this.redisClient = null;
         this.dbHelper = null;
+        this.sqlConnectedAt = null;
+        this.redisConnectedAt = null;
+        this.sqlPoolMax = 1;
     }
 }

package/lib/logger.ts

@@ -5,20 +5,9 @@
 
 import { join } from 'pathe';
 import { appendFile, stat } from 'node:fs/promises';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import type { LogLevel } from '../types/common.js';
 import type { LoggerConfig } from '../types/befly.js';
 
-/**
- * 日志上下文存储
- */
-export interface LogContext {
-    requestId?: string;
-    [key: string]: any;
-}
-
-export const logContextStorage = new AsyncLocalStorage<LogContext>();
-
 /**
  * 日志消息类型
  */
@@ -84,12 +73,7 @@ export class Logger {
 
         // 格式化日志消息
         const levelStr = level.toUpperCase().padStart(5);
-
-        // 获取上下文中的 requestId
-        const store = logContextStorage.getStore();
-        const requestId = store?.requestId ? ` [${store.requestId}]` : '';
-
-        const logMessage = `[${timestamp}]${requestId} ${levelStr} - ${content}`;
+        const logMessage = `[${timestamp}] ${levelStr} - ${content}`;
 
         // 控制台输出
         if (this.config.console === 1) {

package/lib/redisHelper.ts

@@ -3,9 +3,10 @@
  * 提供 Redis 操作的便捷方法
  */
 
-import { RedisClient } from 'bun';
-import { Logger } from '../lib/logger.js';
-import { Database } from './database.js';
+import { SQL, RedisClient } from 'bun';
+import { Logger } from './logger.js';
+import { Connect } from './connect.js';
+import type { KeyValue } from '../types/common.js';
 
 /**
  * Redis 助手类
@@ -19,9 +20,9 @@ export class RedisHelper {
      * @param prefix - Key 前缀
      */
     constructor(prefix: string = '') {
-        const client = Database.getRedis();
+        const client = Connect.getRedis();
         if (!client) {
-            throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
+            throw new Error('Redis 客户端未初始化，请先调用 Connect.connectRedis()');
         }
         this.client = client;
         this.prefix = prefix ? `${prefix}:` : '';

package/loader/loadApis.ts

@@ -58,9 +58,9 @@ const DEFAULT_API_FIELDS = {
 
 /**
  * 加载所有 API 路由
- * @param apiRoutes - API 路由映射表
+ * @param apis - API 路由映射表
  */
-export async function loadApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+export async function loadApis(apis: Map<string, ApiRoute>): Promise<void> {
     try {
         const loadStartTime = Bun.nanoseconds();
 
@@ -120,7 +120,7 @@ export async function loadApis(apiRoutes: Map<string, ApiRoute>): Promise<void>
 
                 // 构建路由
                 api.route = `${api.method.toUpperCase()}/api/${apiFile.routePrefix ? apiFile.routePrefix + '/' : ''}${apiFile.relativePath}`;
-                apiRoutes.set(api.route, api);
+                apis.set(api.route, api);
             } catch (error: any) {
                 Logger.error(`[${apiFile.typeName}] 接口 ${apiFile.relativePath} 加载失败`, error);
                 process.exit(1);

package/loader/loadHooks.ts

@@ -1,63 +1,37 @@
 /**
  * 钩子加载器
- * 负责扫描和初始化所有钩子（核心、组件、项目）
+ * 只加载核心钩子
  */
 
-// 外部依赖
-import { scanAddons, getAddonDir } from 'befly-util';
-
 // 相对导入
 import { Logger } from '../lib/logger.js';
-import { coreHookDir, projectHookDir } from '../paths.js';
-import { sortModules, scanModules } from '../util.js';
+import { coreHookDir } from '../paths.js';
+import { scanModules } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
 
-export async function loadHooks(befly: {
-    //
-    hookLists: Hook[];
-    pluginsConfig?: Record<string, any>;
-}): Promise<void> {
+export async function loadHooks(pluginsConfig: Record<string, any> | undefined, hooks: Hook[]): Promise<void> {
     try {
-        const allHooks: Hook[] = [];
-
         // 1. 扫描核心钩子
-        const coreHooks = await scanModules<Hook>(coreHookDir, 'core', '钩子', befly.pluginsConfig);
-
-        // 2. 扫描组件钩子
-        const addonHooks: Hook[] = [];
-        const addons = scanAddons();
-        for (const addon of addons) {
-            const dir = getAddonDir(addon, 'hooks');
-            const hooks = await scanModules<Hook>(dir, 'addon', '钩子', befly.pluginsConfig, addon);
-            addonHooks.push(...hooks);
-        }
+        const coreHooks = await scanModules<Hook>(coreHookDir, 'core', '钩子', pluginsConfig);
 
-        // 3. 扫描项目钩子
-        const appHooks = await scanModules<Hook>(projectHookDir, 'app', '钩子', befly.pluginsConfig);
-
-        // 4. 合并所有钩子
-        allHooks.push(...coreHooks);
-        allHooks.push(...addonHooks);
-        allHooks.push(...appHooks);
-
-        // 5. 过滤禁用的钩子
-        const disableHooks = (befly as any).config?.disableHooks || [];
-        const enabledHooks = allHooks.filter((hook) => !disableHooks.includes(hook.name));
+        // 2. 过滤禁用的钩子
+        const disableHooks = (pluginsConfig as any)?.disableHooks || [];
+        const enabledHooks = coreHooks.filter((hook) => !disableHooks.includes(hook.name));
 
         if (disableHooks.length > 0) {
             Logger.info(`禁用钩子: ${disableHooks.join(', ')}`);
         }
 
-        // 6. 排序
-        const sortedHooks = sortModules(enabledHooks);
-        if (sortedHooks === false) {
-            Logger.error('钩子依赖关系错误，请检查 after 属性');
-            process.exit(1);
-        }
+        // 3. 按 order 排序
+        const sortedHooks = enabledHooks.sort((a, b) => {
+            const orderA = a.order ?? 999;
+            const orderB = b.order ?? 999;
+            return orderA - orderB;
+        });
 
-        befly.hookLists.push(...sortedHooks);
+        hooks.push(...sortedHooks);
     } catch (error: any) {
         Logger.error('加载钩子时发生错误', error);
         process.exit(1);