befly 1.0.3 → 1.1.1

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,15 @@ class BunPii {
 
     async loadPlugins() {
         try {
+            const loadStartTime = Bun.nanoseconds();
+
             const glob = new Bun.Glob('*.js');
             const corePlugins = [];
             const userPlugins = [];
             const loadedPluginNames = new Set(); // 用于跟踪已加载的插件名称
 
-            // 扫描指定目录
+            // 扫描核心插件目录
+            const corePluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
                 cwd: path.join(dirname2(import.meta.url), 'plugins'),
                 onlyFiles: true,
@@ -101,12 +115,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,6 +136,8 @@ class BunPii {
                 process.exit();
             }
 
+            // 初始化核心插件
+            const corePluginsInitStart = Bun.nanoseconds();
             for (const plugin of sortedCorePlugins) {
                 try {
                     this.pluginLists.push(plugin);
@@ -122,8 +146,11 @@ class BunPii {
                     Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
                 }
             }
+            const corePluginsInitTime = (Bun.nanoseconds() - corePluginsInitStart) / 1_000_000;
+            Logger.info(`核心插件初始化完成，耗时: ${corePluginsInitTime.toFixed(2)}ms`);
 
-            // 扫描指定目录
+            // 扫描用户插件目录
+            const userPluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
                 cwd: path.join(process.cwd(), 'plugins'),
                 onlyFiles: true,
@@ -138,11 +165,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 +184,24 @@ 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) {
+                const userPluginsInitStart = Bun.nanoseconds();
+                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);
+                    }
                 }
+                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 +212,18 @@ class BunPii {
     }
     async loadApis(dirName) {
         try {
+            const loadStartTime = Bun.nanoseconds();
+            const dirDisplayName = dirName === 'core' ? '核心' : '用户';
+
             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 +233,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 +290,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 +308,7 @@ class BunPii {
                 '/': async (req) => {
                     return Response.json({
                         code: 0,
-                        msg: 'BunPii 接口服务已启动',
+                        msg: 'Befly 接口服务已启动',
                         data: {
                             mode: Env.NODE_ENV
                         }
@@ -327,7 +406,7 @@ class BunPii {
                         }
 
                         // 请求记录
-                        Logger.debug({
+                        Logger.info({
                             msg: '通用接口日志',
                             请求路径: apiPath,
                             请求方法: req.method,
@@ -400,10 +479,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.1",
     "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -49,5 +49,5 @@
         "README.md",
         "vitest.config.js"
     ],
-    "gitHead": "3bd2e1f01b94f2b576467db1b63a016b6717dbbe"
+    "gitHead": "e63250008419234f883e562b6eba2ab554602150"
 }

package/plugins/db.js

@@ -35,8 +35,7 @@ export default {
                 // 测试数据库连接
                 const result = await sql`SELECT VERSION() AS version`.execute(db);
                 if (result?.rows?.[0]?.version) {
-                    // 扩展数据库实例
-                    return new Crud(db, befly.redis, sql);
+                    return db;
                 } else {
                     return {};
                 }

package/plugins/tool.js

@@ -0,0 +1,45 @@
+export default {
+    after: ['_redis', '_db'],
+    async onInit(befly) {
+        // 增强的更新方法 - 自动添加 updated_at
+
+        // 辅助函数：过滤掉 undefined 值
+        const filterUndefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([key, value]) => value !== undefined));
+
+        return {
+            async updData(data) {
+                const filteredData = filterUndefined(data);
+
+                const updateData = {
+                    ...fnOmit(filteredData, ['id', 'created_at', 'deleted_at']),
+                    updated_at: Date.now()
+                };
+
+                return updateData;
+            },
+            async insData(data) {
+                const now = Date.now();
+
+                if (Array.isArray(data)) {
+                    const data2 = await Promise.all(
+                        data.map(async (item) => ({
+                            ...filterUndefined(item),
+                            id: await redis.genTimeID(),
+                            created_at: now,
+                            updated_at: now
+                        }))
+                    );
+                    return data2;
+                } else {
+                    const data2 = {
+                        ...filterUndefined(data),
+                        id: await redis.genTimeID(),
+                        created_at: now,
+                        updated_at: now
+                    };
+                    return data2;
+                }
+            }
+        };
+    }
+};

package/utils/curd.js

@@ -1,186 +0,0 @@
-import { omitFields } from './util.js';
-
-export class Crud {
-    constructor(db, redis, sql) {
-        this.db = db;
-        this.redis = redis;
-        this.sql = sql;
-        this.initMethods();
-    }
-
-    initMethods() {
-        // 将所有 CRUD 方法直接挂载到 db 实例上
-        this.db.insData = this.insData.bind(this);
-        this.db.updData = this.updData.bind(this);
-        this.db.delData = this.delData.bind(this);
-        this.db.getOne = this.getOne.bind(this);
-        this.db.getList = this.getList.bind(this);
-        this.db.getAll = this.getAll.bind(this);
-        this.db.getCount = this.getCount.bind(this);
-    }
-
-    // 事务方法
-    async trans(callback) {
-        return await this.db.transaction().execute(async (trx) => {
-            // 创建一个临时的 Crud 实例，使用事务连接
-            const transactionCrud = new Crud(trx, this.redis, this.sql);
-            return await callback(transactionCrud);
-        });
-    }
-
-    // 增强的插入方法 - 自动添加 ID 和时间戳，支持链式调用
-    insData(tableName, data) {
-        const insertQuery = this.db.insertInto(tableName);
-        const redis = this.redis;
-
-        insertQuery.exec = async function () {
-            const now = Date.now();
-            let processedData = data;
-
-            if (Array.isArray(data)) {
-                processedData = await Promise.all(
-                    data.map(async (item) => ({
-                        ...item,
-                        id: await redis.genTimeID(),
-                        created_at: now,
-                        updated_at: now
-                    }))
-                );
-            } else {
-                processedData = {
-                    ...data,
-                    id: await redis.genTimeID(),
-                    created_at: now,
-                    updated_at: now
-                };
-            }
-
-            const result = await this.values(processedData).execute();
-            return { data: result }; // 返回统一格式
-        };
-
-        return insertQuery;
-    }
-
-    // 增强的更新方法 - 自动添加 updated_at，支持链式调用
-    updData(tableName, data) {
-        // 剔除 undefined 值
-        const filteredData = Object.fromEntries(Object.entries(data).filter(([key, value]) => value !== undefined));
-
-        const updateData = {
-            ...omitFields(filteredData, ['id', 'created_at', 'deleted_at']),
-            updated_at: Date.now()
-        };
-
-        const updateQuery = this.db.updateTable(tableName).set(updateData);
-
-        updateQuery.exec = async function () {
-            const result = await this.execute();
-            return { data: result }; // 返回统一格式
-        };
-
-        return updateQuery;
-    }
-
-    // 增强的删除方法 - 支持链式调用
-    delData(tableName) {
-        const deleteQuery = this.db.deleteFrom(tableName);
-
-        deleteQuery.exec = async function () {
-            const result = await this.execute();
-            return { data: result }; // 返回统一格式
-        };
-
-        return deleteQuery;
-    }
-
-    // 查询单条记录 - 支持链式调用
-    getOne(tableName, fields) {
-        let selectQuery;
-
-        if (fields) {
-            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
-        } else {
-            selectQuery = this.db.selectFrom(tableName).selectAll();
-        }
-
-        // 默认过滤软删除的数据
-        selectQuery = selectQuery.where('state', '<>', 2);
-
-        // 添加 exec 方法，自动返回单条记录
-        selectQuery.exec = async function () {
-            const result = await this.executeTakeFirst();
-            return { data: result }; // 返回统一格式
-        };
-
-        return selectQuery;
-    }
-
-    // 查询列表 - 支持链式调用和分页
-    getList(tableName, fields, page = 1, pageSize = 20) {
-        let selectQuery;
-
-        if (fields) {
-            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
-        } else {
-            selectQuery = this.db.selectFrom(tableName).selectAll();
-        }
-
-        // 默认过滤软删除的数据
-        selectQuery = selectQuery.where('state', '<>', 2);
-
-        // 添加 exec 方法 - 支持分页，只返回数据列表
-        selectQuery.exec = async function () {
-            const offset = (page - 1) * pageSize;
-            const result = await this.limit(pageSize).offset(offset).execute();
-            return { data: result };
-        };
-
-        return selectQuery;
-    }
-
-    // 查询所有记录 - 支持链式调用
-    getAll(tableName, fields) {
-        let selectQuery;
-
-        if (fields) {
-            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
-        } else {
-            selectQuery = this.db.selectFrom(tableName).selectAll();
-        }
-
-        // 默认过滤软删除的数据
-        selectQuery = selectQuery.where('state', '<>', 2);
-
-        // 添加 exec 方法，执行查询所有记录
-        selectQuery.exec = async function () {
-            const result = await this.execute();
-            return { data: result }; // 返回统一格式
-        };
-
-        return selectQuery;
-    }
-
-    // 便捷的计数方法 - 支持链式调用
-    getCount(tableName) {
-        const sql = this.sql;
-        const countQuery = this.db
-            .selectFrom(tableName)
-            .select(sql`count(*)`.as('total'))
-            .where('state', '<>', 2);
-
-        // 添加便捷的 exec 方法
-        countQuery.exec = async function () {
-            const result = await this.executeTakeFirst();
-            const count = Number(result?.total || 0);
-            return { data: count }; // 返回统一格式
-        };
-
-        return countQuery;
-    }
-
-    // 获取原始数据库实例
-    getDb() {
-        return this.db;
-    }
-}