befly 3.8.2 → 3.8.4

package/lifecycle/checker.ts

@@ -1,122 +0,0 @@
-/**
- * 系统检查管理器
- * 负责在框架启动前执行系统检查
- */
-
-import { join, basename } from 'pathe';
-import { existsSync, statSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { calcPerfTime } from '../util.js';
-import { projectCheckDir } from '../paths.js';
-import { checkDefault } from '../check.js';
-import { Addon } from '../lib/addon.js';
-
-/**
- * 系统检查器类
- */
-export class Checker {
-    /**
-     * 执行所有系统检查
-     */
-    static async run(): Promise<void> {
-        try {
-            const checkStartTime = Bun.nanoseconds();
-
-            // 先执行默认检查（有异常会自动抛出）
-            await checkDefault();
-
-            const glob = new Bun.Glob('*.{ts}');
-
-            // 统计信息
-            const stats = {
-                totalChecks: 0,
-                passedChecks: 0,
-                failedChecks: 0
-            };
-
-            // 检查目录列表：先项目，后 addons
-            const checkDirs: Array<{ path: string; type: 'app' | 'addon'; addonName?: string }> = [];
-
-            // 添加项目 checks 目录（如果存在）
-            if (existsSync(projectCheckDir) && statSync(projectCheckDir).isDirectory()) {
-                checkDirs.push({ path: projectCheckDir, type: 'app' });
-            }
-
-            // 添加所有 addon 的 checks 目录
-            const addons = Addon.scan();
-            for (const addon of addons) {
-                if (Addon.dirExists(addon, 'checks')) {
-                    checkDirs.push({
-                        path: Addon.getDir(addon, 'checks'),
-                        type: 'addon',
-                        addonName: addon
-                    });
-                }
-            }
-
-            // 按顺序扫描并执行检查函数
-            for (const checkConfig of checkDirs) {
-                const { path: checkDir, type: type } = checkConfig;
-                const addonName = 'addonName' in checkConfig ? checkConfig.addonName : undefined;
-                const checkTypeLabel = type === 'app' ? '项目' : `组件${addonName}`;
-
-                for await (const file of glob.scan({
-                    cwd: checkDir,
-                    onlyFiles: true,
-                    absolute: true
-                })) {
-                    const fileName = basename(file);
-                    if (fileName.startsWith('_')) continue; // 跳过以下划线开头的文件
-
-                    try {
-                        stats.totalChecks++;
-                        const singleCheckStart = Bun.nanoseconds();
-
-                        // 导入检查模块
-                        const checkModule = await import(file);
-
-                        // 获取 default 导出的检查函数
-                        const checkFn = checkModule.default;
-
-                        // 执行检查函数
-                        if (typeof checkFn === 'function') {
-                            const checkResult = await checkFn();
-                            const singleCheckTime = calcPerfTime(singleCheckStart);
-
-                            // 检查返回值是否为 boolean
-                            if (typeof checkResult !== 'boolean') {
-                                Logger.warn(`${checkTypeLabel}检查 ${fileName} 返回值必须为 true 或 false，当前为 ${typeof checkResult}`);
-                                stats.failedChecks++;
-                            } else if (checkResult === true) {
-                                stats.passedChecks++;
-                            } else {
-                                Logger.warn(`${checkTypeLabel}检查未通过: ${fileName}`);
-                                stats.failedChecks++;
-                            }
-                        } else {
-                            Logger.warn(`${checkTypeLabel}检查文件 ${fileName} 未找到 default 导出的检查函数`);
-                            stats.failedChecks++;
-                        }
-                    } catch (error: any) {
-                        const singleCheckTime = calcPerfTime(Bun.nanoseconds());
-                        Logger.error(`${checkTypeLabel}检查失败 ${fileName}，耗时: ${singleCheckTime}`, error);
-                        stats.failedChecks++;
-                    }
-                }
-            }
-
-            const totalCheckTime = calcPerfTime(checkStartTime);
-
-            // 输出检查结果统计
-            if (stats.failedChecks > 0) {
-                Logger.error(`系统检查失败: ${stats.failedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
-                process.exit(1);
-            } else if (stats.totalChecks > 0) {
-                Logger.info(`系统检查通过: ${stats.passedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
-            }
-        } catch (error: any) {
-            Logger.error('执行系统检查时发生错误', error);
-            process.exit(1);
-        }
-    }
-}

package/lifecycle/lifecycle.ts

@@ -1,61 +0,0 @@
-/**
- * 生命周期管理器
- * 统一管理框架的启动流程：检查、加载插件、加载API、启动服务器
- */
-
-import { Logger } from '../lib/logger.js';
-import { Database } from '../lib/database.js';
-import { loadPlugins } from './loadPlugins.js';
-import { loadApis } from './loadApis.js';
-import { Checker } from './checker.js';
-import { Env } from '../env.js';
-import { calcPerfTime } from '../util.js';
-import { Addon } from '../lib/addon.js';
-import { Bootstrap } from './bootstrap.js';
-
-import type { Server } from 'bun';
-import type { Plugin } from '../types/plugin.js';
-import type { ApiRoute } from '../types/api.js';
-import type { BeflyContext } from '../types/befly.js';
-
-/**
- * 生命周期管理类
- */
-export class Lifecycle {
-    /** API 路由映射表 */
-    private apiRoutes: Map<string, ApiRoute> = new Map();
-
-    /** 插件列表 */
-    private pluginLists: Plugin[] = [];
-
-    constructor() {}
-
-    /**
-     * 启动完整的生命周期流程
-     * @param appContext - 应用上下文
-     */
-    async start(appContext: BeflyContext): Promise<Server> {
-        const serverStartTime = Bun.nanoseconds();
-
-        // 1. 执行系统检查
-        await Checker.run();
-
-        // 2. 加载插件
-        await loadPlugins({
-            pluginLists: this.pluginLists,
-            appContext: appContext
-        });
-
-        // // 3. 加载所有 API
-        await loadApis(this.apiRoutes);
-
-        // 4. 启动 HTTP 服务器
-        const totalStartupTime = calcPerfTime(serverStartTime);
-
-        return await Bootstrap.start({
-            apiRoutes: this.apiRoutes,
-            pluginLists: this.pluginLists,
-            appContext: appContext
-        });
-    }
-}

package/lifecycle/loadApis.ts

@@ -1,164 +0,0 @@
-/**
- * API 加载器
- * 负责扫描和加载所有 API 路由（核心、组件、用户）
- */
-
-import { relative, basename } from 'pathe';
-import { existsSync } from 'node:fs';
-import { isPlainObject } from 'es-toolkit/compat';
-import { Logger } from '../lib/logger.js';
-import { calcPerfTime } from '../util.js';
-import { coreApiDir, projectApiDir } from '../paths.js';
-import { Addon } from '../lib/addon.js';
-import type { ApiRoute } from '../types/api.js';
-
-/**
- * API 默认字段定义
- * 这些字段会自动合并到所有 API 的 fields 中
- * API 自定义的同名字段可以覆盖这些默认值
- */
-const DEFAULT_API_FIELDS = {
-    id: {
-        name: 'ID',
-        type: 'number',
-        min: 1,
-        max: null
-    },
-    page: {
-        name: '页码',
-        type: 'number',
-        min: 1,
-        max: 9999
-    },
-    limit: {
-        name: '每页数量',
-        type: 'number',
-        min: 1,
-        max: 100
-    },
-    keyword: {
-        name: '关键词',
-        type: 'string',
-        min: 1,
-        max: 50
-    },
-    state: {
-        name: '状态',
-        type: 'number',
-        min: 0,
-        max: 2
-    }
-} as const;
-
-/**
- * 扫描单个目录的 API 文件
- * @param apiDir - API 目录路径
- * @param apiRoutes - API 路由映射表
- * @param routePrefix - 路由前缀（如 'core', 'addon/admin', ''）
- * @param displayName - 显示名称（用于日志）
- */
-async function scanApisFromDir(apiDir: string, apiRoutes: Map<string, ApiRoute>, routePrefix: string, displayName: string): Promise<void> {
-    if (!existsSync(apiDir)) {
-        return;
-    }
-
-    const glob = new Bun.Glob('**/*.ts');
-
-    for await (const file of glob.scan({
-        cwd: apiDir,
-        onlyFiles: true,
-        absolute: true
-    })) {
-        const fileName = basename(file).replace(/\.ts$/, '');
-        const apiPath = relative(apiDir, file).replace(/\.ts$/, '');
-        if (apiPath.indexOf('_') !== -1) continue;
-
-        try {
-            const apiImport = await import(file);
-            const api = apiImport.default;
-            // 验证必填属性：name 和 handler
-            if (typeof api.name !== 'string' || api.name.trim() === '') {
-                throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
-            }
-            if (typeof api.handler !== 'function') {
-                throw new Error(`接口 ${apiPath} 的 handler 属性必须是函数`);
-            }
-            // 设置默认值
-            api.method = api.method || 'POST';
-            api.auth = api.auth !== undefined ? api.auth : true;
-            // 合并默认字段：先设置自定义字段，再用默认字段覆盖（默认字段优先级更高）
-            api.fields = { ...(api.fields || {}), ...DEFAULT_API_FIELDS };
-            api.required = api.required || [];
-            // 验证可选属性的类型（如果提供了）
-            if (api.method && !['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(api.method.toUpperCase())) {
-                throw new Error(`接口 ${apiPath} 的 method 属性必须是有效的 HTTP 方法`);
-            }
-            if (api.auth !== undefined && typeof api.auth !== 'boolean') {
-                throw new Error(`接口 ${apiPath} 的 auth 属性必须是布尔值 (true=需登录, false=公开)`);
-            }
-            if (api.fields && !isPlainObject(api.fields)) {
-                throw new Error(`接口 ${apiPath} 的 fields 属性必须是对象`);
-            }
-            if (api.required && !Array.isArray(api.required)) {
-                throw new Error(`接口 ${apiPath} 的 required 属性必须是数组`);
-            }
-            if (api.required && api.required.some((item: any) => typeof item !== 'string')) {
-                throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
-            }
-            // 构建路由
-            api.route = `${api.method.toUpperCase()}/api/${routePrefix ? routePrefix + '/' : ''}${apiPath}`;
-            apiRoutes.set(api.route, api);
-        } catch (error: any) {
-            Logger.error(`[${displayName}] 接口 ${apiPath} 加载失败`, error);
-            process.exit(1);
-        }
-    }
-}
-
-/**
- * 扫描核心 APIs
- */
-async function scanCoreApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
-    await scanApisFromDir(coreApiDir, apiRoutes, 'core', '核心');
-}
-
-/**
- * 扫描组件 APIs
- */
-async function scanAddonApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
-    const addons = Addon.scan();
-
-    for (const addon of addons) {
-        if (!Addon.dirExists(addon, 'apis')) continue;
-
-        const addonApiDir = Addon.getDir(addon, 'apis');
-        await scanApisFromDir(addonApiDir, apiRoutes, `addon/${addon}`, `组件${addon}`);
-    }
-}
-
-/**
- * 扫描用户 APIs
- */
-async function scanUserApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
-    await scanApisFromDir(projectApiDir, apiRoutes, '', '用户');
-}
-
-/**
- * 加载所有 API 路由
- * @param apiRoutes - API 路由映射表
- */
-export async function loadApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
-    try {
-        const loadStartTime = Bun.nanoseconds();
-
-        // 扫描所有 APIs
-        await scanCoreApis(apiRoutes);
-        await scanAddonApis(apiRoutes);
-        await scanUserApis(apiRoutes);
-
-        const totalLoadTime = calcPerfTime(loadStartTime);
-    } catch (error: any) {
-        Logger.error('加载 API 时发生错误', error);
-        process.exit(1);
-    }
-}

