befly 2.0.14 → 2.1.1

package/.gitignore

@@ -91,3 +91,4 @@ profile-*
 profile*
 *clinic*
 *flamegraph*
+logs

package/checks/table.js

@@ -1,13 +1,13 @@
 import path from 'node:path';
-import { Logger } from '../utils/Logger.js';
-import { parseFieldRule } from '../utils/util.js';
+import { Logger } from '../utils/logger.js';
+import { parseFieldRule, validateFieldName, validateFieldType, validateMinMax, validateDefaultValue, validateIndex, validateRegex } from '../utils/util.js';
 import { __dirtables, getProjectDir } from '../system.js';
 
+// 所有校验函数均复用 utils/util.js 导出的实现
+
 export default async () => {
     try {
         const tablesGlob = new Bun.Glob('*.json');
-        const coreTablesDir = __dirtables;
-        const userTablesDir = getProjectDir('tables');
 
         // 统计信息
         let totalFiles = 0;
@@ -15,18 +15,55 @@ export default async () => {
         let validFiles = 0;
         let invalidFiles = 0;
 
-        const validateFile = async (file) => {
+        // 收集所有表文件
+        const allTableFiles = [];
+        const coreTableNames = new Set(); // 存储内核表文件名
+
+        // 收集内核表字段定义文件
+        for await (const file of tablesGlob.scan({
+            cwd: __dirtables,
+            absolute: true,
+            onlyFiles: true
+        })) {
+            const fileName = path.basename(file, '.json');
+            coreTableNames.add(fileName);
+            allTableFiles.push({ file, type: 'core' });
+        }
+
+        // 收集项目表字段定义文件，并检查是否与内核表同名
+        for await (const file of tablesGlob.scan({
+            cwd: getProjectDir('tables'),
+            absolute: true,
+            onlyFiles: true
+        })) {
+            const fileName = path.basename(file, '.json');
+
+            // 检查项目表是否与内核表同名
+            if (coreTableNames.has(fileName)) {
+                Logger.error(`项目表 ${fileName}.json 与内核表同名，项目表不能与内核表定义文件同名`);
+                invalidFiles++;
+                totalFiles++;
+                continue;
+            }
+
+            allTableFiles.push({ file, type: 'project' });
+        }
+
+        // 保留字段列表
+        const reservedFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
+
+        // 合并进行验证逻辑
+        for (const { file, type } of allTableFiles) {
             totalFiles++;
             const fileName = path.basename(file);
+            const fileType = type === 'core' ? '内核' : '项目';
+
             try {
                 // 读取并解析 JSON 文件
                 const table = await Bun.file(file).json();
                 let fileValid = true;
                 let fileRules = 0;
 
-                // 保留字段列表
-                const reservedFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
-
                 // 检查 table 中的每个验证规则
                 for (const [fieldName, rule] of Object.entries(table)) {
                     fileRules++;
@@ -34,80 +71,84 @@ export default async () => {
 
                     // 检查是否使用了保留字段
                     if (reservedFields.includes(fieldName)) {
-                        Logger.error(`${fileName} 文件包含保留字段 ${fieldName}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
+                        Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${fieldName}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
                         fileValid = false;
                         continue;
                     }
 
                     // 验证规则格式
-                    const ruleParts = parseFieldRule(rule);
-
-                    if (ruleParts.length !== 7) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 验证规则错误，应包含 7 个部分，但包含 ${ruleParts.length} 个部分`);
-                        fileValid = false;
-                        continue;
-                    }
+                    try {
+                        const ruleParts = parseFieldRule(rule);
 
-                    const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = ruleParts;
-
-                    // 验证类型（必须严格使用小写类型名称）
-                    const validTypes = ['number', 'string', 'text', 'array'];
-                    if (!validTypes.includes(type)) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 类型 ${type} 不支持，应为小写的 number、string、text 或 array`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    // 验证最小值/最大值
-                    if (minStr !== 'null' && isNaN(parseInt(minStr))) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 最小值 ${minStr} 应为数字或 null`);
-                        fileValid = false;
-                        continue;
-                    }
+                        if (ruleParts.length !== 7) {
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则错误，应包含 7 个部分，但包含 ${ruleParts.length} 个部分`);
+                            fileValid = false;
+                            continue;
+                        }
 
-                    if (maxStr !== 'null' && isNaN(parseInt(maxStr))) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 最大值 ${maxStr} 应为数字或 null`);
-                        fileValid = false;
-                        continue;
-                    }
+                        const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = ruleParts;
 
-                    // 验证索引字段
-                    if (isIndexStr !== 'null' && !['0', '1'].includes(isIndexStr)) {
-                        Logger.warn(`${fileName} 文件 ${fieldName} 索引标识 ${isIndexStr} 应为 0、1 或 null`);
-                        fileValid = false;
-                        continue;
-                    }
+                        // 使用新的验证函数进行严格验证
+                        // 第1个值：名称必须为中文、数字、字母
+                        if (!validateFieldName(name)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 名称 "${name}" 格式错误，必须为中文、数字、字母`);
+                            fileValid = false;
+                            continue;
+                        }
 
-                    // 验证正则约束
-                    if (regexConstraint !== 'null') {
-                        if (type === 'number' && regexConstraint.includes('=')) {
-                            // 数字计算表达式应包含安全字符
-                            const safePattern = /^[x\d\+\-\*\/\(\)\.\s\%]+$/;
-                            const expressionPart = regexConstraint.split('=')[0].trim();
+                        // 第2个值：字段类型必须为string,number,text,array之一
+                        if (!validateFieldType(type)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 类型 "${type}" 格式错误，必须为string、number、text、array之一`);
+                            fileValid = false;
+                            continue;
+                        }
 
-                            if (!safePattern.test(expressionPart)) {
-                                Logger.warn(`${fileName} 文件 ${fieldName} 表达式 ${expressionPart} 包含不安全的字符`);
-                                fileValid = false;
-                                continue;
-                            }
+                        // 第3个值：最小值必须为null或数字
+                        if (!validateMinMax(minStr)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最小值 "${minStr}" 格式错误，必须为null或数字`);
+                            fileValid = false;
+                            continue;
+                        }
 
-                            // 验证等号右侧是否为数字
-                            const rightPart = regexConstraint.split('=')[1].trim();
-                            if (isNaN(parseFloat(rightPart))) {
-                                Logger.error(`${fileName} 文件 ${fieldName} 计算规则右边必须是数字，而不是 ${rightPart}`);
+                        // 第4个值：当类型为 string/array 时，最大长度必须为数字且不可为 null；其他类型允许为 null 或数字
+                        if (type === 'string' || type === 'array') {
+                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，string/array 类型必须为具体数字`);
                                 fileValid = false;
                                 continue;
                             }
-                        } else if (type === 'string' || type === 'array' || type === 'text') {
-                            // 尝试编译正则表达式以检查是否有效
-                            try {
-                                new RegExp(regexConstraint);
-                            } catch (e) {
-                                Logger.error(`${fileName} 文件 ${fieldName} 正则表达式 ${regexConstraint} 无效: ${e.message}`);
+                        } else {
+                            if (!validateMinMax(maxStr)) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大值 "${maxStr}" 格式错误，必须为null或数字`);
                                 fileValid = false;
                                 continue;
                             }
                         }
+
+                        // 第5个值：默认值必须为null、字符串或数字
+                        if (!validateDefaultValue(defaultValue)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+                            fileValid = false;
+                            continue;
+                        }
+
+                        // 第6个值：是否创建索引必须为0或1
+                        if (!validateIndex(isIndexStr)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 索引标识 "${isIndexStr}" 格式错误，必须为0或1`);
+                            fileValid = false;
+                            continue;
+                        }
+
+                        // 第7个值：必须为null或正则表达式
+                        if (!validateRegex(regexConstraint)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
+                            fileValid = false;
+                            continue;
+                        }
+                    } catch (error) {
+                        Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则解析失败: ${error.message}`);
+                        fileValid = false;
+                        continue;
                     }
                 }
 
@@ -117,25 +158,9 @@ export default async () => {
                     invalidFiles++;
                 }
             } catch (error) {
-                Logger.error(`Table ${fileName} 解析失败: ${error.message}`);
+                Logger.error(`${fileType}表 ${fileName} 解析失败: ${error.message}`);
                 invalidFiles++;
             }
-        };
-
-        for await (const file of tablesGlob.scan({
-            cwd: coreTablesDir,
-            absolute: true,
-            onlyFiles: true
-        })) {
-            await validateFile(file);
-        }
-
-        for await (const file of tablesGlob.scan({
-            cwd: userTablesDir,
-            absolute: true,
-            onlyFiles: true
-        })) {
-            await validateFile(file);
         }
 
         if (invalidFiles > 0) {

package/config/env.js

@@ -25,6 +25,7 @@ export const Env = {
     TZ: process.env.TZ,
     // 数据库配置
     MYSQL_ENABLE: Number(process.env.MYSQL_ENABLE),
+    MYSQL_URL: process.env.MYSQL_URL,
     MYSQL_HOST: process.env.MYSQL_HOST,
     MYSQL_PORT: Number(process.env.MYSQL_PORT),
     MYSQL_DB: process.env.MYSQL_DB,

package/main.js

@@ -1,27 +1,14 @@
 import path from 'node:path';
 import { Env } from './config/env.js';
-
-// 工具函数
 import { Api } from './utils/api.js';
 import { Logger } from './utils/logger.js';
 import { Jwt } from './utils/jwt.js';
 import { validator } from './utils/validate.js';
 import { Crypto2 } from './utils/crypto.js';
 import { Xml } from './libs/xml.js';
-import { isEmptyObject, isType, pickFields, sortPlugins, RYes, RNo, filename2, dirname2, filterLogFields } from './utils/util.js';
-
-const setCorsOptions = (req) => {
-    return {
-        headers: {
-            'Access-Control-Allow-Origin': Env.ALLOWED_ORIGIN || req.headers.get('origin') || '*',
-            'Access-Control-Allow-Methods': Env.ALLOWED_METHODS || 'GET, POST, PUT, DELETE, OPTIONS',
-            'Access-Control-Allow-Headers': Env.ALLOWED_HEADERS || 'Content-Type, Authorization, authorization, token',
-            'Access-Control-Expose-Headers': Env.EXPOSE_HEADERS || 'Content-Range, X-Content-Range, Authorization, authorization, token',
-            'Access-Control-Max-Age': Env.MAX_AGE || 86400,
-            'Access-Control-Allow-Credentials': Env.ALLOW_CREDENTIALS || 'true'
-        }
-    };
-};
+import { SyncDb } from './scripts/syncDb.js';
+import { __dirchecks, __dirplugins, __dirapis, getProjectDir } from './system.js';
+import { isEmptyObject, isType, pickFields, sortPlugins, RYes, RNo, filterLogFields, setCorsOptions, calculateElapsedTime } from './utils/util.js';
 
 class Befly {
     constructor(options = {}) {
@@ -34,9 +21,7 @@ class Befly {
     async initCheck() {
         try {
             const checkStartTime = Bun.nanoseconds();
-            Logger.info('开始执行系统检查...');
 
-            const checksDir = path.join(dirname2(import.meta.url), 'checks');
             const glob = new Bun.Glob('*.js');
 
             // 统计信息
@@ -46,7 +31,7 @@ class Befly {
 
             // 扫描并执行检查函数
             for await (const file of glob.scan({
-                cwd: checksDir,
+                cwd: __dirchecks,
                 onlyFiles: true,
                 absolute: true
             })) {
@@ -63,24 +48,24 @@ class Befly {
                     // 执行默认导出的函数
                     if (typeof check.default === 'function') {
                         const checkResult = await check.default(this.appContext);
-                        const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
+                        const singleCheckTime = calculateElapsedTime(singleCheckStart);
 
                         if (checkResult === true) {
                             passedChecks++;
-                            Logger.info(`检查 ${fileName} 通过，耗时: ${singleCheckTime.toFixed(2)}ms`);
+                            Logger.info(`检查 ${fileName} 通过，耗时: ${singleCheckTime}`);
                         } else {
-                            Logger.error(`检查未通过: ${fileName}，耗时: ${singleCheckTime.toFixed(2)}ms`);
+                            Logger.error(`检查未通过: ${fileName}，耗时: ${singleCheckTime}`);
                             failedChecks++;
                         }
                     } else {
-                        const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
-                        Logger.warn(`文件 ${fileName} 未导出默认函数，耗时: ${singleCheckTime.toFixed(2)}ms`);
+                        const singleCheckTime = calculateElapsedTime(singleCheckStart);
+                        Logger.warn(`文件 ${fileName} 未导出默认函数，耗时: ${singleCheckTime}`);
                         failedChecks++;
                     }
                 } catch (error) {
-                    const singleCheckTime = (Bun.nanoseconds() - singleCheckStart) / 1_000_000;
+                    const singleCheckTime = calculateElapsedTime(singleCheckStart);
                     Logger.error({
-                        msg: `检查失败 ${fileName}，耗时: ${singleCheckTime.toFixed(2)}ms`,
+                        msg: `检查失败 ${fileName}，耗时: ${singleCheckTime}`,
                         error: error.message,
                         stack: error.stack
                     });
@@ -88,10 +73,10 @@ class Befly {
                 }
             }
 
-            const totalCheckTime = (Bun.nanoseconds() - checkStartTime) / 1_000_000;
+            const totalCheckTime = calculateElapsedTime(checkStartTime);
 
             // 输出检查结果统计
-            Logger.info(`系统检查完成! 总耗时: ${totalCheckTime.toFixed(2)}ms，总检查数: ${totalChecks}, 通过: ${passedChecks}, 失败: ${failedChecks}`);
+            Logger.info(`系统检查完成! 总耗时: ${totalCheckTime}，总检查数: ${totalChecks}, 通过: ${passedChecks}, 失败: ${failedChecks}`);
 
             if (failedChecks > 0) {
                 process.exit();
@@ -122,7 +107,7 @@ class Befly {
             // 扫描核心插件目录
             const corePluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
-                cwd: path.join(dirname2(import.meta.url), 'plugins'),
+                cwd: __dirplugins,
                 onlyFiles: true,
                 absolute: true
             })) {
@@ -131,17 +116,17 @@ class Befly {
 
                 const importStart = Bun.nanoseconds();
                 const plugin = await import(file);
-                const importTime = (Bun.nanoseconds() - importStart) / 1_000_000; // 转换为毫秒
+                const importTime = calculateElapsedTime(importStart);
 
                 const pluginInstance = plugin.default;
                 pluginInstance.pluginName = fileName;
                 corePlugins.push(pluginInstance);
                 loadedPluginNames.add(fileName); // 记录已加载的核心插件名称
 
-                Logger.info(`核心插件 ${fileName} 导入耗时: ${importTime.toFixed(2)}ms`);
+                Logger.info(`核心插件 ${fileName} 导入耗时: ${importTime}`);
             }
-            const corePluginsScanTime = (Bun.nanoseconds() - corePluginsScanStart) / 1_000_000;
-            Logger.info(`核心插件扫描完成，耗时: ${corePluginsScanTime.toFixed(2)}ms，共找到 ${corePlugins.length} 个插件`);
+            const corePluginsScanTime = calculateElapsedTime(corePluginsScanStart);
+            Logger.info(`核心插件扫描完成，耗时: ${corePluginsScanTime}，共找到 ${corePlugins.length} 个插件`);
 
             const sortedCorePlugins = sortPlugins(corePlugins);
             if (sortedCorePlugins === false) {
@@ -159,13 +144,13 @@ class Befly {
                     Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
                 }
             }
-            const corePluginsInitTime = (Bun.nanoseconds() - corePluginsInitStart) / 1_000_000;
-            Logger.info(`核心插件初始化完成，耗时: ${corePluginsInitTime.toFixed(2)}ms`);
+            const corePluginsInitTime = calculateElapsedTime(corePluginsInitStart);
+            Logger.info(`核心插件初始化完成，耗时: ${corePluginsInitTime}`);
 
             // 扫描用户插件目录
             const userPluginsScanStart = Bun.nanoseconds();
             for await (const file of glob.scan({
-                cwd: path.join(process.cwd(), 'plugins'),
+                cwd: getProjectDir('plugins'),
                 onlyFiles: true,
                 absolute: true
             })) {
@@ -180,16 +165,16 @@ class Befly {
 
                 const importStart = Bun.nanoseconds();
                 const plugin = await import(file);
-                const importTime = (Bun.nanoseconds() - importStart) / 1_000_000; // 转换为毫秒
+                const importTime = calculateElapsedTime(importStart);
 
                 const pluginInstance = plugin.default;
                 pluginInstance.pluginName = fileName;
                 userPlugins.push(pluginInstance);
 
-                Logger.info(`用户插件 ${fileName} 导入耗时: ${importTime.toFixed(2)}ms`);
+                Logger.info(`用户插件 ${fileName} 导入耗时: ${importTime}`);
             }
-            const userPluginsScanTime = (Bun.nanoseconds() - userPluginsScanStart) / 1_000_000;
-            Logger.info(`用户插件扫描完成，耗时: ${userPluginsScanTime.toFixed(2)}ms，共找到 ${userPlugins.length} 个插件`);
+            const userPluginsScanTime = calculateElapsedTime(userPluginsScanStart);
+            Logger.info(`用户插件扫描完成，耗时: ${userPluginsScanTime}，共找到 ${userPlugins.length} 个插件`);
 
             const sortedUserPlugins = sortPlugins(userPlugins);
             if (sortedUserPlugins === false) {
@@ -208,13 +193,13 @@ class Befly {
                         Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
                     }
                 }
-                const userPluginsInitTime = (Bun.nanoseconds() - userPluginsInitStart) / 1_000_000;
-                Logger.info(`用户插件初始化完成，耗时: ${userPluginsInitTime.toFixed(2)}ms`);
+                const userPluginsInitTime = calculateElapsedTime(userPluginsInitStart);
+                Logger.info(`用户插件初始化完成，耗时: ${userPluginsInitTime}`);
             }
 
-            const totalLoadTime = (Bun.nanoseconds() - loadStartTime) / 1_000_000;
+            const totalLoadTime = calculateElapsedTime(loadStartTime);
             const totalPluginCount = sortedCorePlugins.length + sortedUserPlugins.length;
-            Logger.info(`插件加载完成! 总耗时: ${totalLoadTime.toFixed(2)}ms，共加载 ${totalPluginCount} 个插件`);
+            Logger.info(`插件加载完成! 总耗时: ${totalLoadTime}，共加载 ${totalPluginCount} 个插件`);
         } catch (error) {
             Logger.error({
                 msg: '加载插件时发生错误',
@@ -228,10 +213,8 @@ class Befly {
             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;
+            const apiDir = dirName === 'core' ? __dirapis : getProjectDir('apis');
 
             let totalApis = 0;
             let loadedApis = 0;
@@ -274,22 +257,22 @@ class Befly {
                     api.route = `${api.method.toUpperCase()}/api/${dirName}/${apiPath}`;
                     this.apiRoutes.set(api.route, api);
 
-                    const singleApiTime = (Bun.nanoseconds() - singleApiStart) / 1_000_000;
+                    const singleApiTime = calculateElapsedTime(singleApiStart);
                     loadedApis++;
-                    // Logger.info(`${dirDisplayName}接口 ${apiPath} 加载成功，耗时: ${singleApiTime.toFixed(2)}ms`);
+                    // Logger.info(`${dirDisplayName}接口 ${apiPath} 加载成功，耗时: ${singleApiTime}`);
                 } catch (error) {
-                    const singleApiTime = (Bun.nanoseconds() - singleApiStart) / 1_000_000;
+                    const singleApiTime = calculateElapsedTime(singleApiStart);
                     failedApis++;
                     Logger.error({
-                        msg: `${dirDisplayName}接口 ${apiPath} 加载失败，耗时: ${singleApiTime.toFixed(2)}ms`,
+                        msg: `${dirDisplayName}接口 ${apiPath} 加载失败，耗时: ${singleApiTime}`,
                         error: error.message,
                         stack: error.stack
                     });
                 }
             }
 
-            const totalLoadTime = (Bun.nanoseconds() - loadStartTime) / 1_000_000;
-            Logger.info(`${dirDisplayName}接口加载完成! 总耗时: ${totalLoadTime.toFixed(2)}ms，总数: ${totalApis}, 成功: ${loadedApis}, 失败: ${failedApis}`);
+            const totalLoadTime = calculateElapsedTime(loadStartTime);
+            Logger.info(`${dirDisplayName}接口加载完成! 总耗时: ${totalLoadTime}，总数: ${totalApis}, 成功: ${loadedApis}, 失败: ${failedApis}`);
         } catch (error) {
             Logger.error({
                 msg: '加载接口时发生错误',
@@ -311,8 +294,8 @@ class Befly {
         await this.loadApis('core');
         await this.loadApis('app');
 
-        const totalStartupTime = (Bun.nanoseconds() - serverStartTime) / 1_000_000;
-        Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime.toFixed(2)}ms`);
+        const totalStartupTime = calculateElapsedTime(serverStartTime);
+        Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime}`);
 
         const server = Bun.serve({
             port: Env.APP_PORT,
@@ -399,7 +382,7 @@ class Befly {
                                 } else if (contentType.indexOf('form-data') !== -1) {
                                     ctx.body = await req.formData();
                                 } else if (contentType.indexOf('x-www-form-urlencoded') !== -1) {
-                                    const text = await clonedReq.text();
+                                    const text = await req.text();
                                     const formData = new URLSearchParams(text);
                                     ctx.body = Object.fromEntries(formData);
                                 } else {
@@ -511,7 +494,7 @@ class Befly {
                     }
 
                     const url = new URL(req.url);
-                    const filePath = path.join(process.cwd(), 'public', url.pathname);
+                    const filePath = path.join(getProjectDir('public'), url.pathname);
 
                     try {
                         const file = await Bun.file(filePath);
@@ -545,8 +528,8 @@ class Befly {
             }
         });
 
-        const finalStartupTime = (Bun.nanoseconds() - serverStartTime) / 1_000_000;
-        Logger.info(`Befly 服务器启动成功! 完整启动耗时: ${finalStartupTime.toFixed(2)}ms`);
+        const finalStartupTime = calculateElapsedTime(serverStartTime);
+        Logger.info(`Befly 服务器启动成功! 完整启动耗时: ${finalStartupTime}`);
         Logger.info(`服务器监听地址: http://${Env.APP_HOST}:${Env.APP_PORT}`);
 
         if (callback && typeof callback === 'function') {
@@ -555,4 +538,4 @@ class Befly {
     }
 }
 
-export { Befly, Env, Api, Jwt, Crypto2, Logger, RYes, RNo };
+export { Befly, Env, Api, Jwt, Crypto2, Logger, RYes, RNo, SyncDb };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "2.0.14",
+    "version": "2.1.1",
     "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -9,19 +9,19 @@
         "registry": "https://registry.npmjs.org"
     },
     "main": "main.js",
