befly 3.8.1 → 3.8.2

package/lifecycle/loadPlugins.ts

@@ -0,0 +1,244 @@
+/**
+ * 插件加载器
+ * 负责扫描和初始化所有插件（核心、组件、用户）
+ */
+
+import { basename } from 'pathe';
+import { existsSync } from 'node:fs';
+import { camelCase } from 'es-toolkit/string';
+import { Logger } from '../lib/logger.js';
+import { calcPerfTime } from '../util.js';
+import { corePluginDir, projectPluginDir } from '../paths.js';
+import { Addon } from '../lib/addon.js';
+import type { Plugin } from '../types/plugin.js';
+import type { BeflyContext } from '../types/befly.js';
+
+/**
+ * 排序插件（根据依赖关系）
+ */
+function sortPlugins(plugins: Plugin[]): Plugin[] | false {
+    const result: Plugin[] = [];
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const pluginMap: Record<string, Plugin> = Object.fromEntries(plugins.map((p) => [p.pluginName || p.name, p]));
+    let isPass = true;
+
+    const visit = (name: string): void => {
+        if (visited.has(name)) return;
+        if (visiting.has(name)) {
+            isPass = false;
+            return;
+        }
+
+        const plugin = pluginMap[name];
+        if (!plugin) return;
+
+        visiting.add(name);
+        (plugin.after || []).forEach(visit);
+        visiting.delete(name);
+        visited.add(name);
+        result.push(plugin);
+    };
+
+    plugins.forEach((p) => visit(p.pluginName || p.name));
+    return isPass ? result : false;
+}
+
+/**
+ * 扫描核心插件
+ */
+async function scanCorePlugins(loadedPluginNames: Set<string>): Promise<Plugin[]> {
+    const plugins: Plugin[] = [];
+    const glob = new Bun.Glob('*.ts');
+
+    for await (const file of glob.scan({
+        cwd: corePluginDir,
+        onlyFiles: true,
+        absolute: true
+    })) {
+        const fileName = basename(file).replace(/\.ts$/, '');
+        if (fileName.startsWith('_')) continue;
+
+        try {
+            const pluginImport = await import(file);
+            const plugin = pluginImport.default;
+            plugin.pluginName = fileName;
+            plugins.push(plugin);
+            loadedPluginNames.add(fileName);
+        } catch (err: any) {
+            Logger.error(`核心插件 ${fileName} 导入失败`, err);
+            process.exit(1);
+        }
+    }
+
+    return plugins;
+}
+
+/**
+ * 扫描组件插件
+ */
+async function scanAddonPlugins(loadedPluginNames: Set<string>): Promise<Plugin[]> {
+    const plugins: Plugin[] = [];
+    const glob = new Bun.Glob('*.ts');
+    const addons = Addon.scan();
+
+    for (const addon of addons) {
+        if (!Addon.dirExists(addon, 'plugins')) continue;
+
+        const addonPluginsDir = Addon.getDir(addon, 'plugins');
+        for await (const file of glob.scan({
+            cwd: addonPluginsDir,
+            onlyFiles: true,
+            absolute: true
+        })) {
+            const fileName = basename(file).replace(/\.ts$/, '');
+            if (fileName.startsWith('_')) continue;
+
+            const addonCamelCase = camelCase(addon);
+            const fileNameCamelCase = camelCase(fileName);
+            const pluginFullName = `addon${addonCamelCase.charAt(0).toUpperCase() + addonCamelCase.slice(1)}_${fileNameCamelCase}`;
+
+            if (loadedPluginNames.has(pluginFullName)) {
+                continue;
+            }
+
+            try {
+                const plugin = require(file);
+                const pluginInstance = plugin.default;
+                pluginInstance.pluginName = pluginFullName;
+                plugins.push(pluginInstance);
+                loadedPluginNames.add(pluginFullName);
+            } catch (err: any) {
+                Logger.error(`组件${addon} ${fileName} 导入失败`, err);
+                process.exit(1);
+            }
+        }
+    }
+
+    return plugins;
+}
+
+/**
+ * 扫描用户插件
+ */
+async function scanUserPlugins(loadedPluginNames: Set<string>): Promise<Plugin[]> {
+    const plugins: Plugin[] = [];
+
+    if (!existsSync(projectPluginDir)) {
+        return plugins;
+    }
+
+    const glob = new Bun.Glob('*.ts');
+    for await (const file of glob.scan({
+        cwd: projectPluginDir,
+        onlyFiles: true,
+        absolute: true
+    })) {
+        const fileName = basename(file).replace(/\.ts$/, '');
+        if (fileName.startsWith('_')) continue;
+
+        const fileNameCamelCase = camelCase(fileName);
+        const pluginFullName = `app${fileNameCamelCase.charAt(0).toUpperCase() + fileNameCamelCase.slice(1)}`;
+
+        if (loadedPluginNames.has(pluginFullName)) {
+            continue;
+        }
+
+        try {
+            const plugin = require(file);
+            const pluginInstance = plugin.default;
+            pluginInstance.pluginName = pluginFullName;
+            plugins.push(pluginInstance);
+            loadedPluginNames.add(pluginFullName);
+        } catch (err: any) {
+            Logger.error(`用户插件 ${fileName} 导入失败`, err);
+            process.exit(1);
+        }
+    }
+
+    return plugins;
+}
+
+/**
+ * 初始化单个插件
+ */
+async function initPlugin(befly: { pluginLists: Plugin[]; appContext: BeflyContext }, plugin: Plugin): Promise<void> {
+    befly.pluginLists.push(plugin);
+
+    if (typeof plugin?.onInit === 'function') {
+        befly.appContext[plugin.pluginName] = await plugin?.onInit(befly.appContext);
+    } else {
+        befly.appContext[plugin.pluginName] = {};
+    }
+}
+
+/**
+ * 加载所有插件
+ * @param befly - Befly实例（需要访问 pluginLists 和 appContext）
+ */
+export async function loadPlugins(befly: { pluginLists: Plugin[]; appContext: BeflyContext }): Promise<void> {
+    try {
+        const loadStartTime = Bun.nanoseconds();
+        const loadedPluginNames = new Set<string>();
+
+        // 阶段1：扫描所有插件
+        const corePlugins = await scanCorePlugins(loadedPluginNames);
+        const addonPlugins = await scanAddonPlugins(loadedPluginNames);
+        const userPlugins = await scanUserPlugins(loadedPluginNames);
+
+        // 阶段2：分层排序插件
+        const sortedCorePlugins = sortPlugins(corePlugins);
+        if (sortedCorePlugins === false) {
+            Logger.error('核心插件依赖关系错误，请检查插件的 after 属性');
+            process.exit(1);
+        }
+
+        const sortedAddonPlugins = sortPlugins(addonPlugins);
+        if (sortedAddonPlugins === false) {
+            Logger.error('组件插件依赖关系错误，请检查插件的 after 属性');
+            process.exit(1);
+        }
+
+        const sortedUserPlugins = sortPlugins(userPlugins);
+        if (sortedUserPlugins === false) {
+            Logger.error('用户插件依赖关系错误，请检查插件的 after 属性');
+            process.exit(1);
+        }
+
+        // 阶段3：分层初始化插件（核心 → 组件 → 用户）
+        // 3.1 初始化核心插件
+        for (const plugin of sortedCorePlugins) {
+            try {
+                await initPlugin(befly, plugin);
+            } catch (error: any) {
+                Logger.error(`核心插件 ${plugin.pluginName} 初始化失败`, error);
+                process.exit(1);
+            }
+        }
+
+        // 3.2 初始化组件插件
+        for (const plugin of sortedAddonPlugins) {
+            try {
+                await initPlugin(befly, plugin);
+            } catch (error: any) {
+                Logger.error(`组件插件 ${plugin.pluginName} 初始化失败`, error);
+                process.exit(1);
+            }
+        }
+
+        // 3.3 初始化用户插件
+        for (const plugin of sortedUserPlugins) {
+            try {
+                await initPlugin(befly, plugin);
+            } catch (error: any) {
+                Logger.error(`用户插件 ${plugin.pluginName} 初始化失败`, error);
+                process.exit(1);
+            }
+        }
+
+        const totalLoadTime = calcPerfTime(loadStartTime);
+    } catch (error: any) {
+        Logger.error('加载插件时发生错误', error);
+        process.exit(1);
+    }
+}