package/menu.json

@@ -1,55 +0,0 @@
-[
-    {
-        "name": "首页",
-        "path": "/internal/index",
-        "icon": "",
-        "sort": 1,
-        "type": 1
-    },
-    {
-        "name": "人员管理",
-        "path": "_people",
-        "icon": "",
-        "sort": 2,
-        "type": 1,
-        "children": [
-            {
-                "name": "管理员管理",
-                "path": "/internal/admin",
-                "icon": "",
-                "sort": 2,
-                "type": 1
-            }
-        ]
-    },
-    {
-        "name": "权限设置",
-        "path": "_permission",
-        "icon": "",
-        "sort": 3,
-        "type": 1,
-        "children": [
-            {
-                "name": "菜单管理",
-                "path": "/internal/menu",
-                "icon": "",
-                "sort": 4,
-                "type": 1
-            },
-            {
-                "name": "角色管理",
-                "path": "/internal/role",
-                "icon": "",
-                "sort": 5,
-                "type": 1
-            }
-        ]
-    },
-    {
-        "name": "字典管理",
-        "path": "/internal/dict",
-        "icon": "",
-        "sort": 6,
-        "type": 1
-    }
-]

package/plugins/cache.ts

@@ -1,22 +0,0 @@
-/**
- * 缓存插件 - TypeScript 版本
- * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
- */
-
-import { CacheHelper } from '../lib/cacheHelper.js';
-import type { Plugin } from '../types/plugin.js';
-import type { BeflyContext } from '../types/befly.js';
-
-/**
- * 缓存插件
- */
-const cachePlugin: Plugin = {
-    name: '_cache',
-    after: ['_db', '_redis'],
-
-    async onInit(befly: BeflyContext): Promise<CacheHelper> {
-        return new CacheHelper(befly);
-    }
-};
-
-export default cachePlugin;

