befly 3.74.2 → 3.75.0

package/index.js

@@ -6,16 +6,17 @@
 // 检查
 import { checkApi } from "#befly/checks/api.js";
 import { checkConfig } from "#befly/checks/config.js";
-import { checkHook } from "#befly/checks/hook.js";
+import { checkHook, checkPlugin } from "#befly/checks/items.js";
 import { checkMenu } from "#befly/checks/menu.js";
-import { checkPlugin } from "#befly/checks/plugin.js";
 import { checkTable } from "#befly/checks/table.js";
 // 配置
 import beflyConfig from "#befly/configs/beflyConfig.json";
 import beflyMenus from "#befly/configs/beflyMenus.json";
+import { BEFLY_ADMIN_TABLE, BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ROLE_TABLE } from "#befly/configs/constConfig.js";
 // ========== 相对导入（项目内部文件） ==========
 // 基础设施
 import { Connect } from "#befly/lib/connect.js";
+// oxlint-disable-next-line unicorn/prefer-export-from -- Logger 同时被本文件大量使用，不能合并为 re-export
 import { Logger } from "#befly/lib/logger.js";
 // 路由处理
 import { apiHandler } from "#befly/router/api.js";
@@ -27,14 +28,20 @@ import { syncDev } from "#befly/sync/dev.js";
 import { syncMenu } from "#befly/sync/menu.js";
 // 工具
 import { calcPerfTime } from "#befly/utils/calcPerfTime.js";
+import { formatYmdHms } from "#befly/utils/datetime.js";
 import { deepMerge } from "#befly/utils/deepMerge.js";
+import { createError } from "#befly/utils/error.js";
 import { isPrimaryProcess } from "#befly/utils/is.js";
 import { scanSources } from "#befly/utils/scanSources.js";
+import { getRunMode, waitFor } from "#befly/utils/util.js";
 
 export { syncDb } from "#befly/scripts/syncDb/index.js";
 export { xmlParse } from "#befly/lib/xmlParse.js";
 export { Logger };
 
