befly 3.16.11 → 3.17.2

package/lib/cacheHelper.js

@@ -0,0 +1,483 @@
+/**
+ * 缓存助手 - JavaScript 版本
+ * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
+ */
+
+import { CacheKeys } from "./cacheKeys.js";
+import { Logger } from "./logger.js";
+import { isNonEmptyString, isNullable, isString } from "../utils/is.js";
+
+/**
+ * 缓存助手类
+ */
+export class CacheHelper {
+    constructor(deps) {
+        this.mysql = deps.mysql;
+        this.redis = deps.redis;
+    }
+
+    assertApiPathList(value) {
+        if (isNullable(value)) return [];
+
+        let list = value;
+
+        if (isString(list)) {
+            const trimmed = list.trim();
+            if (trimmed === "" || trimmed === "null") {
+                return [];
+            }
+
+            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                try {
+                    list = JSON.parse(trimmed);
+                } catch {
+                    return [];
+                }
+            }
+        }
+
+        if (!Array.isArray(list)) {
+            return [];
+        }
+
+        const out = [];
+        for (const item of list) {
+            if (!isString(item)) continue;
+            const trimmed = item.trim();
+            if (!isNonEmptyString(trimmed)) continue;
+            out.push(trimmed);
+        }
+
+        return out;
+    }
+
+    assertMenuPathList(value) {
+        if (isNullable(value)) return [];
+
+        let list = value;
+
+        if (isString(list)) {
+            const trimmed = list.trim();
+            if (trimmed === "" || trimmed === "null") {
+                return [];
+            }
+
+            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                try {
+                    list = JSON.parse(trimmed);
+                } catch {
+                    return [];
+                }
+            }
+        }
+
+        if (!Array.isArray(list)) {
+            return [];
+        }
+
+        const out = [];
+        for (const item of list) {
+            if (!isString(item)) continue;
+            const trimmed = item.trim();
+            if (!isNonEmptyString(trimmed)) continue;
+            out.push(trimmed);
+        }
+
+        return out;
+    }
+
+    /**
+     * 缓存所有接口到 Redis
+     */
+    async cacheApis() {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.mysql.tableExists("beflyApi");
+            if (!tableExists.data) {
+                Logger.warn("⚠️ 接口表不存在，跳过接口缓存");
+                return;
+            }
+
+            // 从数据库查询所有接口
+            const apiList = await this.mysql.getAll({
+                table: "beflyApi"
+            });
+
+            // 缓存到 Redis
+            const result = await this.redis.setObject(CacheKeys.apisAll(), apiList.data.lists);
+
+            if (result === null) {
+                Logger.warn("⚠️ 接口缓存失败");
+            }
+        } catch (error) {
+            Logger.error("⚠️ 接口缓存异常", error);
+        }
+    }
+
+    /**
+     * 缓存所有菜单到 Redis（从数据库读取）
+     */
+    async cacheMenus() {
+        try {
+            // 检查表是否存在
+            const tableExists = await this.mysql.tableExists("beflyMenu");
+            if (!tableExists.data) {
+                Logger.warn("⚠️ 菜单表不存在，跳过菜单缓存");
+                return;
+            }
+
+            // 从数据库查询所有菜单
+            const menus = await this.mysql.getAll({
+                table: "beflyMenu"
+            });
+
+            // 缓存到 Redis
+            const result = await this.redis.setObject(CacheKeys.menusAll(), menus.data.lists);
+
+            if (result === null) {
+                Logger.warn("⚠️ 菜单缓存失败");
+            }
+        } catch (error) {
+            Logger.warn("⚠️ 菜单缓存异常", { err: error });
+        }
+    }
+
+    /**
+     * 缓存所有角色的接口权限到 Redis
+     * 全量重建：清理所有角色权限缓存并重建
+     * - 极简方案：每个角色一个 Set，直接覆盖更新（DEL + SADD）
+     */
+    async cacheRoleApis() {
+        try {
+            // 检查表是否存在
+            const roleTableExists = await this.mysql.tableExists("beflyRole");
+
+            if (!roleTableExists.data) {
+                Logger.warn("⚠️ 角色表不存在，跳过角色权限缓存");
+                return;
+            }
+
+            // 查询所有角色（仅取必要字段）
+            const roles = await this.mysql.getAll({
+                table: "beflyRole",
+                fields: ["code", "apis"]
+            });
+
+            const roleApiPathsMap = new Map();
+
+            for (const role of roles.data.lists) {
+                if (!role?.code) continue;
+                const apiPaths = this.assertApiPathList(role.apis);
+                roleApiPathsMap.set(role.code, apiPaths);
+            }
+
+            const roleCodes = Array.from(roleApiPathsMap.keys());
+            if (roleCodes.length === 0) {
+                Logger.info("✅ 没有需要缓存的角色权限");
+                return;
+            }
+
+            // 清理所有角色的缓存 key（保证幂等）
+            const roleKeys = roleCodes.map((code) => CacheKeys.roleApis(code));
+            await this.redis.delBatch(roleKeys);
+
+            // 批量写入新缓存（只写入非空权限）
+            const items = [];
+
+            for (const roleCode of roleCodes) {
+                const apiPaths = roleApiPathsMap.get(roleCode) || [];
+                const members = Array.from(new Set(apiPaths)).sort();
+
+                if (members.length > 0) {
+                    items.push({ key: CacheKeys.roleApis(roleCode), members: members });
+                }
+            }
+
+            if (items.length > 0) {
+                await this.redis.saddBatch(items);
+            }
+
+            // 极简方案不做版本/ready/meta：重建完成即生效
+        } catch (error) {
+            Logger.error("⚠️ 角色权限缓存异常（将阻断启动）", error);
+            throw new Error("⚠️ 角色权限缓存异常（将阻断启动）", {
+                cause: error,
+                code: "runtime",
+                subsystem: "cache",
+                operation: "cacheRoleApis"
+            });
+        }
+    }
+
+    /**
+     * 缓存所有角色的菜单权限到 Redis
+     * 全量重建：清理所有角色菜单权限缓存并重建
+     * - 每个角色一个 Set，直接覆盖更新（DEL + SADD）
+     */
+    async cacheRoleMenus() {
+        try {
+            // 检查表是否存在
+            const roleTableExists = await this.mysql.tableExists("beflyRole");
+
+            if (!roleTableExists.data) {
+                Logger.warn("⚠️ 角色表不存在，跳过角色菜单权限缓存");
+                return;
+            }
+
+            // 查询所有角色（仅取必要字段）
+            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;
+                const menuPaths = this.assertMenuPathList(role.menus);
+                roleMenuPathsMap.set(role.code, menuPaths);
+            }
+
+            const roleCodes = Array.from(roleMenuPathsMap.keys());
+            if (roleCodes.length === 0) {
+                Logger.info("✅ 没有需要缓存的角色菜单权限");
+                return;
+            }
+
+            // 清理所有角色的缓存 key（保证幂等）
+            const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
+            await this.redis.delBatch(roleKeys);
+
+            // 批量写入新缓存（只写入非空权限）
+            const items = [];
+
+            for (const roleCode of roleCodes) {
+                const menuPaths = roleMenuPathsMap.get(roleCode) || [];
+                const members = Array.from(new Set(menuPaths)).sort();
+
+                if (members.length > 0) {
+                    items.push({ key: CacheKeys.roleMenus(roleCode), members: members });
+                }
+            }
+
+            if (items.length > 0) {
+                await this.redis.saddBatch(items);
+            }
+        } catch (error) {
+            Logger.error("⚠️ 角色菜单权限缓存异常（将阻断启动）", error);
+            throw new Error("⚠️ 角色菜单权限缓存异常（将阻断启动）", {
+                cause: error,
+                code: "runtime",
+                subsystem: "cache",
+                operation: "cacheRoleMenus"
+            });
+        }
+    }
+
+    /**
+     * 增量刷新单个角色的接口权限缓存
+     * - apiIds 为空数组：仅清理缓存（防止残留）
+     * - apiIds 非空：使用 $in 最小查询，DEL 后 SADD
+     */
+    async refreshRoleApiPermissions(roleCode, apiPaths) {
+        if (!isNonEmptyString(roleCode)) {
+            return;
+        }
+        if (!Array.isArray(apiPaths)) {
+            return;
+        }
+
+        const normalizedPaths = this.assertApiPathList(apiPaths);
+        const roleKey = CacheKeys.roleApis(roleCode);
+
+        // 空数组短路：保证清理残留
+        if (normalizedPaths.length === 0) {
+            await this.redis.del(roleKey);
+            return;
+        }
+
+        const members = Array.from(new Set(normalizedPaths));
+
+        await this.redis.del(roleKey);
+        if (members.length > 0) {
+            await this.redis.sadd(roleKey, members);
+        }
+    }
+
+    /**
+     * 增量刷新单个角色的菜单权限缓存
+     * - menuPaths 为空数组：仅清理缓存（防止残留）
+     * - menuPaths 非空：DEL 后 SADD
+     */
+    async refreshRoleMenuPermissions(roleCode, menuPaths) {
+        if (!isNonEmptyString(roleCode)) {
+            return;
+        }
+        if (!Array.isArray(menuPaths)) {
+            return;
+        }
+
+        const normalizedPaths = this.assertMenuPathList(menuPaths);
+        const roleKey = CacheKeys.roleMenus(roleCode);
+
+        // 空数组短路：保证清理残留
+        if (normalizedPaths.length === 0) {
+            await this.redis.del(roleKey);
+            return;
+        }
+
+        const members = Array.from(new Set(normalizedPaths));
+
+        await this.redis.del(roleKey);
+        if (members.length > 0) {
+            await this.redis.sadd(roleKey, members);
+        }
+    }
+
+    /**
+     * 缓存所有数据
+     */
+    async cacheAll() {
+        // 1. 缓存接口
+        await this.cacheApis();
+
+        // 2. 缓存菜单
+        await this.cacheMenus();
+
+        // 3. 缓存角色权限
+        await this.cacheRoleApis();
+
+        // 4. 缓存角色菜单权限
+        await this.cacheRoleMenus();
+    }
+
+    /**
+     * 获取缓存的所有接口
+     * @returns 接口列表
+     */
+    async getApis() {
+        try {
+            const apis = await this.redis.getObject(CacheKeys.apisAll());
+            return apis || [];
+        } catch (error) {
+            Logger.error("获取接口缓存失败", error);
+            return [];
+        }
+    }
+
+    /**
+     * 获取缓存的所有菜单
+     * @returns 菜单列表
+     */
+    async getMenus() {
+        try {
+            const menus = await this.redis.getObject(CacheKeys.menusAll());
+            return menus || [];
+        } catch (error) {
+            Logger.error("获取菜单缓存失败", error);
+            return [];
+        }
+    }
+
+    /**
+     * 获取角色的接口权限
+     * @param roleCode - 角色代码
+     * @returns 接口路径列表
+     */
+    async getRolePermissions(roleCode) {
+        try {
+            const permissions = await this.redis.smembers(CacheKeys.roleApis(roleCode));
+            return permissions || [];
+        } catch (error) {
+            Logger.error("获取角色权限缓存失败", error, { roleCode: roleCode });
+            return [];
+        }
+    }
+
+    /**
+     * 获取角色的菜单权限
+     * @param roleCode - 角色代码
+     * @returns 菜单路径列表（menu.path）
+     */
+    async getRoleMenuPermissions(roleCode) {
+        try {
+            const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
+            return permissions || [];
+        } catch (error) {
+            Logger.error("获取角色菜单权限缓存失败", error, { roleCode: roleCode });
+            return [];
+        }
+    }
+
+    /**
+     * 检查角色是否有指定接口权限
+     * @param roleCode - 角色代码
+     * @param apiPath - 接口路径（url.pathname，例如 /api/user/login；与 method 无关）
+     * @returns 是否有权限
+     */
+    async checkRolePermission(roleCode, apiPath) {
+        try {
+            if (isNullable(apiPath)) return false;
+            const value = isString(apiPath) ? apiPath : String(apiPath);
+            return await this.redis.sismember(CacheKeys.roleApis(roleCode), value);
+        } catch (error) {
+            Logger.error("检查角色权限失败", error, { roleCode: roleCode });
+            return false;
+        }
+    }
+
+    /**
+     * 检查角色是否有指定菜单权限
+     * @param roleCode - 角色代码
+     * @param menuPath - 菜单路径（menu.path）
+     * @returns 是否有权限
+     */
+    async checkRoleMenuPermission(roleCode, menuPath) {
+        try {
+            if (isNullable(menuPath)) return false;
+            const value = isString(menuPath) ? menuPath : String(menuPath);
+            return await this.redis.sismember(CacheKeys.roleMenus(roleCode), value);
+        } catch (error) {
+            Logger.error("检查角色菜单权限失败", error, { roleCode: roleCode });
+            return false;
+        }
+    }
+
+    /**
+     * 删除角色的接口权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRolePermissions(roleCode) {
+        try {
+            const result = await this.redis.del(CacheKeys.roleApis(roleCode));
+            if (result > 0) {
+                Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
+                return true;
+            }
+            return false;
+        } catch (error) {
+            Logger.error("删除角色权限缓存失败", error, { roleCode: roleCode });
+            return false;
+        }
+    }
+
+    /**
+     * 删除角色的菜单权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRoleMenuPermissions(roleCode) {
+        try {
+            const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
+            if (result > 0) {
+                Logger.info(`✅ 已删除角色 ${roleCode} 的菜单权限缓存`);
+                return true;
+            }
+            return false;
+        } catch (error) {
+            Logger.error("删除角色菜单权限缓存失败", error, { roleCode: roleCode });
+            return false;
+        }
+    }
+}

package/lib/cacheKeys.js

@@ -0,0 +1,42 @@
+/**
+ * Cache Key 统一管理
+ * 所有缓存键在此统一定义，避免硬编码分散
+ */
+
+/**
+ * Cache Key 生成函数集合
+ */
+export class CacheKeys {
+    /** 所有接口缓存2 */
+    static apisAll() {
+        return "apis:all";
+    }
+
+    /** 所有菜单缓存 */
+    static menusAll() {
+        return "menus:all";
+    }
+
+    /** 角色信息缓存（完整角色对象） */
+    static roleInfo(roleCode) {
+        return `role:info:${roleCode}`;
+    }
+
+    /**
+     * 角色菜单权限缓存（Set 集合）
+     * - key: role:menus:${roleCode}
+     * - member: menu.path（例如 /permission/role）
+     */
+    static roleMenus(roleCode) {
+        return `role:menus:${roleCode}`;
+    }
+
+    /**
+     * 角色接口权限缓存（Set 集合）
+     * - key: role:apis:${roleCode}
+     * - member: url.pathname（例如 /api/user/login；与 method 无关）
+     */
+    static roleApis(roleCode) {
+        return `role:apis:${roleCode}`;
+    }
+}

