befly 3.74.3 → 3.75.1

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() });
     }
 
     /**