befly 3.73.0 → 3.74.1

package/index.js

@@ -55,7 +55,7 @@ function prefixMenuPaths(menus, prefix) {
     });
 }
 
-async function ensureSyncPrerequisites(ctx) {
+async function syncReady(ctx) {
     const missingCtxKeys = ["ctx.redis", "ctx.mysql", "ctx.cache"].filter((key) => !ctx[key.slice(4)]);
     if (missingCtxKeys.length > 0) {
         throw new Error(`启动失败：${missingCtxKeys.join("、")} 未初始化`, {
@@ -88,6 +88,7 @@ async function ensureSyncPrerequisites(ctx) {
 }
 
 export async function createBefly(config = {}, menus = []) {
+    const mergeStartTime = Bun.nanoseconds();
     const mergedConfig = deepMerge(beflyConfig, config);
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
 
@@ -95,15 +96,35 @@ export async function createBefly(config = {}, menus = []) {
         runtimeEnv: mergedConfig.runMode,
         ...mergedConfig.logger
     });
+    Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
 
+    let stageStartTime = Bun.nanoseconds();
     const configHasError = await checkConfig(mergedConfig);
+    Logger.info(`启动 检查配置 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const { apis, tables, plugins, hooks } = await scanSources();
+    Logger.info(`启动 扫描源码 耗时 ${calcPerfTime(stageStartTime)}`);
 
+    stageStartTime = Bun.nanoseconds();
     const apiHasError = await checkApi(apis);
+    Logger.info(`启动 检查接口 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const tableHasError = await checkTable(tables);
+    Logger.info(`启动 检查表 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const pluginHasError = await checkPlugin(plugins);
+    Logger.info(`启动 检查插件 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const hookHasError = await checkHook(hooks);
+    Logger.info(`启动 检查钩子 耗时 ${calcPerfTime(stageStartTime)}`);
+
+    stageStartTime = Bun.nanoseconds();
     const menuHasError = await checkMenu(mergedMenus);
+    Logger.info(`启动 检查菜单 耗时 ${calcPerfTime(stageStartTime)}`);
 
     if (configHasError || apiHasError || tableHasError || pluginHasError || hookHasError || menuHasError) {
         throw new Error("检查失败：存在配置/结构问题", {
@@ -167,24 +188,46 @@ export class Befly {
 
             // 启动期建立基础连接（SQL + Redis）
             // 说明：连接职责收敛到启动期单点；插件只消费已连接实例（Connect.getSql/getRedis）。
+            let stageStartTime = Bun.nanoseconds();
             await Connect.connectRedis(this.context.config.redis);
+            Logger.info(`启动 连接 Redis 耗时 ${calcPerfTime(stageStartTime)}`);
+
+            stageStartTime = Bun.nanoseconds();
             await Connect.connectMysql(this.context.config.mysql);
+            Logger.info(`启动 连接 Mysql 耗时 ${calcPerfTime(stageStartTime)}`);
 
             // 加载插件
             for (const item of this.plugins.toSorted((a, b) => a.order - b.order)) {
+                const pluginStartTime = Bun.nanoseconds();
                 this.context[item.fileName] = await item.handler(this.context);
+                Logger.info(`启动 插件 ${item.fileName} 耗时 ${calcPerfTime(pluginStartTime)}`);
             }
-            await ensureSyncPrerequisites(this.context);
+
+            stageStartTime = Bun.nanoseconds();
+            await syncReady(this.context);
+            Logger.info(`启动 同步就绪 耗时 ${calcPerfTime(stageStartTime)}`);
 
             // 自动同步（PM2 cluster：主进程执行，其它进程等待同步完成）
             if (isPrimaryProcess()) {
+                stageStartTime = Bun.nanoseconds();
                 await syncApi(this.context, this.apis);
+                Logger.info(`启动 同步接口 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncMenu(this.context, this.menus);
+                Logger.info(`启动 同步菜单 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncDev(this.context);
+                Logger.info(`启动 同步开发账号 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                stageStartTime = Bun.nanoseconds();
                 await syncCache(this.context);
+                Logger.info(`启动 同步缓存 耗时 ${calcPerfTime(stageStartTime)}`);
             }
 
             // 加载钩子
+            stageStartTime = Bun.nanoseconds();
             this.hooks = this.hooks.toSorted((a, b) => a.order - b.order);
 
             // 加载所有 API
@@ -193,7 +236,9 @@ export class Befly {
             // 启动 HTTP服务器
             const apiFetch = apiHandler(this.apis, this.hooks, this.context);
             const staticFetch = staticHandler(this.context.config.cors, this.context.config.upload);
+            Logger.info(`启动 装配接口 耗时 ${calcPerfTime(stageStartTime)}`);
 
+            stageStartTime = Bun.nanoseconds();
             const server = Bun.serve({
                 port: this.context.config.appPort || 3000,
                 hostname: this.context.config.appHost || "0.0.0.0",
@@ -230,6 +275,7 @@ export class Befly {
                     return Response.json({ code: 1, msg: "内部服务器错误" }, { status: 200 });
                 }
             });
+            Logger.info(`启动 监听服务 耗时 ${calcPerfTime(stageStartTime)}`);
 
             const finalStartupTime = calcPerfTime(serverStartTime);
 

package/lib/connect.js

@@ -88,7 +88,6 @@ export class Connect {
             });
 
             await this.mysqlClient`SELECT 1`;
-            Logger.info(`Mysql 连接成功 (${config.hostname})`);
         } catch (error) {
             await this.handleConnectError("mysqlClient", "Mysql", "mysql", config.hostname, error);
         }
@@ -101,11 +100,6 @@ export class Connect {
     static async connectRedis(config) {
         try {
             this.redisClient = new RedisClient(buildRedisUrl(config));
-            // Called when successfully connected to Redis server
-            this.redisClient.onconnect = () => {
-                Logger.info(`Redis 连接成功 (${config.hostname})`);
-            };
-
             // Called when disconnected from Redis server
             this.redisClient.onclose = (error) => {
                 if (error) {

package/lib/dbHelper.js

@@ -1052,20 +1052,11 @@ class DbHelper {
     }
 
     async trans(callback) {
-        const abortMark = "__beflyTransAbort";
-
         if (this.isTransaction) {
-            const result = await callback(this);
-            if (result?.code !== undefined && result.code !== 0) {
-                const abortError = new Error("TRANSACTION_ABORT", {
-                    cause: null,
-                    code: "runtime"
-                });
-                abortError[abortMark] = true;
-                abortError.payload = result;
-                throw abortError;
-            }
-            return result;
+            throw new Error("不支持嵌套事务", {
+                cause: null,
+                code: "policy"
+            });
         }
 
         if (typeof this.sql?.begin !== "function") {
@@ -1075,34 +1066,17 @@ class DbHelper {
             });
         }
 
-        try {
-            return await this.sql.begin(async (tx) => {
-                const trans = new this.constructor({
-                    redis: this.redis,
-                    dbName: this.dbName,
-                    sql: tx,
-                    isTransaction: true,
-                    beflyMode: this.beflyMode,
-                    tables: this.tables
-                });
-                const result = await callback(trans);
-                if (result?.code !== undefined && result.code !== 0) {
-                    const abortError = new Error("TRANSACTION_ABORT", {
-                        cause: null,
-                        code: "runtime"
-                    });
-                    abortError[abortMark] = true;
-                    abortError.payload = result;
-                    throw abortError;
-                }
-                return result;
+        return await this.sql.begin(async (tx) => {
+            const trans = new this.constructor({
+                redis: this.redis,
+                dbName: this.dbName,
+                sql: tx,
+                isTransaction: true,
+                beflyMode: this.beflyMode,
+                tables: this.tables
             });
-        } catch (error) {
-            if (error && error[abortMark] === true) {
-                return error.payload;
-            }
-            throw error;
-        }
+            return await callback(trans);
+        });
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.73.0",
+    "version": "3.74.1",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",

package/plugins/tool.js

@@ -47,6 +47,21 @@ export function No(msg, data = null, other = {}) {
     return out;
 }
 
+/**
+ * 业务失败并抛出错误
+ *
+ * 仅用于事务内需要回滚的业务失败；抛出后由路由统一转换为 { code: 1 } 响应。
+ * @param msg - 消息
+ * @param data - 数据（可选）
+ * @param other - 其他字段（可选）
+ */
+export function Fail(msg, data = null, other = {}) {
+    const error = new Error(msg);
+    error.isBeflyResponse = true;
+    error.payload = No(msg, data, other);
+    throw error;
+}
+
 /**
  * 统一响应函数
  *
@@ -109,6 +124,7 @@ export default {
         return {
             Yes: Yes,
             No: No,
+            Fail: Fail,
             Raw: Raw
         };
     }

package/router/api.js

@@ -158,6 +158,10 @@ export function apiHandler(apis, hooks, context) {
             // 7. 返回响应（自动处理 response/result/日志）
             return FinalResponse(ctx);
         } catch (err) {
+            if (err && err.isBeflyResponse === true) {
+                ctx.result = err.payload;
+                return FinalResponse(ctx);
+            }
             // 全局错误处理
             Logger.error("请求错误", err, {
                 path: ctx.apiPath,