package/lib/connect.js

@@ -0,0 +1,120 @@
+/**
+ * 连接管理器 - JavaScript 版本
+ * 负责管理数据库和 Redis 连接
+ */
+
+import { RedisClient, SQL } from "bun";
+import { Logger } from "./logger.js";
+
+/**
+ * 连接管理器
+ */
+export class Connect {
+    static mysqlClient = null;
+    static redisClient = null;
+
+    /**
+     * 获取数据库客户端
+     * @returns 数据库客户端
+     */
+    static getMysql() {
+        return this.mysqlClient;
+    }
+
+    /**
+     * 获取 Redis 客户端
+     * @returns Redis 客户端
+     */
+    static getRedis() {
+        return this.redisClient;
+    }
+
+    /**
+     * 连接数据库
+     * @param config - 数据库配置
+     */
+    static async connectMysql(config) {
+        try {
+            const sqlConfig = {
+                adapter: "mysql",
+                hostname: config.hostname,
+                port: config.port,
+                database: config.database,
+                username: config.username,
+                password: config.password,
+                max: config.max
+            };
+
+            this.mysqlClient = new SQL(sqlConfig);
+
+            await this.mysqlClient`SELECT 1`;
+            Logger.info("Mysql 连接成功");
+        } catch (error) {
+            await this.mysqlClient?.close();
+            this.mysqlClient = null;
+            Logger.error("Mysql 连接失败", error);
+            throw new Error("Mysql 连接失败", {
+                cause: error,
+                code: "runtime",
+                subsystem: "mysql",
+                operation: "connect"
+            });
+        }
+    }
+
+    /**
+     * 连接 Redis
+     * @param config - Redis 配置
+     */
+    static async connectRedis(config) {
+        try {
+            let authPart = "";
+            if (config.username) {
+                const encodedUser = encodeURIComponent(config.username);
+                const encodedPass = encodeURIComponent(config.password || "");
+                authPart = `${encodedUser}:${encodedPass}@`;
+            } else if (config.password) {
+                const encodedPass = encodeURIComponent(config.password);
+                authPart = `:${encodedPass}@`;
+            }
+
+            const redisUrl = `redis://${authPart}${config.hostname}:${config.port}/${config.db}`;
+
+            this.redisClient = new RedisClient(redisUrl);
+            // Called when successfully connected to Redis server
+            this.redisClient.onconnect = () => {
+                Logger.info("Redis 连接成功");
+            };
+
+            // Called when disconnected from Redis server
+            this.redisClient.onclose = (error) => {
+                Logger.warn("Redis 断开连接", {
+                    subsystem: "redis",
+                    operation: "onclose",
+                    cause: error
+                });
+            };
+        } catch (error) {
+            await this.redisClient?.close();
+            this.redisClient = null;
+            Logger.error("Redis 连接失败", error);
+            throw new Error("Redis 连接失败", {
+                cause: error,
+                code: "runtime",
+                subsystem: "redis",
+                operation: "connect"
+            });
+        }
+    }
+
+    /**
+     * 断开连接
+     */
+    static async disconnect() {
+        await this.mysqlClient?.close();
+        this.mysqlClient = null;
+
+        await this.redisClient?.close();
+        this.redisClient = null;
+    }
+}