befly 3.2.0 → 3.3.0

package/plugins/cache.ts

@@ -0,0 +1,187 @@
+/**
+ * 缓存插件 - TypeScript 版本
+ * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
+ */
+
+import { Logger } from '../lib/logger.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+import type { ApiRoute } from '../types/api.js';
+
+/**
+ * 缓存管理器类
+ */
+class CacheManager {
+    private appContext: BeflyContext;
+
+    constructor(appContext: BeflyContext) {
+        this.appContext = appContext;
+    }
+
+    /**
+     * 缓存所有接口到 Redis
+     */
+    async cacheApis(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.appContext.db.tableExists('core_api');
+            if (!tableExists) {
+                Logger.warn('⚠️ 接口表不存在，跳过接口缓存');
+                return;
+            }
+
+            // 从数据库查询所有接口（与 apiAll.ts 保持一致）
+            const apiList = await this.appContext.db.getAll({
+                table: 'core_api',
+                fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
+                orderBy: ['addonName#ASC', 'path#ASC']
+            });
+
+            // 缓存到 Redis
+            const result = await this.appContext.redis.setObject('apis:all', apiList);
+
+            if (result === null) {
+                Logger.warn('⚠️ 接口缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: apis:all)`);
+            }
+        } catch (error: any) {
+            Logger.error('⚠️ 接口缓存异常:', error);
+        }
+    }
+
+    /**
+     * 缓存所有菜单到 Redis（从数据库读取）
+     */
+    async cacheMenus(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.appContext.db.tableExists('core_menu');
+            if (!tableExists) {
+                Logger.warn('⚠️ 菜单表不存在，跳过菜单缓存');
+                return;
+            }
+
+            // 从数据库查询所有菜单
+            const menus = await this.appContext.db.getAll({
+                table: 'core_menu',
+                fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
+                orderBy: ['sort#ASC', 'id#ASC']
+            });
+
+            // 缓存到 Redis
+            const result = await this.appContext.redis.setObject('menus:all', menus);
+
+            if (result === null) {
+                Logger.warn('⚠️ 菜单缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: menus:all)`);
+            }
+        } catch (error: any) {
+            const errorMessage = error?.message || error?.toString?.() || String(error);
+            Logger.warn('⚠️ 菜单缓存异常:', errorMessage);
+        }
+    }
+
+    /**
+     * 缓存所有角色的接口权限到 Redis
+     */
+    async cacheRolePermissions(): Promise<void> {
+        try {
+            // 检查表是否存在
+            const apiTableExists = await this.appContext.db.tableExists('core_api');
+            const roleTableExists = await this.appContext.db.tableExists('core_role');
+
+            if (!apiTableExists || !roleTableExists) {
+                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
+                return;
+            }
+
+            // 查询所有角色
+            const roles = await this.appContext.db.getAll({
+                table: 'core_role',
+                fields: ['id', 'code', 'apis']
+            });
+
+            // 查询所有接口（用于权限映射）
+            const allApis = await this.appContext.db.getAll({
+                table: 'core_api',
+                fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
+            });
+
+            // 为每个角色缓存接口权限
+            let cachedRoles = 0;
+            for (const role of roles) {
+                if (!role.apis) continue;
+
+                // 解析角色的接口 ID 列表
+                const apiIds = role.apis
+                    .split(',')
+                    .map((id: string) => parseInt(id.trim()))
+                    .filter((id: number) => !isNaN(id));
+
+                // 根据 ID 过滤出接口路径
+                const roleApiPaths = allApis.filter((api: any) => apiIds.includes(api.id)).map((api: any) => `${api.method}${api.path}`);
+
+                if (roleApiPaths.length === 0) continue;
+
+                // 使用 Redis Set 缓存角色权限（性能优化：SADD + SISMEMBER）
+                const redisKey = `role:apis:${role.code}`;
+
+                // 先删除旧数据
+                await this.appContext.redis.del(redisKey);
+
+                // 批量添加到 Set
+                const result = await this.appContext.redis.sadd(redisKey, roleApiPaths);
+
+                if (result > 0) {
+                    cachedRoles++;
+                    Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
+                }
+            }
+
+            Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
+        } catch (error: any) {
+            const errorMessage = error?.message || error?.toString?.() || String(error);
+            Logger.warn('⚠️ 角色权限缓存异常:', errorMessage);
+        }
+    }
+
+    /**
+     * 缓存所有数据
+     */
+    async cacheAll(): Promise<void> {
+        Logger.info('========== 开始缓存数据到 Redis ==========');
+
+        // 1. 缓存接口
+        await this.cacheApis();
+
+        // 2. 缓存菜单
+        await this.cacheMenus();
+
+        // 3. 缓存角色权限
+        await this.cacheRolePermissions();
+
+        Logger.info('========== 数据缓存完成 ==========\n');
+    }
+}
+
+/**
+ * 缓存插件
+ */
+const cachePlugin: Plugin = {
+    name: '_cache',
+    after: ['_db', '_redis'],
+
+    async onInit(befly: BeflyContext): Promise<CacheManager> {
+        try {
+            const cacheManager = new CacheManager(befly);
+            Logger.info('缓存插件初始化成功');
+            return cacheManager;
+        } catch (error: any) {
+            throw error;
+        }
+    }
+};
+
+export default cachePlugin;