package/plugins/db.ts

@@ -1,59 +0,0 @@
-/**
- * 数据库插件 - TypeScript 版本
- * 初始化数据库连接和 SQL 管理器
- */
-
-import { Env } from '../env.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';
-
-/**
- * 数据库插件
- */
-const dbPlugin: Plugin = {
-    name: '_db',
-    after: ['_redis'],
-
-    async onInit(befly: BeflyContext): Promise<DbHelper | Record<string, never>> {
-        let sql: any = null;
-
-        try {
-            if (Env.DB_ENABLE === 1) {
-                // 创建 Bun SQL 客户端（内置连接池），并确保连接验证成功后再继续
-                // 从环境变量读取连接超时配置
-                const connectionTimeout = Env.DB_CONNECTION_TIMEOUT ? parseInt(Env.DB_CONNECTION_TIMEOUT) : 30000;
-
-                sql = await Database.connectSql({
-                    connectionTimeout
-                });
-
-                // 创建数据库管理器实例，直接传入 sql 对象
-                const dbManager = new DbHelper(befly, sql);
-
-                return dbManager;
-            } else {
-                Logger.warn('数据库未启用（DB_ENABLE≠1），跳过初始化');
-                return {};
-            }
-        } catch (error: any) {
-            Logger.error('数据库初始化失败', error);
-
-            // 清理资源
-            if (sql) {
-                try {
-                    await sql.close();
-                } catch (cleanupError: any) {
-                    Logger.error('清理连接池失败:', cleanupError);
-                }
-            }
-
-            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
-            throw error;
-        }
-    }
-};
-
-export default dbPlugin;