package/main.ts

@@ -4,7 +4,7 @@
  */
 
 import { Env } from './env.js';
-import { Yes, No } from './util.js';
+import { Yes, No, keysToSnake, keysToCamel, arrayKeysToCamel, pickFields, fieldClear, calcPerfTime } from './util.js';
 import { Logger } from './lib/logger.js';
 import { Cipher } from './lib/cipher.js';
 import { Jwt } from './lib/jwt.js';
@@ -15,10 +15,9 @@ import { DbHelper } from './lib/dbHelper.js';
 import { RedisHelper } from './lib/redisHelper.js';
 import { Addon } from './lib/addon.js';
 import { checkDefault } from './check.js';
-import * as utilFunctions from './util.js';
 
 import type { Server } from 'bun';
-import type { BeflyContext, BeflyOptions } from './types/befly.js';
+import type { BeflyContext } from './types/befly.js';
 /**
  * Befly 框架核心类
  * 职责：管理应用上下文和生命周期
@@ -30,17 +29,16 @@ export class Befly {
     /** 应用上下文 */
     public appContext: BeflyContext;
 
-    constructor(options: BeflyOptions = {}) {
-        this.lifecycle = new Lifecycle(options);
+    constructor() {
+        this.lifecycle = new Lifecycle();
         this.appContext = {};
     }
 
     /**
      * 启动服务器并注册优雅关闭处理
-     * @param callback - 启动完成后的回调函数
      */
-    async listen(callback?: (server: Server) => void): Promise<Server> {
-        const server = await this.lifecycle.start(this.appContext, callback);
+    async listen(): Promise<Server> {
+        const server = await this.lifecycle.start(this.appContext);
 
         const gracefulShutdown = async (signal: string) => {
             // 1. 停止接收新请求
@@ -85,11 +83,10 @@ export {
 
 // 工具函数命名空间导出
 export const utils = {
-    keysToSnake: utilFunctions.keysToSnake,
-    keysToCamel: utilFunctions.keysToCamel,
-    arrayKeysToCamel: utilFunctions.arrayKeysToCamel,
-    pickFields: utilFunctions.pickFields,
-    fieldClear: utilFunctions.fieldClear,
-    calcPerfTime: utilFunctions.calcPerfTime,
-    parseRule: utilFunctions.parseRule
+    keysToSnake: keysToSnake,
+    keysToCamel: keysToCamel,
+    arrayKeysToCamel: arrayKeysToCamel,
+    pickFields: pickFields,
+    fieldClear: fieldClear,
+    calcPerfTime: calcPerfTime
 };

package/menu.json

@@ -1,22 +1,22 @@
 [
     {
         "name": "首页",
-        "path": "/",
-        "icon": "Home",
+        "path": "/internal/index",
+        "icon": "",
         "sort": 1,
         "type": 1
     },
     {
         "name": "人员管理",
-        "path": "/internal/people",
-        "icon": "UserCircle",
+        "path": "_people",
+        "icon": "",
         "sort": 2,
         "type": 1,
         "children": [
             {
                 "name": "管理员管理",
-                "path": "/admin",
-                "icon": "Users",
+                "path": "/internal/admin",
+                "icon": "",
                 "sort": 2,
                 "type": 1
             }
@@ -24,22 +24,22 @@
     },
     {
         "name": "权限设置",
-        "path": "/internal/settings",
-        "icon": "Settings",
+        "path": "_permission",
+        "icon": "",
         "sort": 3,
         "type": 1,
         "children": [
             {
                 "name": "菜单管理",
-                "path": "/menu",
-                "icon": "Menu",
+                "path": "/internal/menu",
+                "icon": "",
                 "sort": 4,
                 "type": 1
             },
             {
                 "name": "角色管理",
-                "path": "/role",
-                "icon": "Users",
+                "path": "/internal/role",
+                "icon": "",
                 "sort": 5,
                 "type": 1
             }
@@ -48,7 +48,7 @@
     {
         "name": "字典管理",
         "path": "/internal/dict",
-        "icon": "BookOpen",
+        "icon": "",
         "sort": 6,
         "type": 1
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.1",
+    "version": "3.8.2",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -69,5 +69,5 @@
         "es-toolkit": "^1.41.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "da3ca0f3da53574d9b1053ad5cb2247acc11d384"
+    "gitHead": "c0844203f8fee734d2a8742f3b77b67bf0874681"
 }

package/plugins/cache.ts

@@ -3,168 +3,9 @@
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
-import { Logger } from '../lib/logger.js';
+import { CacheHelper } from '../lib/cacheHelper.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');
-    }
-}
 
 /**
  * 缓存插件
@@ -173,13 +14,8 @@ const cachePlugin: Plugin = {
     name: '_cache',
     after: ['_db', '_redis'],
 
-    async onInit(befly: BeflyContext): Promise<CacheManager> {
-        try {
-            const cacheManager = new CacheManager(befly);
-            return cacheManager;
-        } catch (error: any) {
-            throw error;
-        }
+    async onInit(befly: BeflyContext): Promise<CacheHelper> {
+        return new CacheHelper(befly);
     }
 };
 

package/types/common.d.ts

@@ -21,9 +21,33 @@ export interface ValidationResult {
 }
 
 /**
- * 字段规则字符串
+ * 字段定义类型（对象格式）
+ */
+export interface FieldDefinition {
+    name: string; // 字段标签/描述
+    detail: string; // 字段详细说明
+    type: 'string' | 'number' | 'text' | 'array_string' | 'array_text';
+    min: number | null; // 最小值/最小长度
+    max: number | null; // 最大值/最大长度
+    default: any; // 默认值
+    index: boolean; // 是否创建索引
+    unique: boolean; // 是否唯一
+    comment: string; // 字段注释
+    nullable: boolean; // 是否允许为空
+    unsigned: boolean; // 是否无符号（仅number类型）
+    regexp: string | null; // 正则验证
+}
+
+/**
+ * 表定义类型（对象格式）
+ */
+export type TableDefinition = Record<string, FieldDefinition>;
+
+/**
+ * 字段规则字符串（已废弃，保留用于兼容）
  * 格式: "字段名|类型|最小值|最大值|默认值|是否索引|正则约束"
  *
+ * @deprecated 请使用 FieldDefinition 对象格式
  * @example
  * "用户名|string|2|50|null|1|^[a-zA-Z0-9_]+$"
  * "年龄|number|0|150|18|0|null"
@@ -31,12 +55,9 @@ export interface ValidationResult {
 export type FieldRule = string;
 
 /**
- * 表定义类型
- */
-export type TableDefinition = Record<string, FieldRule>;
-
-/**
- * 解析后的字段规则
+ * 解析后的字段规则（已废弃，保留用于兼容）
+ *
+ * @deprecated 请使用 FieldDefinition 对象格式
  */
 export interface ParsedFieldRule {
     name: string; // 字段名称

package/util.ts

@@ -9,7 +9,6 @@ import { projectDir } from './paths.js';
 import type { KeyValue } from './types/common.js';
 import type { JwtPayload, JwtSignOptions, JwtVerifyOptions } from './types/jwt';
 import type { Plugin } from './types/plugin.js';
-import type { ParsedFieldRule } from './types/common.js';
 
 // ========================================
 // API 响应工具
@@ -39,6 +38,10 @@ export const No = <T = any>(msg: string = '', data: T | {} = {}, other: KeyValue
     };
 };
 
+// ========================================
+// 动态导入工具
+// ========================================
+
 // ========================================
 // 字段转换工具（重新导出 lib/convert.ts）
 // ========================================
@@ -168,50 +171,3 @@ export const calcPerfTime = (startTime: number, endTime: number = Bun.nanosecond
         return `${elapsedSeconds.toFixed(2)} 秒`;
     }
 };
-
-// ========================================
-// 表定义工具
-// ========================================
-
-/**
- * 解析字段规则字符串
- * 格式："字段名|类型|最小值|最大值|默认值|必填|正则"
- * 注意：只分割前6个|，第7个|之后的所有内容（包括|）都属于正则表达式
- */
-export const parseRule = (rule: string): ParsedFieldRule => {
-    const parts: string[] = [];
-    let currentPart = '';
-    let pipeCount = 0;
-
-    for (let i = 0; i < rule.length; i++) {
-        if (rule[i] === '|' && pipeCount < 6) {
-            parts.push(currentPart);
-            currentPart = '';
-            pipeCount++;
-        } else {
-            currentPart += rule[i];
-        }
-    }
-    parts.push(currentPart);
-
-    const [fieldName = '', fieldType = 'string', fieldMinStr = 'null', fieldMaxStr = 'null', fieldDefaultStr = 'null', fieldIndexStr = '0', fieldRegx = 'null'] = parts;
-
-    const fieldIndex = Number(fieldIndexStr) as 0 | 1;
-    const fieldMin = fieldMinStr !== 'null' ? Number(fieldMinStr) : null;
-    const fieldMax = fieldMaxStr !== 'null' ? Number(fieldMaxStr) : null;
-
-    let fieldDefault: any = fieldDefaultStr;
-    if (fieldType === 'number' && fieldDefaultStr !== 'null') {
-        fieldDefault = Number(fieldDefaultStr);
-    }
-
-    return {
-        name: fieldName,
-        type: fieldType as 'string' | 'number' | 'text' | 'array_string' | 'array_text',
-        min: fieldMin,
-        max: fieldMax,
-        default: fieldDefault,
-        index: fieldIndex,
-        regex: fieldRegx !== 'null' ? fieldRegx : null
-    };
-};