package/plugins/db.ts

@@ -4,9 +4,9 @@
  */
 
 import { Env } from '../config/env.js';
-import { Logger } from '../utils/logger.js';
-import { createSqlClient } from '../utils/database.js';
-import { DbHelper } from '../utils/dbHelper.js';
+import { Logger } from '../lib/logger.js';
+import { Database } from '../lib/database.js';
+import { DbHelper } from '../lib/dbHelper.js';
 import type { Plugin } from '../types/plugin.js';
 import type { BeflyContext } from '../types/befly.js';
 
@@ -26,7 +26,7 @@ const dbPlugin: Plugin = {
                 // 从环境变量读取连接超时配置
                 const connectionTimeout = process.env.DB_CONNECTION_TIMEOUT ? parseInt(process.env.DB_CONNECTION_TIMEOUT) : 5000;
 
-                sql = await createSqlClient({
+                sql = await Database.connectSql({
                     connectionTimeout
                 });
 

package/plugins/logger.ts

@@ -3,7 +3,7 @@
  * 提供全局日志功能
  */
 
-import { Logger } from '../utils/logger.js';
+import { Logger } from '../lib/logger.js';
 import type { Plugin } from '../types/plugin.js';
 import type { BeflyContext } from '../types/befly.js';
 

package/plugins/redis.ts

@@ -4,9 +4,9 @@
  */
 
 import { Env } from '../config/env.js';
-import { Logger } from '../utils/logger.js';
-import { RedisHelper } from '../utils/redisHelper.js';
-import { initRedisOnly } from '../utils/database.js';
+import { Logger } from '../lib/logger.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';
 
@@ -21,7 +21,7 @@ const redisPlugin: Plugin = {
         try {
             if (Env.REDIS_ENABLE === 1) {
                 // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
-                await initRedisOnly();
+                await Database.connectRedis();
 
                 Logger.info('Redis 插件初始化成功', {
                     host: Env.REDIS_HOST,

package/router/api.ts

@@ -0,0 +1,155 @@
+/**
+ * API路由处理器
+ * 处理 /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 '../config/env.js';
+import type { RequestContext } from '../util.js';
+import type { ApiRoute } from '../types/api.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * API处理器工厂函数
+ * @param apiRoutes - API路由映射表
+ * @param pluginLists - 插件列表
+ * @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()
+            };
+
+            // 3. 获取API路由
+            const url = new URL(req.url);
+            apiPath = `${req.method}${url.pathname}`;
+            api = apiRoutes.get(apiPath);
+
+            if (!api) {
+                return Response.json(No('接口不存在'), {
+                    headers: corsOptions.headers
+                });
+            }
+
+            // 4. 用户认证
+            await authenticate(ctx);
+
+            // 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
+                    });
+                }
+            }
+
+            // 6. 执行插件钩子
+            await executePluginHooks(pluginLists, appContext, ctx);
+
+            // 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. 返回响应
+            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
+                });
+            }
+        } catch (error: any) {
+            // 记录详细的错误日志
+            Logger.warn(api ? `接口 [${api.name}] 执行失败` : '处理接口请求时发生错误', error);
+
+            // 根据错误类型返回不同的错误信息
+            let errorMessage = '内部服务器错误';
+            let errorDetail = {};
+
+            // 数据库错误
+            if (error.message?.includes('ECONNREFUSED') || error.message?.includes('database')) {
+                errorMessage = '数据库连接失败';
+            }
+            // Redis错误
+            else if (error.message?.includes('Redis') || error.message?.includes('redis')) {
+                errorMessage = 'Redis服务异常';
+            }
+            // 权限错误
+            else if (error.message?.includes('permission') || error.message?.includes('权限')) {
+                errorMessage = '权限不足';
+            }
+            // 认证错误
+            else if (error.message?.includes('token') || error.message?.includes('认证')) {
+                errorMessage = '认证失败';
+            }
+
+            // 开发环境返回详细错误信息
+            if (Env.NODE_ENV === 'development') {
+                errorDetail = {
+                    type: error.constructor?.name || 'Error',
+                    message: error.message,
+                    stack: error.stack
+                };
+            }
+
+            return Response.json(No(errorMessage, errorDetail), {
+                headers: corsOptions.headers
+            });
+        }
+    };
+}

package/router/root.ts

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

package/router/static.ts

@@ -0,0 +1,76 @@
+/**
+ * 静态文件路由处理器
+ * 处理 /* 路径的静态文件请求
+ */
+
+import { join } from 'pathe';
+import { paths } from '../paths.js';
+import { No } from '../util.js';
+import { setCorsOptions } from '../lib/middleware.js';
+import { Logger } from '../lib/logger.js';
+import { Env } from '../config/env.js';
+
+/**
+ * 静态文件处理器
+ */
+export async function staticHandler(req: Request): Promise<Response> {
+    const corsOptions = setCorsOptions(req);
+    const url = new URL(req.url);
+    const filePath = join(paths.projectDir, 'public', url.pathname);
+
+    try {
+        // OPTIONS预检请求
+        if (req.method === 'OPTIONS') {
+            return new Response(null, {
+                status: 204,
+                headers: corsOptions.headers
+            });
+        }
+
+        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);
+
+        // 根据错误类型返回不同的错误信息
+        let errorMessage = '文件读取失败';
+        let errorDetail = {};
+
+        // 权限错误
+        if (error.message?.includes('EACCES') || error.message?.includes('permission')) {
+            errorMessage = '文件访问权限不足';
+        }
+        // 路径错误
+        else if (error.message?.includes('ENOENT') || error.message?.includes('not found')) {
+            errorMessage = '文件路径不存在';
+        }
+
+        // 开发环境返回详细错误信息
+        if (Env.NODE_ENV === 'development') {
+            errorDetail = {
+                type: error.constructor?.name || 'Error',
+                message: error.message,
+                stack: error.stack,
+                filePath: filePath
+            };
+        }
+
+        return Response.json(No(errorMessage, errorDetail), {
+            status: 500,
+            headers: corsOptions.headers
+        });
+    }
+}

package/types/api.d.ts

@@ -11,42 +11,6 @@ import type { RequestContext } from './context.js';
  */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
 
-/**
- * 请求上下文类型（已废弃，使用 RequestContext 类）
- * @deprecated 使用 RequestContext 类替代
- */
-export interface RequestContext<T = any> {
-    /** 请求对象 */
-    request: Request;
-
-    /** 请求体参数 */
-    body: T;
-
-    /** URL 参数 */
-    query: KeyValue<string>;
-
-    /** 路径参数 */
-    pathParams: KeyValue<string>;
-
-    /** 请求头 */
-    headers: Headers;
-
-    /** 用户信息（认证后） */
-    user?: UserInfo;
-
-    /** 客户端 IP */
-    ip?: string;
-
-    /** User-Agent */
-    userAgent?: string;
-
-    /** 请求 ID */
-    requestId?: string;
-
-    /** 开始时间 */
-    startTime: number;
-}
-
 /**
  * 用户信息类型
  */

package/types/befly.d.ts

@@ -5,11 +5,13 @@
 import type { Plugin } from './plugin.js';
 import type { ApiRoute, HttpMethod } from './api.js';
 import type { KeyValue } from './common.js';
-import type { Logger } from '../utils/logger.js';
-import type { Jwt } from '../utils/jwt.js';
-import type { Validator } from '../utils/validate.js';
-import type { DbHelper } from '../utils/dbHelper.js';
-import type { Crypto2 } from '../utils/crypto.js';
+import type { Logger } from '../lib/logger.js';
+import type { Jwt } from '../lib/jwt.js';
+import type { Validator } from '../lib/validator.js';
+import type { Database } from 'bun:sqlite';
+import type { DbHelper } from '../lib/dbHelper.js';
+import type { RedisHelper } from '../lib/redisHelper.js';
+import type { Cipher } from '../lib/cipher.js';
 
 /**
  * Befly 应用选项
@@ -81,7 +83,7 @@ export interface Befly {
     sql: DbHelper;
 
     /** 加密工具 */
-    crypto: Crypto2;
+    crypto: Cipher;
 
     /** 数据库连接 */
     db: any;

package/types/common.d.ts

@@ -40,7 +40,7 @@ export type TableDefinition = Record<string, FieldRule>;
  */
 export interface ParsedFieldRule {
     name: string; // 字段名称
-    type: 'string' | 'number' | 'text' | 'array';
+    type: 'string' | 'number' | 'text' | 'array_string' | 'array_text';
     min: number | null; // 最小值
     max: number | null; // 最大值
     default: any; // 默认值

package/types/context.d.ts

@@ -1,7 +1,7 @@
 /**
  * 请求上下文类型定义
- * 实现代码位于 utils/requestContext.ts
+ * 实现代码位于 util.ts，类型定义位于 types/util.d.ts
  */
 
-// 重新导出 RequestContext 类
-export { RequestContext } from '../utils/requestContext.js';
+// 重新导出 RequestContext 接口
+export type { RequestContext } from './util.js';

package/types/util.d.ts

@@ -0,0 +1,45 @@
+/**
+ * util.ts 相关类型定义
+ */
+
+import type { RedisClient } from 'bun';
+import type { DbHelper } from '../lib/dbHelper.js';
+
+/**
+ * 数据清洗选项
+ */
+export interface DataCleanOptions {
+    /** 排除的字段名 */
+    excludeKeys?: string[];
+    /** 包含的字段名（优先级高于 excludeKeys） */
+    includeKeys?: string[];
+    /** 要移除的值 */
+    removeValues?: any[];
+    /** 字符串最大长度（超出截断） */
+    maxLen?: number;
+    /** 是否深度处理嵌套对象 */
+    deep?: boolean;
+}
+
+/**
+ * 数据库连接集合（内部使用）
+ */
+export interface DatabaseConnections {
+    redis: RedisClient | null;
+    sql: any;
+    helper: DbHelper | null;
+}
+
+/**
+ * 请求上下文接口
+ */
+export interface RequestContext {
+    /** 请求体参数 */
+    body: Record<string, any>;
+    /** 用户信息 */
+    user: Record<string, any>;
+    /** 原始请求对象 */
+    request: Request;
+    /** 请求开始时间（毫秒） */
+    startTime: number;
+}