package/plugins/logger.ts

@@ -1,27 +0,0 @@
-/**
- * 日志插件 - TypeScript 版本
- * 提供全局日志功能
- */
-
-import { Logger } from '../lib/logger.js';
-import type { Plugin } from '../types/plugin.js';
-import type { BeflyContext } from '../types/befly.js';
-
-/**
- * 日志插件
- */
-const loggerPlugin: Plugin = {
-    name: '_logger',
-    after: [],
-
-    async onInit(befly: BeflyContext): Promise<typeof Logger> {
-        try {
-            return Logger;
-        } catch (error: any) {
-            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
-            throw error;
-        }
-    }
-};
-
-export default loggerPlugin;

package/plugins/redis.ts

@@ -1,41 +0,0 @@
-/**
- * Redis 插件 - TypeScript 版本
- * 初始化 Redis 连接和助手工具
- */
-
-import { Env } from '../env.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';
-
-/**
- * Redis 插件
- */
-const redisPlugin: Plugin = {
-    name: '_redis',
-    after: ['_logger'],
-
-    async onInit(befly: BeflyContext): Promise<typeof RedisHelper | Record<string, never>> {
-        try {
-            if (Env.REDIS_ENABLE === 1) {
-                // 初始化 Redis 客户端（统一使用 database.ts 的连接管理）
-                await Database.connectRedis();
-
-                // 返回工具对象，向下游以相同 API 暴露
-                return RedisHelper;
-            } else {
-                Logger.warn('Redis 未启用，跳过初始化');
-                return {};
-            }
-        } catch (error: any) {
-            Logger.error('Redis 初始化失败', error);
-
-            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
-            throw error;
-        }
-    }
-};
-
-export default redisPlugin;