befly 1.0.3 → 1.1.0

package/README.md

@@ -1,3 +1,3 @@
-# BunPii
+# Befly
 
 自用框架，请勿使用。

package/main.js

@@ -10,7 +10,7 @@ import { Crypto2 } from './utils/crypto.js';
 import { XMLParser } from './libs/xml/XMLParser.js';
 import { isEmptyObject, isType, pickFields, sortPlugins, RYes, RNo, filename2, dirname2 } from './utils/util.js';
 
-class BunPii {
+class Befly {
     constructor(options = {}) {
         this.apiRoutes = new Map();
         this.pluginLists = [];
@@ -20,6 +20,9 @@ class BunPii {
 
     async initCheck() {
         try {
+            const checkStartTime = Bun.nanoseconds();
+            Logger.info('开始执行系统检查...');
+
             const checksDir = path.join(dirname2(import.meta.url), 'checks');
             const glob = new Bun.Glob('*.js');
 
@@ -39,6 +42,7 @@ class BunPii {
 
                 try {
                     totalChecks++;
+                    const singleCheckStart = Bun.nanoseconds();
 
                     // 导入检查模块
                     const check = await import(file);
@@ -46,19 +50,24 @@ class BunPii {
                     // 执行默认导出的函数
                     if (typeof check.default === 'function') {
                         const checkResult = await check.default(this.appContext);
+                        const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
+
                         if (checkResult === true) {
                             passedChecks++;
+                            Logger.info(`检查 ${fileName} 通过，耗时: ${singleCheckTime.toFixed(2)}ms`);
                         } else {
-                            Logger.error(`检查未通过: ${fileName}`);
+                            Logger.error(`检查未通过: ${fileName}，耗时: ${singleCheckTime.toFixed(2)}ms`);
                             failedChecks++;
                         }
                     } else {
-                        Logger.warn(`文件 ${fileName} 未导出默认函数`);
+                        const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
+                        Logger.warn(`文件 ${fileName} 未导出默认函数，耗时: ${singleCheckTime.toFixed(2)}ms`);
                         failedChecks++;
                     }
                 } catch (error) {
+                    const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
                     Logger.error({
-                        msg: `检查失败 ${fileName}`,
+                        msg: `检查失败 ${fileName}，耗时: ${singleCheckTime.toFixed(2)}ms`,
                         error: error.message,
                         stack: error.stack
                     });
@@ -66,8 +75,10 @@ class BunPii {
                 }
             }
 
+            const totalCheckTime = (Bun.nanoseconds() - checkStartTime) / 1_000_000;
+
             // 输出检查结果统计
-            Logger.info(`总检查数: ${totalChecks}, 通过: ${passedChecks}, 失败: ${failedChecks}`);
+            Logger.info(`系统检查完成! 总耗时: ${totalCheckTime.toFixed(2)}ms，总检查数: ${totalChecks}, 通过: ${passedChecks}, 失败: ${failedChecks}`);
 
             if (failedChecks > 0) {
                 process.exit();
@@ -78,7 +89,7 @@ class BunPii {
             }
         } catch (error) {
             Logger.error({
-                msg: '加载接口时发生错误',
+                msg: '执行系统检查时发生错误',
                 error: error.message,
                 stack: error.stack
             });
@@ -88,12 +99,17 @@ class BunPii {
 
     async loadPlugins() {
         try {
+            const loadStartTime = Bun.nanoseconds();
+            Logger.info('开始加载插件...');
+
             const glob = new Bun.Glob('*.js');
             const corePlugins = [];
             const userPlugins = [];
             const loadedPluginNames = new Set(); // 用于跟踪已加载的插件名称
 
-            // 扫描指定目录
+            // 扫描核心插件目录
+            Logger.info('正在扫描核心插件...');
+            const corePluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
                 cwd: path.join(dirname2(import.meta.url), 'plugins'),
                 onlyFiles: true,
@@ -101,12 +117,20 @@ class BunPii {
             })) {
                 const fileName = path.basename(file, '.js');
                 if (fileName.startsWith('_')) continue;
+
+                const importStart = Bun.nanoseconds();
                 const plugin = await import(file);
+                const importTime = (Bun.nanoseconds() - importStart) / 1_000_000; // 转换为毫秒
+
                 const pluginInstance = plugin.default;
                 pluginInstance.pluginName = fileName;
                 corePlugins.push(pluginInstance);
                 loadedPluginNames.add(fileName); // 记录已加载的核心插件名称
+
+                Logger.info(`核心插件 ${fileName} 导入耗时: ${importTime.toFixed(2)}ms`);
             }
+            const corePluginsScanTime = (Bun.nanoseconds() - corePluginsScanStart) / 1_000_000;
+            Logger.info(`核心插件扫描完成，耗时: ${corePluginsScanTime.toFixed(2)}ms，共找到 ${corePlugins.length} 个插件`);
 
             const sortedCorePlugins = sortPlugins(corePlugins);
             if (sortedCorePlugins === false) {
@@ -114,16 +138,26 @@ class BunPii {
                 process.exit();
             }
 
+            // 初始化核心插件
+            Logger.info('正在初始化核心插件...');
+            const corePluginsInitStart = Bun.nanoseconds();
             for (const plugin of sortedCorePlugins) {
                 try {
+                    const initStart = Bun.nanoseconds();
                     this.pluginLists.push(plugin);
                     this.appContext[plugin.pluginName] = typeof plugin?.onInit === 'function' ? await plugin?.onInit(this.appContext) : {};
+                    const initTime = (Bun.nanoseconds() - initStart) / 1_000_000;
+                    Logger.info(`核心插件 ${plugin.pluginName} 初始化耗时: ${initTime.toFixed(2)}ms`);
                 } catch (error) {
                     Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
                 }
             }
+            const corePluginsInitTime = (Bun.nanoseconds() - corePluginsInitStart) / 1_000_000;
+            Logger.info(`核心插件初始化完成，耗时: ${corePluginsInitTime.toFixed(2)}ms`);
 
-            // 扫描指定目录
+            // 扫描用户插件目录
+            Logger.info('正在扫描用户插件...');
+            const userPluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
                 cwd: path.join(process.cwd(), 'plugins'),
                 onlyFiles: true,
@@ -138,11 +172,18 @@ class BunPii {
                     continue;
                 }
 
+                const importStart = Bun.nanoseconds();
                 const plugin = await import(file);
+                const importTime = (Bun.nanoseconds() - importStart) / 1_000_000; // 转换为毫秒
+
                 const pluginInstance = plugin.default;
                 pluginInstance.pluginName = fileName;
                 userPlugins.push(pluginInstance);
+
+                Logger.info(`用户插件 ${fileName} 导入耗时: ${importTime.toFixed(2)}ms`);
             }
+            const userPluginsScanTime = (Bun.nanoseconds() - userPluginsScanStart) / 1_000_000;
+            Logger.info(`用户插件扫描完成，耗时: ${userPluginsScanTime.toFixed(2)}ms，共找到 ${userPlugins.length} 个插件`);
 
             const sortedUserPlugins = sortPlugins(userPlugins);
             if (sortedUserPlugins === false) {
@@ -150,14 +191,28 @@ class BunPii {
                 process.exit();
             }
 
-            for (const plugin of sortedUserPlugins) {
-                try {
-                    this.pluginLists.push(plugin);
-                    this.appContext[plugin.pluginName] = typeof plugin?.onInit === 'function' ? await plugin?.onInit(this.appContext) : {};
-                } catch (error) {
-                    Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
+            // 初始化用户插件
+            if (userPlugins.length > 0) {
+                Logger.info('正在初始化用户插件...');
+                const userPluginsInitStart = Bun.nanoseconds();
+                for (const plugin of sortedUserPlugins) {
+                    try {
+                        const initStart = Bun.nanoseconds();
+                        this.pluginLists.push(plugin);
+                        this.appContext[plugin.pluginName] = typeof plugin?.onInit === 'function' ? await plugin?.onInit(this.appContext) : {};
+                        const initTime = (Bun.nanoseconds() - initStart) / 1_000_000;
+                        Logger.info(`用户插件 ${plugin.pluginName} 初始化耗时: ${initTime.toFixed(2)}ms`);
+                    } catch (error) {
+                        Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
+                    }
                 }
+                const userPluginsInitTime = (Bun.nanoseconds() - userPluginsInitStart) / 1_000_000;
+                Logger.info(`用户插件初始化完成，耗时: ${userPluginsInitTime.toFixed(2)}ms`);
             }
+
+            const totalLoadTime = (Bun.nanoseconds() - loadStartTime) / 1_000_000;
+            const totalPluginCount = sortedCorePlugins.length + sortedUserPlugins.length;
+            Logger.info(`插件加载完成! 总耗时: ${totalLoadTime.toFixed(2)}ms，共加载 ${totalPluginCount} 个插件`);
         } catch (error) {
             Logger.error({
                 msg: '加载插件时发生错误',
@@ -168,10 +223,19 @@ class BunPii {
     }
     async loadApis(dirName) {
         try {
+            const loadStartTime = Bun.nanoseconds();
+            const dirDisplayName = dirName === 'core' ? '核心' : '用户';
+            Logger.info(`开始加载${dirDisplayName}接口...`);
+
             const coreApisDir = path.join(dirname2(import.meta.url), 'apis');
             const userApisDir = path.join(process.cwd(), 'apis');
             const glob = new Bun.Glob('**/*.js');
             const apiDir = dirName === 'core' ? coreApisDir : userApisDir;
+
+            let totalApis = 0;
+            let loadedApis = 0;
+            let failedApis = 0;
+
             // 扫描指定目录
             for await (const file of glob.scan({
                 cwd: apiDir,
@@ -181,29 +245,50 @@ class BunPii {
                 const fileName = path.basename(file, '.js');
                 const apiPath = path.relative(apiDir, file).replace(/\.js$/, '').replace(/\\/g, '/');
                 if (apiPath.indexOf('_') !== -1) continue;
-                const api = (await import(file)).default;
-                if (isType(api.name, 'string') === false || api.name.trim() === '') {
-                    throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
-                }
-                if (api.auth !== false && api.auth !== true && Array.isArray(api.auth) === false) {
-                    throw new Error(`接口 ${apiPath} 的 auth 属性必须是布尔值或字符串数组`);
-                }
-                if (isType(api.fields, 'object') === false) {
-                    throw new Error(`接口 ${apiPath} 的 fields 属性必须是对象`);
-                }
-                if (isType(api.required, 'array') === false) {
-                    throw new Error(`接口 ${apiPath} 的 required 属性必须是数组`);
-                }
-                // 数组的每一项都必须是字符串
-                if (api.required.some((item) => isType(item, 'string') === false)) {
-                    throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
-                }
-                if (isType(api.handler, 'function') === false) {
-                    throw new Error(`接口 ${apiPath} 的 handler 属性必须是函数`);
+
+                totalApis++;
+                const singleApiStart = Bun.nanoseconds();
+
+                try {
+                    const api = (await import(file)).default;
+                    if (isType(api.name, 'string') === false || api.name.trim() === '') {
+                        throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
+                    }
+                    if (api.auth !== false && api.auth !== true && Array.isArray(api.auth) === false) {
+                        throw new Error(`接口 ${apiPath} 的 auth 属性必须是布尔值或字符串数组`);
+                    }
+                    if (isType(api.fields, 'object') === false) {
+                        throw new Error(`接口 ${apiPath} 的 fields 属性必须是对象`);
+                    }
+                    if (isType(api.required, 'array') === false) {
+                        throw new Error(`接口 ${apiPath} 的 required 属性必须是数组`);
+                    }
+                    // 数组的每一项都必须是字符串
+                    if (api.required.some((item) => isType(item, 'string') === false)) {
+                        throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
+                    }
+                    if (isType(api.handler, 'function') === false) {
+                        throw new Error(`接口 ${apiPath} 的 handler 属性必须是函数`);
+                    }
+                    api.route = `${api.method.toUpperCase()}/api/${dirName}/${apiPath}`;
+                    this.apiRoutes.set(api.route, api);
+
+                    const singleApiTime = (Bun.nanoseconds() - singleApiStart) / 1_000_000;
+                    loadedApis++;
+                    // Logger.info(`${dirDisplayName}接口 ${apiPath} 加载成功，耗时: ${singleApiTime.toFixed(2)}ms`);
+                } catch (error) {
+                    const singleApiTime = (Bun.nanoseconds() - singleApiStart) / 1_000_000;
+                    failedApis++;
+                    Logger.error({
+                        msg: `${dirDisplayName}接口 ${apiPath} 加载失败，耗时: ${singleApiTime.toFixed(2)}ms`,
+                        error: error.message,
+                        stack: error.stack
+                    });
                 }
-                api.route = `${api.method.toUpperCase()}/api/${dirName}/${apiPath}`;
-                this.apiRoutes.set(api.route, api);
             }
+
+            const totalLoadTime = (Bun.nanoseconds() - loadStartTime) / 1_000_000;
+            Logger.info(`${dirDisplayName}接口加载完成! 总耗时: ${totalLoadTime.toFixed(2)}ms，总数: ${totalApis}, 成功: ${loadedApis}, 失败: ${failedApis}`);
         } catch (error) {
             Logger.error({
                 msg: '加载接口时发生错误',
@@ -217,11 +302,17 @@ class BunPii {
      * 启动服务器
      */
     async listen(callback) {
+        const serverStartTime = Bun.nanoseconds();
+        Logger.info('开始启动 Befly 服务器...');
+
         await this.initCheck();
         await this.loadPlugins();
         await this.loadApis('core');
         await this.loadApis('app');
 
+        const totalStartupTime = (Bun.nanoseconds() - serverStartTime) / 1_000_000;
+        Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime.toFixed(2)}ms`);
+
         const server = Bun.serve({
             port: Env.APP_PORT,
             hostname: Env.APP_HOST,
@@ -229,7 +320,7 @@ class BunPii {
                 '/': async (req) => {
                     return Response.json({
                         code: 0,
-                        msg: 'BunPii 接口服务已启动',
+                        msg: 'Befly 接口服务已启动',
                         data: {
                             mode: Env.NODE_ENV
                         }
@@ -327,7 +418,7 @@ class BunPii {
                         }
 
                         // 请求记录
-                        Logger.debug({
+                        Logger.info({
                             msg: '通用接口日志',
                             请求路径: apiPath,
                             请求方法: req.method,
@@ -400,10 +491,14 @@ class BunPii {
             }
         });
 
+        const finalStartupTime = (Bun.nanoseconds() - serverStartTime) / 1_000_000;
+        Logger.info(`🚀 Befly 服务器启动成功! 完整启动耗时: ${finalStartupTime.toFixed(2)}ms`);
+        Logger.info(`📡 服务器监听地址: http://${Env.APP_HOST}:${Env.APP_PORT}`);
+
         if (callback && typeof callback === 'function') {
             callback(server);
         }
     }
 }
 
-export { BunPii, Env, Api, Jwt, Crypto2, Logger, RYes, RNo };
+export { Befly, Env, Api, Jwt, Crypto2, Logger, RYes, RNo };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "1.0.3",
+    "version": "1.1.0",
     "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -49,5 +49,5 @@
         "README.md",
         "vitest.config.js"
     ],
-    "gitHead": "3bd2e1f01b94f2b576467db1b63a016b6717dbbe"
+    "gitHead": "c86df1d32fd5321912fed97a1bf7c1348ce9c730"
 }