befly 3.8.29 → 3.8.30

package/README.md

@@ -37,12 +37,14 @@ bunx befly init
 
 ```typescript
 // main.ts
-import { Server } from 'befly';
+import { Befly } from 'befly';
 
-await Server({
-    name: 'My API',
-    port: 3000
+const app = new Befly({
+    appName: 'My API',
+    appPort: 3000
 });
+
+await app.start();
 ```
 
 运行项目：
@@ -55,7 +57,7 @@ bun run main.ts
 
 ```typescript
 // apis/user/hello.ts
-import type { ApiRoute } from 'befly';
+import type { ApiRoute } from 'befly/types/index';
 
 export default {
     name: '问候接口',
@@ -79,7 +81,7 @@ export default {
 ### TypeScript 全面支持
 
 ```typescript
-import type { ApiRoute, BeflyContext } from 'befly';
+import type { ApiRoute, BeflyContext } from 'befly/types/index';
 import type { User } from './types/models';
 
 export default {

package/checks/checkApi.ts

@@ -3,7 +3,8 @@ import { existsSync } from 'node:fs';
 
 // 外部依赖
 import { isPlainObject } from 'es-toolkit/compat';
-import { scanAddons, getAddonDir, addonDirExists, scanFiles } from 'befly-util';
+import { scanFiles } from 'befly-shared/scanFiles';
+import { scanAddons, getAddonDir, addonDirExists } from 'befly-shared/addonHelper';
 
 // 相对导入
 import { Logger } from '../lib/logger.js';

package/checks/checkTable.ts

@@ -3,14 +3,15 @@ import { existsSync } from 'node:fs';
 
 // 外部依赖
 import { basename } from 'pathe';
-import { scanAddons, getAddonDir, scanFiles } from 'befly-util';
+import { scanFiles } from 'befly-shared/scanFiles';
+import { scanAddons, getAddonDir } from 'befly-shared/addonHelper';
 
 // 相对导入
 import { Logger } from '../lib/logger.js';
 import { projectTableDir } from '../paths.js';
 
 // 类型导入
-import type { FieldDefinition } from '../types/common.js';
+import type { FieldDefinition } from 'befly-shared/types';
 
 /**
  * 表文件信息接口

package/hooks/parser.ts

@@ -1,14 +1,16 @@
 // 外部依赖
 import { isPlainObject, isEmpty } from 'es-toolkit/compat';
-import { pickFields } from 'befly-util';
+import { pickFields } from 'befly-shared/pickFields';
+import { XMLParser } from 'fast-xml-parser';
 
 // 相对导入
-import { Xml } from '../lib/xml.js';
 import { ErrorResponse } from '../util.js';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
 
+const xmlParser = new XMLParser();
+
 /**
  * 请求参数解析钩子
  * - GET 请求：解析 URL 查询参数
@@ -43,7 +45,7 @@ const hook: Hook = {
                 } else if (contentType.includes('application/xml') || contentType.includes('text/xml')) {
                     // XML 格式
                     const text = await ctx.req.text();
-                    const body = await Xml.parse(text);
+                    const body = xmlParser.parse(text);
                     if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
                         ctx.body = pickFields(body, Object.keys(ctx.api.fields));
                     } else {

package/hooks/permission.ts

@@ -1,5 +1,6 @@
 // 相对导入
 import { ErrorResponse } from '../util.js';
+import { RedisKeys } from 'befly-shared/redisKeys';
 
 // 类型导入
 import type { Hook } from '../types/hook.js';
@@ -35,11 +36,17 @@ const hook: Hook = {
         // 4. 角色权限检查
         let hasPermission = false;
         if (ctx.user.roleCode && befly.redis) {
-            // 验证角色权限
-            const apiPath = `${ctx.req.method}${new URL(ctx.req.url).pathname}`;
-            const roleApisKey = `role:apis:${ctx.user.roleCode}`;
-            const isMember = await befly.redis.sismember(roleApisKey, apiPath);
-            hasPermission = isMember === 1;
+            try {
+                // 验证角色权限
+                const apiPath = `${ctx.req.method}${new URL(ctx.req.url).pathname}`;
+                const roleApisKey = RedisKeys.roleApis(ctx.user.roleCode);
+                const isMember = await befly.redis.sismember(roleApisKey, apiPath);
+                hasPermission = isMember === 1;
+            } catch (error) {
+                // Redis 异常时降级为拒绝访问
+                befly.logger.warn({ err: error, route: ctx.route }, 'Redis 权限检查失败');
+                hasPermission = false;
+            }
         }
 
         if (!hasPermission) {

package/lib/cacheHelper.ts

@@ -4,6 +4,8 @@
  */
 
 import { Logger } from './logger.js';
+import { RedisKeys } from 'befly-shared/redisKeys';
+
 import type { BeflyContext } from '../types/befly.js';
 
 /**
@@ -26,29 +28,29 @@ export class CacheHelper {
     async cacheApis(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.befly.db.tableExists('core_api');
+            const tableExists = await this.befly.db.tableExists('addon_admin_api');
             if (!tableExists) {
                 Logger.warn('⚠️ 接口表不存在，跳过接口缓存');
                 return;
             }
 
-            // 从数据库查询所有接口（与 apiAll.ts 保持一致）
+            // 从数据库查询所有接口
             const apiList = await this.befly.db.getAll({
-                table: 'core_api',
+                table: 'addon_admin_api',
                 fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
                 orderBy: ['addonName#ASC', 'path#ASC']
             });
 
             // 缓存到 Redis
-            const result = await this.befly.redis.setObject('apis:all', apiList);
+            const result = await this.befly.redis.setObject(RedisKeys.apisAll(), apiList);
 
             if (result === null) {
                 Logger.warn('⚠️ 接口缓存失败');
             } else {
-                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: apis:all)`);
+                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: ${RedisKeys.apisAll()})`);
             }
         } catch (error: any) {
-            Logger.error('⚠️ 接口缓存异常:', error);
+            Logger.error({ err: error }, '⚠️ 接口缓存异常');
         }
     }
 
@@ -58,7 +60,7 @@ export class CacheHelper {
     async cacheMenus(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.befly.db.tableExists('core_menu');
+            const tableExists = await this.befly.db.tableExists('addon_admin_menu');
             if (!tableExists) {
                 Logger.warn('⚠️ 菜单表不存在，跳过菜单缓存');
                 return;
@@ -66,86 +68,101 @@ export class CacheHelper {
 
             // 从数据库查询所有菜单
             const menus = await this.befly.db.getAll({
-                table: 'core_menu',
+                table: 'addon_admin_menu',
                 fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
                 orderBy: ['sort#ASC', 'id#ASC']
             });
 
             // 缓存到 Redis
-            const result = await this.befly.redis.setObject('menus:all', menus);
+            const result = await this.befly.redis.setObject(RedisKeys.menusAll(), menus);
 
             if (result === null) {
                 Logger.warn('⚠️ 菜单缓存失败');
             } else {
-                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: menus:all)`);
+                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: ${RedisKeys.menusAll()})`);
             }
         } catch (error: any) {
-            const errorMessage = error?.message || error?.toString?.() || String(error);
-            Logger.warn('⚠️ 菜单缓存异常:', errorMessage);
+            Logger.warn({ err: error }, '⚠️ 菜单缓存异常');
         }
     }
 
     /**
      * 缓存所有角色的接口权限到 Redis
+     * 优化：使用 Promise.all 利用 Bun Redis 自动 pipeline 特性
      */
     async cacheRolePermissions(): Promise<void> {
         try {
             // 检查表是否存在
-            const apiTableExists = await this.befly.db.tableExists('core_api');
-            const roleTableExists = await this.befly.db.tableExists('core_role');
+            const apiTableExists = await this.befly.db.tableExists('addon_admin_api');
+            const roleTableExists = await this.befly.db.tableExists('addon_admin_role');
 
             if (!apiTableExists || !roleTableExists) {
                 Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
                 return;
             }
 
-            // 查询所有角色
-            const roles = await this.befly.db.getAll({
-                table: 'core_role',
-                fields: ['id', 'code', 'apis']
-            });
+            // 并行查询角色和接口（利用自动 pipeline）
+            const [roles, allApis] = await Promise.all([
+                this.befly.db.getAll({
+                    table: 'addon_admin_role',
+                    fields: ['id', 'code', 'apis']
+                }),
+                this.befly.db.getAll({
+                    table: 'addon_admin_api',
+                    fields: ['id', 'path', 'method']
+                })
+            ]);
+
+            // 构建接口 ID -> 路径的映射（避免重复过滤）
+            const apiMap = new Map<number, string>();
+            for (const api of allApis) {
+                apiMap.set(api.id, `${api.method}${api.path}`);
+            }
 
-            // 查询所有接口（用于权限映射）
-            const allApis = await this.befly.db.getAll({
-                table: 'core_api',
-                fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
-            });
+            // 收集需要缓存的角色权限
+            const cacheOperations: Array<{ roleCode: string; apiPaths: string[] }> = [];
 
-            // 为每个角色缓存接口权限
-            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}`);
+                // 解析角色的接口 ID 列表并映射到路径
+                const apiPaths: string[] = [];
+                const apiIds = role.apis.split(',');
+
+                for (const idStr of apiIds) {
+                    const id = parseInt(idStr.trim());
+                    if (!isNaN(id)) {
+                        const path = apiMap.get(id);
+                        if (path) {
+                            apiPaths.push(path);
+                        }
+                    }
+                }
 
-                if (roleApiPaths.length === 0) continue;
+                if (apiPaths.length > 0) {
+                    cacheOperations.push({ roleCode: role.code, apiPaths: apiPaths });
+                }
+            }
 
-                // 使用 Redis Set 缓存角色权限（性能优化：SADD + SISMEMBER）
-                const redisKey = `role:apis:${role.code}`;
+            if (cacheOperations.length === 0) {
+                Logger.info('✅ 没有需要缓存的角色权限');
+                return;
+            }
 
-                // 先删除旧数据
-                await this.befly.redis.del(redisKey);
+            // 批量删除旧缓存（利用自动 pipeline）
+            const deletePromises = cacheOperations.map((op) => this.befly.redis.del(RedisKeys.roleApis(op.roleCode)));
+            await Promise.all(deletePromises);
 
-                // 批量添加到 Set
-                const result = await this.befly.redis.sadd(redisKey, roleApiPaths);
+            // 批量添加新缓存（利用自动 pipeline）
+            const addPromises = cacheOperations.map((op) => this.befly.redis.sadd(RedisKeys.roleApis(op.roleCode), op.apiPaths));
+            const results = await Promise.all(addPromises);
 
-                if (result > 0) {
-                    cachedRoles++;
-                    Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
-                }
-            }
+            // 统计成功缓存的角色数
+            const cachedRoles = results.filter((r) => r > 0).length;
 
-            Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
+            Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限（共 ${cacheOperations.reduce((sum, op) => sum + op.apiPaths.length, 0)} 个接口）`);
         } catch (error: any) {
-            const errorMessage = error?.message || error?.toString?.() || String(error);
-            Logger.warn('⚠️ 角色权限缓存异常:', errorMessage);
+            Logger.warn({ err: error }, '⚠️ 角色权限缓存异常');
         }
     }
 