-    "bin": {
-        "befly": "./bin/befly.js"
-    },
     "exports": {
         ".": "./main.js"
     },
     "scripts": {
-        "r": "bun publish --registry=https://registry.npmjs.org --access=public",
-        "ra": "bun run scripts/release.js -a",
-        "rb": "bun run scripts/release.js -b",
-        "rc": "bun run scripts/release.js -c",
+        "ra": "bun run release.js -a",
+        "rb": "bun run release.js -b",
+        "rc": "bun run release.js -c",
         "test": "bun test",
-        "test:jwt": "bun test tests/jwt.test.js"
+        "test:unit": "bun test tests",
+        "test:jwt": "bun test tests/jwt.test.js",
+        "dev": "bun run project/main.js",
+        "server": "bunx --bun pm2 start pm2.config.cjs -a",
+        "syncDb": "bun run scripts/syncDb.js"
     },
     "keywords": [
         "bun",
@@ -38,7 +38,6 @@
     "license": "Apache-2.0",
     "files": [
         "apis/",
-        "bin/",
         "checks/",
         "config/",
         "libs/",
@@ -62,9 +61,7 @@
         "vitest.config.js"
     ],
     "gitHead": "1dc5f118a723969456559e758e2ba889f4601224",
-    "dependencies": {
-        "mariadb": "^3.4.5"
-    },
+    "dependencies": {},
     "simple-git-hooks": {
         "pre-commit": "bunx --bun lint-staged"
     },