+// 主进程同步完成的 Redis 就绪标记（非主进程等待此标记后再对外服务）
+const SYNC_READY_KEY = "befly:syncReady";
+
 function prefixMenuPaths(menus, prefix) {
     return menus.map((menu) => {
         const nextMenu = {
@@ -58,8 +65,7 @@ function prefixMenuPaths(menus, prefix) {
 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("、")} 未初始化`, {
-            cause: null,
+        throw createError(`启动失败：${missingCtxKeys.join("、")} 未初始化`, {
             code: "runtime",
             subsystem: "sync",
             operation: "ctxCheck",
@@ -67,7 +73,7 @@ async function syncReady(ctx) {
         });
     }
 
-    const requiredTables = ["beflyApi", "beflyMenu", "beflyAdmin", "beflyRole"];
+    const requiredTables = [BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ADMIN_TABLE, BEFLY_ROLE_TABLE];
     const missingTables = [];
 
     for (const table of requiredTables) {
@@ -77,8 +83,7 @@ async function syncReady(ctx) {
     }
 
     if (missingTables.length > 0) {
-        throw new Error(`同步依赖表缺失: ${missingTables.join("、")}`, {
-            cause: null,
+        throw createError(`同步依赖表缺失: ${missingTables.join("、")}`, {
             code: "runtime",
             subsystem: "sync",
             operation: "tableExists",
@@ -93,7 +98,7 @@ export async function createBefly(config = {}, menus = []) {
     const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
 
     Logger.configure({
-        runtimeEnv: mergedConfig.runMode,
+        runtimeEnv: getRunMode(),
         ...mergedConfig.logger
     });
     Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
@@ -127,14 +132,13 @@ export async function createBefly(config = {}, menus = []) {
     Logger.info(`启动 检查菜单 耗时 ${calcPerfTime(stageStartTime)}`);
 
     if (configHasError || apiHasError || tableHasError || pluginHasError || hookHasError || menuHasError) {
-        throw new Error("检查失败：存在配置/结构问题", {
-            cause: null,
-            code: "policy",
-            subsystem: "checks",
-            operation: "checkAll"
-        });
+        throw createError("检查失败：存在配置/结构问题", { code: "policy", subsystem: "checks", operation: "checkAll" });
     }
 
+    // 运行模式以环境为准（NODE_ENV，线上部署注入 production；本地开发默认 development），
+    // 覆盖配置值，保证 befly.config.runMode 与运行时判断一致
+    mergedConfig.runMode = getRunMode();
+
     return new Befly({
         config: mergedConfig,
         tables: tables,
@@ -168,12 +172,7 @@ export class Befly {
             return;
         }
 
-        throw new Error("请使用 createBefly(...) 创建实例后再调用 start", {
-            cause: null,
-            code: "policy",
-            subsystem: "start",
-            operation: "factoryGuard"
-        });
+        throw createError("请使用 createBefly(...) 创建实例后再调用 start", { code: "policy", subsystem: "start", operation: "factoryGuard" });
     }
 
     /**
@@ -207,7 +206,7 @@ export class Befly {
             await syncReady(this.context);
             Logger.info(`启动 同步就绪 耗时 ${calcPerfTime(stageStartTime)}`);
 
-            // 自动同步（PM2 cluster：主进程执行，其它进程等待同步完成）
+            // 自动同步（bm2 多实例：主进程执行同步并写就绪标记，其它进程等待同步完成后再对外服务）
             if (isPrimaryProcess()) {
                 stageStartTime = Bun.nanoseconds();
                 await syncApi(this.context, this.apis);
@@ -224,6 +223,20 @@ export class Befly {
                 stageStartTime = Bun.nanoseconds();
                 await syncCache(this.context);
                 Logger.info(`启动 同步缓存 耗时 ${calcPerfTime(stageStartTime)}`);
+
+                // 同步完成：写入就绪标记（TTL 防崩溃残留），非主进程据此放行
+                await this.context.redis.setString(SYNC_READY_KEY, String(Date.now()), 300);
+            } else {
+                // 非主进程：在监听端口前等待主进程本次同步完成（时间戳判断，同机时钟一致）
+                const startAt = Date.now();
+                await waitFor({
+                    label: "主进程同步完成",
+                    check: async () => {
+                        const ready = await this.context.redis.getString(SYNC_READY_KEY);
+                        return ready !== null && Number(ready) > startAt;
+                    }
+                });
+                Logger.info("启动 等待主进程同步完成 完成");
             }
 
             // 加载钩子
@@ -241,7 +254,7 @@ export class Befly {
             stageStartTime = Bun.nanoseconds();
             const server = Bun.serve({
                 port: this.context.config.appPort || 3000,
-                hostname: this.context.config.appHost || "0.0.0.0",
+                hostname: this.context.config.appHost || "127.0.0.1",
                 // 开发模式下启用详细错误信息
                 development: this.context.config.runMode === "development",
                 // 空闲连接超时时间（秒），防止恶意连接占用资源
@@ -256,6 +269,22 @@ export class Befly {
                         return staticFetch(req);
                     }
 
+                    // 根路径返回服务基本信息
+                    if (url.pathname === "/") {
+                        return Response.json(
+                            {
+                                code: 0,
+                                msg: "success",
+                                data: {
+                                    name: this.context.config.appName,
+                                    mode: this.context.config.runMode,
+                                    time: formatYmdHms(Date.now())
+                                }
+                            },
+                            { status: 200 }
+                        );
+                    }
+
                     return Response.json({ code: 1, msg: "路径不存在" }, { status: 200 });
                 },
                 error: (error) => {
@@ -302,7 +331,7 @@ export class Befly {
             // - 作为库代码，也不应该强行终止宿主进程
 
             // 注意：测试要求 start() 失败时必须 Logger.error 一次，所以这里始终调用 error。
-            Logger.error("项目启动失败", error, null, false);
+            Logger.error("项目启动失败", error);
 
             // 尽力把错误日志落盘/输出后再把异常抛给上层。
             try {
@@ -312,7 +341,7 @@ export class Befly {
                 // ignore
             }
 
-            throw new Error("运行时错误", {
+            throw createError("运行时错误", {
                 cause: error,
                 code: error?.code || "runtime",
                 subsystem: "start",

package/lib/cacheHelper.js

@@ -1,8 +1,9 @@
 /**
- * 缓存助手 - JavaScript 版本
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
+import { BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ROLE_TABLE } from "../configs/constConfig.js";
+import { createError } from "../utils/error.js";
 import { isNonEmptyString, isNullable, isString } from "../utils/is.js";
 import { Logger } from "./logger.js";
 
@@ -105,161 +106,105 @@ export class CacheHelper {
     }
 
     /**
-     * 缓存所有接口到 Redis
+     * 缓存某类全部数据到 Redis（从数据库读取）
+     * @param kind - 数据类别（apis/menus），决定 Redis key 与日志文案
+     * @param table - 数据库表名
      */
-    async cacheApis() {
+    async cacheAllItems(kind, table) {
         try {
-            // 从数据库查询所有接口
-            const apiList = await this.mysql.getAll({
-                table: "beflyApi"
+            const items = await this.mysql.getAll({
+                table: table
             });
 
-            // 缓存到 Redis
-            const result = await this.redis.setObject("apis:all", apiList.data.lists);
+            const result = await this.redis.setObject(`${kind}:all`, items.data.lists);
 
             if (result === null) {
-                Logger.warn("⚠️ 接口缓存失败", {
+                Logger.warn(`⚠️ ${kind} 缓存失败`, {
                     subsystem: "cache",
-                    operation: "cacheApis"
+                    operation: "cacheAllItems"
                 });
             }
         } catch (error) {
-            Logger.error("⚠️ 接口缓存异常", error);
-            throw new Error("接口缓存异常", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "cacheApis"
-            });
+            throw createError(`${kind} 缓存异常`, { cause: error, code: "runtime", subsystem: "cache", operation: "cacheAllItems" });
         }
     }
 
+    /**
+     * 缓存所有接口到 Redis
+     */
+    async cacheApis() {
+        return this.cacheAllItems("apis", BEFLY_API_TABLE);
+    }
+
     /**
      * 缓存所有菜单到 Redis（从数据库读取）
      */
     async cacheMenus() {
-        try {
-            // 从数据库查询所有菜单
-            const menus = await this.mysql.getAll({
-                table: "beflyMenu"
-            });
-
-            // 缓存到 Redis
-            const result = await this.redis.setObject("menus:all", menus.data.lists);
-
-            if (result === null) {
-                Logger.warn("⚠️ 菜单缓存失败", {
-                    subsystem: "cache",
-                    operation: "cacheMenus"
-                });
-            }
-        } catch (error) {
-            Logger.error("⚠️ 菜单缓存异常", error);
-            throw new Error("菜单缓存异常", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "cacheMenus"
-            });
-        }
+        return this.cacheAllItems("menus", BEFLY_MENU_TABLE);
     }
 
     /**
-     * 缓存所有角色的接口权限到 Redis
-     * 全量重建：清理所有角色权限缓存并重建
-     * - 极简方案：每个角色一个 Set，直接覆盖更新（DEL + SADD）
+     * 缓存所有角色的某类权限到 Redis
+     * 全量重建：清理所有角色权限缓存并重建（DEL + SADD）
+     * @param kind - 权限类别（apis/menus），同时是 beflyRole 表字段名
      */
-    async cacheRoleApis() {
+    async cacheRoleItems(kind) {
         try {
-            // 查询所有角色（仅取必要字段）
             const roles = await this.mysql.getAll({
-                table: "beflyRole",
-                fields: ["code", "apis"]
+                table: BEFLY_ROLE_TABLE,
+                fields: ["code", kind]
             });
 
-            const roleApiPathsMap = new Map();
+            const roleValuesMap = new Map();
 
             for (const role of roles.data.lists) {
                 if (!role?.code) continue;
-                roleApiPathsMap.set(role.code, role.apis);
+                roleValuesMap.set(role.code, role[kind]);
             }
 
-            await this.rebuildRoleCache("apis", roleApiPathsMap);
+            await this.rebuildRoleCache(kind, roleValuesMap);
         } catch (error) {
-            Logger.error("⚠️ 角色权限缓存异常（将阻断启动）", error);
-            throw new Error("⚠️ 角色权限缓存异常（将阻断启动）", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "cacheRoleApis"
-            });
+            throw createError(`⚠️ 角色${kind}权限缓存异常（将阻断启动）`, { cause: error, code: "runtime", subsystem: "cache", operation: "cacheRoleItems" });
         }
     }
 
+    /**
+     * 缓存所有角色的接口权限到 Redis
+     */
+    async cacheRoleApis() {
+        return this.cacheRoleItems("apis");
+    }
+
     /**
      * 缓存所有角色的菜单权限到 Redis
-     * 全量重建：清理所有角色菜单权限缓存并重建
-     * - 每个角色一个 Set，直接覆盖更新（DEL + SADD）
      */
     async cacheRoleMenus() {
-        try {
-            // 查询所有角色（仅取必要字段）
-            const roles = await this.mysql.getAll({
-                table: "beflyRole",
-                fields: ["code", "menus"]
-            });
-
-            const roleMenuPathsMap = new Map();
-
-            for (const role of roles.data.lists) {
-                if (!role?.code) continue;
-                roleMenuPathsMap.set(role.code, role.menus);
-            }
-
-            await this.rebuildRoleCache("menus", roleMenuPathsMap);
-        } catch (error) {
-            Logger.error("⚠️ 角色菜单权限缓存异常（将阻断启动）", error);
-            throw new Error("⚠️ 角色菜单权限缓存异常（将阻断启动）", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "cacheRoleMenus"
-            });
-        }
+        return this.cacheRoleItems("menus");
     }
 
     /**
-     * 增量刷新单个角色的接口权限缓存
-     * - apiIds 为空数组：仅清理缓存（防止残留）
-     * - apiIds 非空：使用 $in 最小查询，DEL 后 SADD
+     * 增量刷新单个角色的某类权限缓存
+     * - paths 为空数组：仅清理缓存（防止残留）
+     * - paths 非空：使用最小查询，DEL 后 SADD
+     * @param kind - 权限类别（apis/menus）
      */
-    async refreshRoleApis(roleCode, apiPaths) {
+    async refreshRoleItems(kind, roleCode, paths) {
         if (!isNonEmptyString(roleCode)) {
-            throw new Error("roleCode 参数不合法", {
-                cause: null,
-                code: "validation",
-                subsystem: "cache",
-                operation: "refreshRoleApis"
-            });
+            throw createError("roleCode 参数不合法", { code: "validation", subsystem: "cache", operation: "refreshRoleItems" });
         }
-        if (!Array.isArray(apiPaths)) {
-            throw new Error("apiPaths 参数不合法", {
-                cause: null,
-                code: "validation",
-                subsystem: "cache",
-                operation: "refreshRoleApis"
-            });
+        if (!Array.isArray(paths)) {
+            throw createError("paths 参数不合法", { code: "validation", subsystem: "cache", operation: "refreshRoleItems" });
         }
 
-        const roleKey = await this.getRoleCacheReadKey("apis", roleCode);
+        const roleKey = await this.getRoleCacheReadKey(kind, roleCode);
 
         // 空数组短路：保证清理残留
-        if (apiPaths.length === 0) {
+        if (paths.length === 0) {
             await this.redis.del(roleKey);
             return;
         }
 
-        const members = Array.from(new Set(apiPaths));
+        const members = Array.from(new Set(paths));
 
         await this.redis.del(roleKey);
         if (members.length > 0) {
@@ -268,59 +213,21 @@ export class CacheHelper {
     }
 
     /**
-     * 增量刷新单个角色的菜单权限缓存
-     * - menuPaths 为空数组：仅清理缓存（防止残留）
-     * - menuPaths 非空：DEL 后 SADD
+     * 增量刷新单个角色的接口权限缓存
+     * - apiPaths 为空数组：仅清理缓存（防止残留）
+     * - apiPaths 非空：使用 $in 最小查询，DEL 后 SADD
      */
-    async refreshRoleMenus(roleCode, menuPaths) {
-        if (!isNonEmptyString(roleCode)) {
-            throw new Error("roleCode 参数不合法", {
-                cause: null,
-                code: "validation",
-                subsystem: "cache",
-                operation: "refreshRoleMenus"
-            });
-        }
-        if (!Array.isArray(menuPaths)) {
-            throw new Error("menuPaths 参数不合法", {
-                cause: null,
-                code: "validation",
-                subsystem: "cache",
-                operation: "refreshRoleMenus"
-            });
-        }
-
-        const roleKey = await this.getRoleCacheReadKey("menus", roleCode);
-
-        // 空数组短路：保证清理残留
-        if (menuPaths.length === 0) {
-            await this.redis.del(roleKey);
-            return;
-        }
-
-        const members = Array.from(new Set(menuPaths));
-
-        await this.redis.del(roleKey);
-        if (members.length > 0) {
-            await this.redis.sadd(roleKey, members);
-        }
+    async refreshRoleApis(roleCode, apiPaths) {
+        return this.refreshRoleItems("apis", roleCode, apiPaths);
     }
 
     /**
-     * 缓存所有数据
+     * 增量刷新单个角色的菜单权限缓存
+     * - menuPaths 为空数组：仅清理缓存（防止残留）
+     * - menuPaths 非空：DEL 后 SADD
      */
-    async cacheAll() {
-        // 1. 缓存接口
-        await this.cacheApis();
-
-        // 2. 缓存菜单
-        await this.cacheMenus();
-
-        // 3. 缓存角色权限
-        await this.cacheRoleApis();
-
-        // 4. 缓存角色菜单权限
-        await this.cacheRoleMenus();
+    async refreshRoleMenus(roleCode, menuPaths) {
+        return this.refreshRoleItems("menus", roleCode, menuPaths);
     }
 
     /**
@@ -332,13 +239,7 @@ export class CacheHelper {
             const apis = await this.redis.getObject("apis:all");
             return apis || [];
         } catch (error) {
-            Logger.error("获取接口缓存失败", error);
-            throw new Error("获取接口缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "getApis"
-            });
+            throw createError("获取接口缓存失败", { cause: error, code: "runtime", subsystem: "cache", operation: "getApis" });
         }
     }
 
@@ -351,13 +252,7 @@ export class CacheHelper {
             const menus = await this.redis.getObject("menus:all");
             return menus || [];
         } catch (error) {
-            Logger.error("获取菜单缓存失败", error);
-            throw new Error("获取菜单缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "getMenus"
-            });
+            throw createError("获取菜单缓存失败", { cause: error, code: "runtime", subsystem: "cache", operation: "getMenus" });
         }
     }
 
@@ -372,14 +267,7 @@ export class CacheHelper {
             const permissions = await this.redis.smembers(roleKey);
             return permissions || [];
         } catch (error) {
-            Logger.error("获取角色权限缓存失败", error, { roleCode: roleCode });
-            throw new Error("获取角色权限缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "getRoleApis",
-                roleCode: roleCode
-            });
+            throw createError("获取角色权限缓存失败", { cause: error, code: "runtime", subsystem: "cache", operation: "getRoleApis", roleCode: roleCode });
         }
     }
 
@@ -394,14 +282,7 @@ export class CacheHelper {
             const permissions = await this.redis.smembers(roleKey);
             return permissions || [];
         } catch (error) {
-            Logger.error("获取角色菜单权限缓存失败", error, { roleCode: roleCode });
-            throw new Error("获取角色菜单权限缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "getRoleMenus",
-                roleCode: roleCode
-            });
+            throw createError("获取角色菜单权限缓存失败", { cause: error, code: "runtime", subsystem: "cache", operation: "getRoleMenus", roleCode: roleCode });
         }
     }
 
@@ -418,14 +299,7 @@ export class CacheHelper {
             const roleKey = await this.getRoleCacheReadKey("apis", roleCode);
             return await this.redis.sismember(roleKey, value);
         } catch (error) {
-            Logger.error("检查角色权限失败", error, { roleCode: roleCode });
-            throw new Error("检查角色权限失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "checkRoleApis",
-                roleCode: roleCode
-            });
+            throw createError("检查角色权限失败", { cause: error, code: "runtime", subsystem: "cache", operation: "checkRoleApis", roleCode: roleCode });
         }
     }
 
@@ -442,66 +316,46 @@ export class CacheHelper {
             const roleKey = await this.getRoleCacheReadKey("menus", roleCode);
             return await this.redis.sismember(roleKey, value);
         } catch (error) {
-            Logger.error("检查角色菜单权限失败", error, { roleCode: roleCode });
-            throw new Error("检查角色菜单权限失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "checkRoleMenus",
-                roleCode: roleCode
-            });
+            throw createError("检查角色菜单权限失败", { cause: error, code: "runtime", subsystem: "cache", operation: "checkRoleMenus", roleCode: roleCode });
         }
     }
 
     /**
-     * 删除角色的接口权限缓存
+     * 删除角色的某类权限缓存
+     * @param kind - 权限类别（apis/menus）
      * @param roleCode - 角色代码
      * @returns 是否删除成功
      */
-    async deleteRoleApis(roleCode) {
+    async deleteRoleItems(kind, roleCode) {
         try {
-            const roleReadKey = await this.getRoleCacheReadKey("apis", roleCode);
-            const result = await this.redis.delBatch([`role:apis:${roleCode}`, roleReadKey]);
+            const roleReadKey = await this.getRoleCacheReadKey(kind, roleCode);
+            // 同时清理无版本旧 key（permission hook 的兜底读取路径）
+            const result = await this.redis.delBatch([`role:${kind}:${roleCode}`, roleReadKey]);
             if (result > 0) {
-                Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
+                Logger.info(`✅ 已删除角色 ${roleCode} 的${kind}权限缓存`);
                 return true;
             }
             return false;
         } catch (error) {
-            Logger.error("删除角色权限缓存失败", error, { roleCode: roleCode });
-            throw new Error("删除角色权限缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "deleteRoleApis",
-                roleCode: roleCode
-            });
+            throw createError("删除角色权限缓存失败", { cause: error, code: "runtime", subsystem: "cache", operation: "deleteRoleItems", roleCode: roleCode });
         }
     }
 
+    /**
+     * 删除角色的接口权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRoleApis(roleCode) {
+        return this.deleteRoleItems("apis", roleCode);
+    }
+
     /**
      * 删除角色的菜单权限缓存
      * @param roleCode - 角色代码
      * @returns 是否删除成功
      */
     async deleteRoleMenus(roleCode) {
-        try {
-            const roleReadKey = await this.getRoleCacheReadKey("menus", roleCode);
-            const result = await this.redis.delBatch([`role:menus:${roleCode}`, roleReadKey]);
-            if (result > 0) {
-                Logger.info(`✅ 已删除角色 ${roleCode} 的菜单权限缓存`);
-                return true;
-            }
-            return false;
-        } catch (error) {
-            Logger.error("删除角色菜单权限缓存失败", error, { roleCode: roleCode });
-            throw new Error("删除角色菜单权限缓存失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "cache",
-                operation: "deleteRoleMenus",
-                roleCode: roleCode
-            });
-        }
+        return this.deleteRoleItems("menus", roleCode);
     }
 }

package/lib/connect.js

@@ -1,16 +1,13 @@
 /**
- * 连接管理器 - JavaScript 版本
  * 负责管理数据库和 Redis 连接
  */
 
 import { RedisClient, SQL } from "bun";
 
+import { createError } from "../utils/error.js";
+import { getRunMode } from "../utils/util.js";
 import { Logger } from "./logger.js";
 
-function getRunMode() {
-    return Bun.env.RUN_MODE || "unknown";
-}
-
 function buildRedisUrl(config) {
     if (config.username) {
         const encodedUser = encodeURIComponent(config.username);
@@ -52,14 +49,7 @@ export class Connect {
     static async handleConnectError(clientKey, label, subsystem, hostname, error) {
         await this[clientKey]?.close();
         this[clientKey] = null;
-        Logger.error(`${label} 连接失败 (${hostname} ${getRunMode()})`, error);
-        throw new Error(`${label} 连接失败 (${hostname})`, {
-            cause: error,
-            code: "runtime",
-            subsystem: subsystem,
-            operation: "connect",
-            runMode: getRunMode()
-        });
+        throw createError(`${label} 连接失败 (${hostname})`, { cause: error, code: "runtime", subsystem: subsystem, operation: "connect", runMode: getRunMode() });
     }
 
     /**