@@ -169,10 +186,10 @@ export class CacheHelper {
      */
     async getApis(): Promise<any[]> {
         try {
-            const apis = await this.befly.redis.getObject<any[]>('apis:all');
+            const apis = await this.befly.redis.getObject<any[]>(RedisKeys.apisAll());
             return apis || [];
         } catch (error: any) {
-            Logger.error('获取接口缓存失败:', error);
+            Logger.error({ err: error }, '获取接口缓存失败');
             return [];
         }
     }
@@ -183,10 +200,10 @@ export class CacheHelper {
      */
     async getMenus(): Promise<any[]> {
         try {
-            const menus = await this.befly.redis.getObject<any[]>('menus:all');
+            const menus = await this.befly.redis.getObject<any[]>(RedisKeys.menusAll());
             return menus || [];
         } catch (error: any) {
-            Logger.error('获取菜单缓存失败:', error);
+            Logger.error({ err: error }, '获取菜单缓存失败');
             return [];
         }
     }
@@ -198,11 +215,10 @@ export class CacheHelper {
      */
     async getRolePermissions(roleCode: string): Promise<string[]> {
         try {
-            const redisKey = `role:apis:${roleCode}`;
-            const permissions = await this.befly.redis.smembers(redisKey);
+            const permissions = await this.befly.redis.smembers(RedisKeys.roleApis(roleCode));
             return permissions || [];
         } catch (error: any) {
-            Logger.error(`获取角色 ${roleCode} 权限缓存失败:`, error);
+            Logger.error({ err: error, roleCode: roleCode }, '获取角色权限缓存失败');
             return [];
         }
     }
@@ -215,11 +231,10 @@ export class CacheHelper {
      */
     async checkRolePermission(roleCode: string, apiPath: string): Promise<boolean> {
         try {
-            const redisKey = `role:apis:${roleCode}`;
-            const result = await this.befly.redis.sismember(redisKey, apiPath);
+            const result = await this.befly.redis.sismember(RedisKeys.roleApis(roleCode), apiPath);
             return result === 1;
         } catch (error: any) {
-            Logger.error(`检查角色 ${roleCode} 权限失败:`, error);
+            Logger.error({ err: error, roleCode: roleCode }, '检查角色权限失败');
             return false;
         }
     }
@@ -231,15 +246,14 @@ export class CacheHelper {
      */
     async deleteRolePermissions(roleCode: string): Promise<boolean> {
         try {
-            const redisKey = `role:apis:${roleCode}`;
-            const result = await this.befly.redis.del(redisKey);
+            const result = await this.befly.redis.del(RedisKeys.roleApis(roleCode));
             if (result > 0) {
                 Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
                 return true;
             }
             return false;
         } catch (error: any) {
-            Logger.error(`删除角色 ${roleCode} 权限缓存失败:`, error);
+            Logger.error({ err: error, roleCode: roleCode }, '删除角色权限缓存失败');
             return false;
         }
     }

package/lib/connect.ts

@@ -4,10 +4,10 @@
  */
 
 import { SQL, RedisClient } from 'bun';
+
 import { Logger } from './logger.js';
-import { DbHelper } from './dbHelper.js';
-import { RedisHelper } from './redisHelper.js';
-import type { BeflyContext, BeflyOptions, DatabaseConfig, RedisConfig } from '../types/befly.js';
+
+import type { BeflyOptions, DatabaseConfig, RedisConfig } from '../types/befly.js';
 import type { SqlClientOptions } from '../types/database.js';
 
 /**
@@ -17,7 +17,6 @@ import type { SqlClientOptions } from '../types/database.js';
 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;
@@ -95,7 +94,7 @@ export class Connect {
             this.sqlPoolMax = config.poolMax ?? 1;
             return sql;
         } catch (error: any) {
-            Logger.error('[Connect] SQL 连接失败', error);
+            Logger.error({ err: error }, '[Connect] SQL 连接失败');
             try {
                 await sql?.close();
             } catch (cleanupError) {}
@@ -112,15 +111,11 @@ export class Connect {
             try {
                 await this.sqlClient.close();
             } catch (error: any) {
-                Logger.error('[Connect] 关闭 SQL 连接时出错', error);
+                Logger.error({ err: error }, '[Connect] 关闭 SQL 连接时出错');
             }
             this.sqlClient = null;
             this.sqlConnectedAt = null;
         }
-
-        if (this.dbHelper) {
-            this.dbHelper = null;
-        }
     }
 
     /**
@@ -134,27 +129,6 @@ export class Connect {
         return this.sqlClient;
     }
 
-    /**
-     * 获取 DbHelper 实例
-     * @throws 如果未连接则抛出错误
-     */
-    static getDbHelper(befly?: BeflyContext): DbHelper {
-        if (!this.dbHelper) {
-            if (!this.sqlClient) {
-                throw new Error('SQL 客户端未连接，请先调用 Connect.connectSql()');
-            }
-            // 创建临时 befly 上下文（仅用于 DbHelper）
-            const ctx = befly || {
-                redis: new RedisHelper(),
-                db: null as any,
-                tool: null as any,
-                logger: null as any
-            };
-            this.dbHelper = new DbHelper(ctx, this.sqlClient);
-        }
-        return this.dbHelper;
-    }
-
     // ========================================
     // Redis 连接管理
     // ========================================
@@ -197,7 +171,7 @@ export class Connect {
             this.redisConnectedAt = Date.now();
             return redis;
         } catch (error: any) {
-            Logger.error('[Connect] Redis 连接失败', error);
+            Logger.error({ err: error }, '[Connect] Redis 连接失败');
             throw new Error(`Redis 连接失败: ${error.message}`);
         }
     }
@@ -211,7 +185,7 @@ export class Connect {
                 this.redisClient.close();
                 this.redisConnectedAt = null;
             } catch (error: any) {
-                Logger.error('[Connect] 关闭 Redis 连接时出错', error);
+                Logger.error({ err: error }, '[Connect] 关闭 Redis 连接时出错');
             }
             this.redisClient = null;
         }
@@ -250,7 +224,7 @@ export class Connect {
             const redisConfig = config?.redis || {};
             await this.connectRedis(redisConfig);
         } catch (error: any) {
-            Logger.error('数据库初始化失败', error);
+            Logger.error({ err: error }, '数据库初始化失败');
             await this.disconnect();
             throw error;
         }
@@ -330,7 +304,6 @@ export class Connect {
     static __reset(): void {
         this.sqlClient = null;
         this.redisClient = null;
-        this.dbHelper = null;
         this.sqlConnectedAt = null;
         this.redisConnectedAt = null;
         this.sqlPoolMax = 1;

package/lib/dbHelper.ts

@@ -5,8 +5,12 @@
 
 import { snakeCase } from 'es-toolkit/string';
 import { SqlBuilder } from './sqlBuilder.js';
-import { keysToCamel, arrayKeysToCamel, keysToSnake, fieldClear } from 'befly-util';
-import { Logger } from '../lib/logger.js';
+import { keysToCamel } from 'befly-shared/keysToCamel';
+import { arrayKeysToCamel } from 'befly-shared/arrayKeysToCamel';
+import { keysToSnake } from 'befly-shared/keysToSnake';
+import { fieldClear } from 'befly-shared/fieldClear';
+import { RedisTTL, RedisKeys } from 'befly-shared/redisKeys';
+import { Logger } from './logger.js';
 import type { WhereConditions } from '../types/common.js';
 import type { BeflyContext } from '../types/befly.js';
 import type { QueryOptions, InsertOptions, UpdateOptions, DeleteOptions, ListResult, TransactionCallback } from '../types/database.js';
@@ -81,7 +85,7 @@ export class DbHelper {
      */
     private async getTableColumns(table: string): Promise<string[]> {
         // 1. 先查 Redis 缓存
-        const cacheKey = `table:columns:${table}`;
+        const cacheKey = RedisKeys.tableColumns(table);
         let columns = await this.befly.redis.getObject<string[]>(cacheKey);
 
         if (columns && columns.length > 0) {
@@ -98,8 +102,8 @@ export class DbHelper {
 
         columns = result.map((row: any) => row.Field);
 
-        // 3. 写入 Redis 缓存（1小时过期）
-        await this.befly.redis.setObject(cacheKey, columns, 3600);
+        // 3. 写入 Redis 缓存
+        await this.befly.redis.setObject(cacheKey, columns, RedisTTL.tableColumns);
 
         return columns;
     }
@@ -507,12 +511,12 @@ export class DbHelper {
 
         // 警告日志：返回数据超过警告阈值
         if (result.length >= WARNING_LIMIT) {
-            Logger.warn(`⚠️ getAll 从表 \`${options.table}\` 返回了 ${result.length} 行数据，建议使用 getList 分页查询以获得更好的性能。`);
+            Logger.warn({ table: options.table, count: result.length }, 'getAll 返回数据过多，建议使用 getList 分页查询');
         }
 
         // 如果达到上限，额外警告
         if (result.length >= MAX_LIMIT) {
-            Logger.warn(`🚨 getAll 达到了最大限制 (${MAX_LIMIT})，可能还有更多数据。请使用 getList 分页查询。`);
+            Logger.warn({ table: options.table, limit: MAX_LIMIT }, 'getAll 达到最大限制，可能还有更多数据');
         }
 
         // 字段名转换：下划线 → 小驼峰
@@ -625,8 +629,7 @@ export class DbHelper {
             await this.executeWithConn(sql, params);
             return ids;
         } catch (error: any) {
-            // 批量插入失败，记录错误
-            Logger.error(`表 \`${table}\` 批量插入失败`, error);
+            Logger.error({ err: error, table: table }, '批量插入失败');
             throw error;
         }
     }
@@ -759,7 +762,7 @@ export class DbHelper {
                 await conn.query('COMMIT');
                 committed = true;
             } catch (commitError: any) {
-                Logger.error('事务提交失败，正在回滚', commitError);
+                Logger.error({ err: commitError }, '事务提交失败，正在回滚');
                 await conn.query('ROLLBACK');
                 throw new Error(`事务提交失败: ${commitError.message}`);
             }
@@ -772,7 +775,7 @@ export class DbHelper {
                     await conn.query('ROLLBACK');
                     Logger.warn('事务已回滚');
                 } catch (rollbackError: any) {
-                    Logger.error('事务回滚失败', rollbackError);
+                    Logger.error({ err: rollbackError }, '事务回滚失败');
                 }
             }
             throw error;