befly 3.9.37 → 3.9.39

package/tests/cacheHelper.test.ts

@@ -1,12 +1,14 @@
 /**
  * CacheHelper 单元测试
  */
-import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
-import { CacheHelper } from '../lib/cacheHelper.js';
-import { Logger, setMockLogger } from '../lib/logger.js';
-import { RedisKeys } from 'befly-shared/redisKeys';
 
-import type { BeflyContext } from '../types/befly.js';
+import type { BeflyContext } from "../types/befly.js";
+
+import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
+
+import { CacheHelper } from "../lib/cacheHelper.js";
+import { CacheKeys } from "../lib/cacheKeys.js";
+import { setMockLogger } from "../lib/logger.js";
 
 // Mock pino logger
 const mockPino = {
@@ -18,10 +20,10 @@ const mockPino = {
     trace: mock(() => {}),
     silent: mock(() => {}),
     child: mock(() => mockPino),
-    level: 'info'
+    level: "info"
 };
 
-describe('CacheHelper', () => {
+describe("CacheHelper", () => {
     let cacheHelper: CacheHelper;
     let mockBefly: BeflyContext;
     let mockDb: any;
@@ -34,17 +36,20 @@ describe('CacheHelper', () => {
         // Mock 数据库方法
         mockDb = {
             tableExists: mock(() => Promise.resolve(true)),
-            getAll: mock(() => Promise.resolve([]))
+            getAll: mock(() => Promise.resolve({ lists: [], total: 0 }))
         };
 
         // Mock Redis 方法
         mockRedis = {
-            setObject: mock(() => Promise.resolve('OK')),
+            setObject: mock(() => Promise.resolve("OK")),
             getObject: mock(() => Promise.resolve(null)),
             sadd: mock(() => Promise.resolve(1)),
+            saddBatch: mock(() => Promise.resolve(1)),
             smembers: mock(() => Promise.resolve([])),
             sismember: mock(() => Promise.resolve(0)),
-            del: mock(() => Promise.resolve(1))
+            del: mock(() => Promise.resolve(1)),
+            delBatch: mock(() => Promise.resolve(1)),
+            exists: mock(() => Promise.resolve(true))
         };
 
         // 创建 mock befly context
@@ -61,29 +66,29 @@ describe('CacheHelper', () => {
         setMockLogger(null);
     });
 
-    describe('cacheApis', () => {
-        it('表不存在时跳过缓存', async () => {
+    describe("cacheApis", () => {
+        it("表不存在时跳过缓存", async () => {
             mockDb.tableExists = mock(() => Promise.resolve(false));
 
             await cacheHelper.cacheApis();
 
-            expect(mockDb.tableExists).toHaveBeenCalledWith('addon_admin_api');
+            expect(mockDb.tableExists).toHaveBeenCalledWith("addon_admin_api");
             expect(mockDb.getAll).not.toHaveBeenCalled();
         });
 
-        it('正常缓存接口列表', async () => {
+        it("正常缓存接口列表", async () => {
             const apis = [
-                { id: 1, name: '登录', path: '/api/login', method: 'POST' },
-                { id: 2, name: '用户列表', path: '/api/user/list', method: 'GET' }
+                { id: 1, name: "登录", path: "/api/login", method: "POST" },
+                { id: 2, name: "用户列表", path: "/api/user/list", method: "GET" }
             ];
             mockDb.getAll = mock(() => Promise.resolve({ lists: apis, total: apis.length }));
 
             await cacheHelper.cacheApis();
 
-            expect(mockRedis.setObject).toHaveBeenCalledWith(RedisKeys.apisAll(), apis);
+            expect(mockRedis.setObject).toHaveBeenCalledWith(CacheKeys.apisAll(), apis);
         });
 
-        it('缓存失败时记录警告', async () => {
+        it("缓存失败时记录警告", async () => {
             mockRedis.setObject = mock(() => Promise.resolve(null));
 
             await cacheHelper.cacheApis();
@@ -91,8 +96,8 @@ describe('CacheHelper', () => {
             expect(mockPino.warn).toHaveBeenCalled();
         });
 
-        it('异常时记录错误', async () => {
-            mockDb.getAll = mock(() => Promise.reject(new Error('DB Error')));
+        it("异常时记录错误", async () => {
+            mockDb.getAll = mock(() => Promise.reject(new Error("DB Error")));
 
             await cacheHelper.cacheApis();
 
@@ -100,110 +105,136 @@ describe('CacheHelper', () => {
         });
     });
 
-    describe('cacheMenus', () => {
-        it('表不存在时跳过缓存', async () => {
+    describe("cacheMenus", () => {
+        it("表不存在时跳过缓存", async () => {
             mockDb.tableExists = mock(() => Promise.resolve(false));
 
             await cacheHelper.cacheMenus();
 
-            expect(mockDb.tableExists).toHaveBeenCalledWith('addon_admin_menu');
+            expect(mockDb.tableExists).toHaveBeenCalledWith("addon_admin_menu");
             expect(mockDb.getAll).not.toHaveBeenCalled();
         });
 
-        it('正常缓存菜单列表', async () => {
+        it("正常缓存菜单列表", async () => {
             const menus = [
-                { id: 1, pid: 0, name: '首页', path: '/home', sort: 1 },
-                { id: 2, pid: 0, name: '用户管理', path: '/user', sort: 2 }
+                { id: 1, pid: 0, name: "首页", path: "/home", sort: 1 },
+                { id: 2, pid: 0, name: "用户管理", path: "/user", sort: 2 }
             ];
             mockDb.getAll = mock(() => Promise.resolve({ lists: menus, total: menus.length }));
 
             await cacheHelper.cacheMenus();
 
-            expect(mockRedis.setObject).toHaveBeenCalledWith(RedisKeys.menusAll(), menus);
+            expect(mockRedis.setObject).toHaveBeenCalledWith(CacheKeys.menusAll(), menus);
         });
     });
 
-    describe('cacheRolePermissions', () => {
-        it('表不存在时跳过缓存', async () => {
+    describe("rebuildRoleApiPermissions", () => {
+        it("表不存在时跳过缓存", async () => {
             mockDb.tableExists = mock((table: string) => {
-                if (table === 'addon_admin_api') return Promise.resolve(true);
-                if (table === 'addon_admin_role') return Promise.resolve(false);
+                if (table === "addon_admin_api") return Promise.resolve(true);
+                if (table === "addon_admin_role") return Promise.resolve(false);
                 return Promise.resolve(false);
             });
 
-            await cacheHelper.cacheRolePermissions();
+            await cacheHelper.rebuildRoleApiPermissions();
 
             expect(mockPino.warn).toHaveBeenCalled();
         });
 
-        it('正常缓存角色权限', async () => {
+        it("正常重建角色权限（覆盖更新）", async () => {
             const roles = [
-                { id: 1, code: 'admin', apis: '1,2,3' },
-                { id: 2, code: 'user', apis: '1' }
+                { id: 1, code: "admin", apis: [1, "2", 3] },
+                { id: 2, code: "user", apis: [1] }
             ];
             const apis = [
-                { id: 1, path: '/api/login', method: 'POST' },
-                { id: 2, path: '/api/user/list', method: 'GET' },
-                { id: 3, path: '/api/user/del', method: 'POST' }
+                { id: 1, path: "/api/login", method: "POST" },
+                { id: 2, path: "/api/user/list", method: "GET" },
+                { id: 3, path: "/api/user/del", method: "POST" }
             ];
 
             mockDb.getAll = mock((opts: any) => {
-                if (opts.table === 'addon_admin_role') return Promise.resolve({ lists: roles, total: roles.length });
-                if (opts.table === 'addon_admin_api') return Promise.resolve({ lists: apis, total: apis.length });
+                if (opts.table === "addon_admin_role") return Promise.resolve({ lists: roles, total: roles.length });
+                if (opts.table === "addon_admin_api") {
+                    // rebuildRoleApiPermissions 会通过 where: { id$in: [...] } 分块查询
+                    return Promise.resolve({ lists: apis, total: apis.length });
+                }
                 return Promise.resolve({ lists: [], total: 0 });
             });
 
-            await cacheHelper.cacheRolePermissions();
-
-            // 验证批量删除调用
-            expect(mockRedis.del).toHaveBeenCalledTimes(2);
-
-            // 验证批量添加调用
-            expect(mockRedis.sadd).toHaveBeenCalledTimes(2);
-            expect(mockRedis.sadd).toHaveBeenCalledWith(RedisKeys.roleApis('admin'), ['POST/api/login', 'GET/api/user/list', 'POST/api/user/del']);
-            expect(mockRedis.sadd).toHaveBeenCalledWith(RedisKeys.roleApis('user'), ['POST/api/login']);
+            await cacheHelper.rebuildRoleApiPermissions();
+
+            // 验证批量删除角色 key
+            expect(mockRedis.delBatch).toHaveBeenCalledTimes(1);
+            const delBatchArgs = (mockRedis.delBatch as any).mock.calls[0][0] as string[];
+            expect(delBatchArgs).toEqual([CacheKeys.roleApis("admin"), CacheKeys.roleApis("user")]);
+
+            // 验证批量写入
+            expect(mockRedis.saddBatch).toHaveBeenCalledTimes(1);
+            const saddBatchArgs = (mockRedis.saddBatch as any).mock.calls[0][0] as Array<{
+                key: string;
+                members: string[];
+            }>;
+            expect(saddBatchArgs).toEqual([
+                {
+                    key: CacheKeys.roleApis("admin"),
+                    members: ["GET/api/user/list", "POST/api/login", "POST/api/user/del"]
+                },
+                { key: CacheKeys.roleApis("user"), members: ["POST/api/login"] }
+            ]);
         });
 
-        it('无有效角色时不执行缓存', async () => {
-            const roles = [{ id: 1, code: 'empty', apis: null }];
-            const apis = [{ id: 1, path: '/api/login', method: 'POST' }];
+        it("无权限时仍会清理旧缓存，但不写入成员", async () => {
+            const roles = [{ id: 1, code: "empty", apis: [] }];
+            const apis = [{ id: 1, path: "/api/login", method: "POST" }];
 
             mockDb.getAll = mock((opts: any) => {
-                if (opts.table === 'addon_admin_role') return Promise.resolve({ lists: roles, total: roles.length });
-                if (opts.table === 'addon_admin_api') return Promise.resolve({ lists: apis, total: apis.length });
+                if (opts.table === "addon_admin_role") return Promise.resolve({ lists: roles, total: roles.length });
+                if (opts.table === "addon_admin_api") return Promise.resolve({ lists: apis, total: apis.length });
                 return Promise.resolve({ lists: [], total: 0 });
             });
 
-            await cacheHelper.cacheRolePermissions();
+            await cacheHelper.rebuildRoleApiPermissions();
 
-            expect(mockRedis.sadd).not.toHaveBeenCalled();
+            expect(mockRedis.delBatch).toHaveBeenCalledTimes(1);
+            expect(mockRedis.saddBatch).not.toHaveBeenCalled();
         });
+    });
 
-        it('使用 Promise.all 并行执行', async () => {
-            const roles = [
-                { id: 1, code: 'role1', apis: '1' },
-                { id: 2, code: 'role2', apis: '1' },
-                { id: 3, code: 'role3', apis: '1' }
+    describe("refreshRoleApiPermissions", () => {
+        it("apiIds 为空数组时只清理缓存，不查询 API 表", async () => {
+            mockDb.getAll = mock(() => Promise.resolve({ lists: [], total: 0 }));
+
+            await cacheHelper.refreshRoleApiPermissions("admin", []);
+
+            expect(mockRedis.del).toHaveBeenCalledWith(CacheKeys.roleApis("admin"));
+            expect(mockDb.getAll).not.toHaveBeenCalledWith(
+                expect.objectContaining({
+                    table: "addon_admin_api"
+                })
+            );
+        });
+
+        it("apiIds 非空时使用 $in 查询并重建该角色缓存（覆盖更新）", async () => {
+            const apis = [
+                { id: 1, path: "/api/login", method: "POST" },
+                { id: 2, path: "/api/user/list", method: "GET" }
             ];
-            const apis = [{ id: 1, path: '/api/test', method: 'GET' }];
 
             mockDb.getAll = mock((opts: any) => {
-                if (opts.table === 'addon_admin_role') return Promise.resolve({ lists: roles, total: roles.length });
-                if (opts.table === 'addon_admin_api') return Promise.resolve({ lists: apis, total: apis.length });
+                if (opts.table === "addon_admin_api") return Promise.resolve({ lists: apis, total: apis.length });
                 return Promise.resolve({ lists: [], total: 0 });
             });
 
-            await cacheHelper.cacheRolePermissions();
+            await cacheHelper.refreshRoleApiPermissions("admin", [1, 2]);
 
-            // 3 个角色应该有 3 次删除和 3 次添加操作
-            expect(mockRedis.del).toHaveBeenCalledTimes(3);
-            expect(mockRedis.sadd).toHaveBeenCalledTimes(3);
+            expect(mockRedis.del).toHaveBeenCalledWith(CacheKeys.roleApis("admin"));
+            expect(mockRedis.sadd).toHaveBeenCalledWith(CacheKeys.roleApis("admin"), ["POST/api/login", "GET/api/user/list"]);
         });
     });
 
-    describe('getApis', () => {
-        it('返回缓存的接口列表', async () => {
-            const apis = [{ id: 1, name: '登录' }];
+    describe("getApis", () => {
+        it("返回缓存的接口列表", async () => {
+            const apis = [{ id: 1, name: "登录" }];
             mockRedis.getObject = mock(() => Promise.resolve(apis));
 
             const result = await cacheHelper.getApis();
@@ -211,7 +242,7 @@ describe('CacheHelper', () => {
             expect(result).toEqual(apis);
         });
 
-        it('缓存不存在时返回空数组', async () => {
+        it("缓存不存在时返回空数组", async () => {
             mockRedis.getObject = mock(() => Promise.resolve(null));
 
             const result = await cacheHelper.getApis();
@@ -220,9 +251,9 @@ describe('CacheHelper', () => {
         });
     });
 
-    describe('getMenus', () => {
-        it('返回缓存的菜单列表', async () => {
-            const menus = [{ id: 1, name: '首页' }];
+    describe("getMenus", () => {
+        it("返回缓存的菜单列表", async () => {
+            const menus = [{ id: 1, name: "首页" }];
             mockRedis.getObject = mock(() => Promise.resolve(menus));
 
             const result = await cacheHelper.getMenus();
@@ -230,7 +261,7 @@ describe('CacheHelper', () => {
             expect(result).toEqual(menus);
         });
 
-        it('缓存不存在时返回空数组', async () => {
+        it("缓存不存在时返回空数组", async () => {
             mockRedis.getObject = mock(() => Promise.resolve(null));
 
             const result = await cacheHelper.getMenus();
@@ -239,89 +270,89 @@ describe('CacheHelper', () => {
         });
     });
 
-    describe('getRolePermissions', () => {
-        it('返回角色的权限列表', async () => {
-            const permissions = ['POST/api/login', 'GET/api/user/list'];
+    describe("getRolePermissions", () => {
+        it("返回角色的权限列表", async () => {
+            const permissions = ["POST/api/login", "GET/api/user/list"];
             mockRedis.smembers = mock(() => Promise.resolve(permissions));
 
-            const result = await cacheHelper.getRolePermissions('admin');
+            const result = await cacheHelper.getRolePermissions("admin");
 
-            expect(mockRedis.smembers).toHaveBeenCalledWith(RedisKeys.roleApis('admin'));
+            expect(mockRedis.smembers).toHaveBeenCalledWith(CacheKeys.roleApis("admin"));
             expect(result).toEqual(permissions);
         });
 
-        it('权限不存在时返回空数组', async () => {
+        it("权限不存在时返回空数组", async () => {
             mockRedis.smembers = mock(() => Promise.resolve(null));
 
-            const result = await cacheHelper.getRolePermissions('unknown');
+            const result = await cacheHelper.getRolePermissions("unknown");
 
             expect(result).toEqual([]);
         });
     });
 
-    describe('checkRolePermission', () => {
-        it('有权限时返回 true', async () => {
+    describe("checkRolePermission", () => {
+        it("有权限时返回 true", async () => {
             mockRedis.sismember = mock(() => Promise.resolve(true));
 
-            const result = await cacheHelper.checkRolePermission('admin', 'POST/api/login');
+            const result = await cacheHelper.checkRolePermission("admin", "POST/api/login");
 
-            expect(mockRedis.sismember).toHaveBeenCalledWith(RedisKeys.roleApis('admin'), 'POST/api/login');
+            expect(mockRedis.sismember).toHaveBeenCalledWith(CacheKeys.roleApis("admin"), "POST/api/login");
             expect(result).toBe(true);
         });
 
-        it('无权限时返回 false', async () => {
+        it("无权限时返回 false", async () => {
             mockRedis.sismember = mock(() => Promise.resolve(false));
 
-            const result = await cacheHelper.checkRolePermission('user', 'POST/api/admin/del');
+            const result = await cacheHelper.checkRolePermission("user", "POST/api/admin/del");
 
             expect(result).toBe(false);
         });
     });
 
-    describe('deleteRolePermissions', () => {
-        it('删除成功返回 true', async () => {
+    describe("deleteRolePermissions", () => {
+        it("删除成功返回 true", async () => {
             mockRedis.del = mock(() => Promise.resolve(1));
 
-            const result = await cacheHelper.deleteRolePermissions('admin');
+            const result = await cacheHelper.deleteRolePermissions("admin");
 
-            expect(mockRedis.del).toHaveBeenCalledWith(RedisKeys.roleApis('admin'));
+            expect(mockRedis.del).toHaveBeenCalledWith(CacheKeys.roleApis("admin"));
             expect(result).toBe(true);
         });
 
-        it('不存在时返回 false', async () => {
+        it("不存在时返回 false", async () => {
             mockRedis.del = mock(() => Promise.resolve(0));
 
-            const result = await cacheHelper.deleteRolePermissions('unknown');
+            const result = await cacheHelper.deleteRolePermissions("unknown");
 
             expect(result).toBe(false);
         });
     });
 
-    describe('cacheAll', () => {
-        it('按顺序调用三个缓存方法', async () => {
+    describe("cacheAll", () => {
+        it("按顺序调用三个缓存方法", async () => {
             const callOrder: string[] = [];
 
             // 使用 spy 记录调用顺序
             const originalCacheApis = cacheHelper.cacheApis.bind(cacheHelper);
             const originalCacheMenus = cacheHelper.cacheMenus.bind(cacheHelper);
-            const originalCacheRolePermissions = cacheHelper.cacheRolePermissions.bind(cacheHelper);
+            const originalRebuildRoleApiPermissions = cacheHelper.rebuildRoleApiPermissions.bind(cacheHelper);
 
             cacheHelper.cacheApis = async () => {
-                callOrder.push('apis');
+                callOrder.push("apis");
                 await originalCacheApis();
             };
             cacheHelper.cacheMenus = async () => {
-                callOrder.push('menus');
+                callOrder.push("menus");
                 await originalCacheMenus();
             };
-            cacheHelper.cacheRolePermissions = async () => {
-                callOrder.push('permissions');
-                await originalCacheRolePermissions();
+            cacheHelper.rebuildRoleApiPermissions = async () => {
+                callOrder.push("permissions");
+                await originalRebuildRoleApiPermissions();
             };
 
             await cacheHelper.cacheAll();
 
-            expect(callOrder).toEqual(['apis', 'menus', 'permissions']);
+            expect(callOrder).toEqual(["apis", "menus", "permissions"]);
         });
     });
 });

package/tests/cacheKeys.test.ts

@@ -0,0 +1,41 @@
+/**
+ * CacheKeys 测试
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { CacheKeys } from "../lib/cacheKeys.js";
+
+describe("CacheKeys - Key 生成函数", () => {
+    test("apisAll - 返回固定的接口缓存键", () => {
+        expect(CacheKeys.apisAll()).toBe("befly:apis:all");
+    });
+
+    test("menusAll - 返回固定的菜单缓存键", () => {
+        expect(CacheKeys.menusAll()).toBe("befly:menus:all");
+    });
+
+    test("roleInfo - 返回带角色代码的缓存键", () => {
+        expect(CacheKeys.roleInfo("admin")).toBe("befly:role:info:admin");
+        expect(CacheKeys.roleInfo("user")).toBe("befly:role:info:user");
+    });
+
+    test("roleApis - 返回带角色代码的权限缓存键", () => {
+        expect(CacheKeys.roleApis("admin")).toBe("befly:role:apis:admin");
+        expect(CacheKeys.roleApis("guest")).toBe("befly:role:apis:guest");
+    });
+
+    test("tableColumns - 返回带表名的结构缓存键", () => {
+        expect(CacheKeys.tableColumns("user")).toBe("befly:table:columns:user");
+        expect(CacheKeys.tableColumns("addon_admin_role")).toBe("befly:table:columns:addon_admin_role");
+    });
+
+    test("roleInfo - 特殊字符处理", () => {
+        expect(CacheKeys.roleInfo("super-admin")).toBe("befly:role:info:super-admin");
+        expect(CacheKeys.roleInfo("role_1")).toBe("befly:role:info:role_1");
+    });
+
+    test("tableColumns - 空字符串", () => {
+        expect(CacheKeys.tableColumns("")).toBe("befly:table:columns:");
+    });
+});