@befly-addon/admin 1.1.30 → 1.1.31

package/apis/admin/cacheRefresh.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * 刷新全部缓存接口
  *
  * 功能：
@@ -12,40 +12,39 @@
  * - 缓存出现异常需要重建
  */
 
-import { RedisKeys } from 'befly-shared/redisKeys';
+import { CacheKeys } from "befly/lib/cacheKeys";
 
 export default {
-    name: '刷新全部缓存',
-    handler: async (befly, ctx) => {
+    name: "刷新全部缓存",
+    handler: async (befly, _ctx) => {
         try {
             const results: Record<string, any> = {
                 apis: { success: false, count: 0 },
                 menus: { success: false, count: 0 },
-                roles: { success: false, count: 0 }
+                roles: { success: false, count: 0 },
+                roleApiPermissions: { success: false }
             };
 
             // 1. 刷新接口缓存
             try {
                 const apis = await befly.db.getAll({
-                    table: 'addon_admin_api',
-                    orderBy: ['addonName#ASC', 'path#ASC']
+                    table: "addon_admin_api"
                 });
 
-                await befly.redis.setObject(RedisKeys.apisAll(), apis.lists);
+                await befly.redis.setObject(CacheKeys.apisAll(), apis.lists);
                 results.apis = { success: true, count: apis.lists.length };
             } catch (error: any) {
-                befly.logger.error({ err: error }, '刷新接口缓存失败');
+                befly.logger.error({ err: error }, "刷新接口缓存失败");
                 results.apis = { success: false, error: error.message };
             }
 
             // 2. 刷新菜单缓存
             try {
                 const menus = await befly.db.getAll({
-                    table: 'addon_admin_menu',
-                    orderBy: ['sort#ASC', 'id#ASC']
+                    table: "addon_admin_menu"
                 });
 
-                await befly.redis.setObject(RedisKeys.menusAll(), menus.lists);
+                await befly.redis.setObject(CacheKeys.menusAll(), menus.lists);
 
                 const parentCount = menus.lists.filter((m: any) => m.pid === 0).length;
                 const childCount = menus.lists.filter((m: any) => m.pid !== 0).length;
@@ -57,41 +56,50 @@ export default {
                     childCount: childCount
                 };
             } catch (error: any) {
-                befly.logger.error({ err: error }, '刷新菜单缓存失败');
+                befly.logger.error({ err: error }, "刷新菜单缓存失败");
                 results.menus = { success: false, error: error.message };
             }
 
             // 3. 刷新角色权限缓存
             try {
                 const roles = await befly.db.getAll({
-                    table: 'addon_admin_role'
+                    table: "addon_admin_role"
                 });
 
                 // 使用 setBatch 批量缓存所有角色
                 const count = await befly.redis.setBatch(
                     roles.lists.map((role: any) => ({
-                        key: RedisKeys.roleInfo(role.code),
+                        key: CacheKeys.roleInfo(role.code),
                         value: role
                     }))
                 );
 
                 results.roles = { success: true, count: count };
             } catch (error: any) {
-                befly.logger.error({ err: error }, '刷新角色缓存失败');
+                befly.logger.error({ err: error }, "刷新角色缓存失败");
                 results.roles = { success: false, error: error.message };
             }
 
+            // 4. 重建角色接口权限缓存（版本化 + 原子切换）
+            try {
+                await befly.cache.rebuildRoleApiPermissions();
+                results.roleApiPermissions = { success: true };
+            } catch (error: any) {
+                befly.logger.error({ err: error }, "重建角色接口权限缓存失败");
+                results.roleApiPermissions = { success: false, error: error.message };
+            }
+
             // 检查是否全部成功
-            const allSuccess = results.apis.success && results.menus.success && results.roles.success;
+            const allSuccess = results.apis.success && results.menus.success && results.roles.success && results.roleApiPermissions.success;
 
             if (allSuccess) {
-                return befly.tool.Yes('全部缓存刷新成功', results);
+                return befly.tool.Yes("全部缓存刷新成功", results);
             } else {
-                return befly.tool.No('部分缓存刷新失败', results);
+                return befly.tool.No("部分缓存刷新失败", results);
             }
         } catch (error: any) {
-            befly.logger.error({ err: error }, '刷新全部缓存失败');
-            return befly.tool.No('刷新全部缓存失败', { error: error.message });
+            befly.logger.error({ err: error }, "刷新全部缓存失败");
+            return befly.tool.No("刷新全部缓存失败", { error: error.message });
         }
     }
 };

package/apis/admin/del.ts

@@ -1,31 +1,31 @@
-export default {
-    name: '删除管理员',
+export default {
+    name: "删除管理员",
     fields: {
-        id: '@id'
+        id: "@id"
     },
-    required: ['id'],
+    required: ["id"],
     handler: async (befly, ctx) => {
         // 检查管理员是否存在
         const adminData = await befly.db.getOne({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             where: { id: ctx.body.id }
         });
 
         if (!adminData?.id) {
-            return befly.tool.No('管理员不存在');
+            return befly.tool.No("管理员不存在");
         }
 
         // 不能删除 dev 角色的管理员
-        if (adminData.roleCode === 'dev') {
-            return befly.tool.No('不能删除开发管理员');
+        if (adminData.roleCode === "dev") {
+            return befly.tool.No("不能删除开发管理员");
         }
 
         // 删除管理员
         await befly.db.delData({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             where: { id: ctx.body.id }
         });
 
-        return befly.tool.Yes('删除成功');
+        return befly.tool.Yes("删除成功");
     }
 };

package/apis/admin/detail.ts

@@ -1,19 +1,19 @@
-export default {
-    name: '获取管理员信息',
+export default {
+    name: "获取管理员信息",
     fields: {
-        id: '@id'
+        id: "@id"
     },
     handler: async (befly, ctx) => {
         const adminData = await befly.db.getOne({
-            table: 'addon_admin_admin',
-            fields: ['!password'],
+            table: "addon_admin_admin",
+            fields: ["!password"],
             where: { id: ctx.user?.id }
         });
 
         if (!adminData?.id) {
-            return befly.tool.No('管理员不存在');
+            return befly.tool.No("管理员不存在");
         }
 
-        return befly.tool.Yes('查询成功', adminData);
+        return befly.tool.Yes("查询成功", adminData);
     }
 };

package/apis/admin/ins.ts

@@ -1,40 +1,40 @@
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '添加管理员',
+    name: "添加管理员",
     fields: adminTable,
-    required: ['username', 'password', 'roleCode'],
+    required: ["username", "password", "roleCode"],
     handler: async (befly, ctx) => {
         // 检查用户名是否已存在
         const existingByUsername = await befly.db.getOne({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             where: { username: ctx.body.username }
         });
 
         if (existingByUsername?.id) {
-            return befly.tool.No('用户名已被使用');
+            return befly.tool.No("用户名已被使用");
         }
 
         // 检查昵称是否已存在
         if (ctx.body.nickname) {
             const existingByNickname = await befly.db.getOne({
-                table: 'addon_admin_admin',
+                table: "addon_admin_admin",
                 where: { nickname: ctx.body.nickname }
             });
 
             if (existingByNickname?.id) {
-                return befly.tool.No('昵称已被使用');
+                return befly.tool.No("昵称已被使用");
             }
         }
 
         // 查询角色信息
         const roleData = await befly.db.getOne({
-            table: 'addon_admin_role',
+            table: "addon_admin_role",
             where: { code: ctx.body.roleCode }
         });
 
         if (!roleData?.id) {
-            return befly.tool.No('角色不存在');
+            return befly.tool.No("角色不存在");
         }
 
         // 加密密码
@@ -42,7 +42,7 @@ export default {
 
         // 创建管理员
         const adminId = await befly.db.insData({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             data: {
                 username: ctx.body.username,
                 password: hashedPassword,
@@ -51,7 +51,7 @@ export default {
             }
         });
 
-        return befly.tool.Yes('添加成功', {
+        return befly.tool.Yes("添加成功", {
             id: adminId
         });
     }

package/apis/admin/list.ts

@@ -1,24 +1,24 @@
-export default {
-    name: '查询管理员列表',
+export default {
+    name: "查询管理员列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
     },
     handler: async (befly, ctx) => {
         const result = await befly.db.getList({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             page: ctx.body.page,
             limit: ctx.body.limit,
             where: {
                 roleCode: {
-                    $ne: 'dev'
+                    $ne: "dev"
                 }
             },
-            orderBy: ['createdAt#DESC']
+            orderBy: ["createdAt#DESC"]
         });
 
-        return befly.tool.Yes('获取成功', result);
+        return befly.tool.Yes("获取成功", result);
     }
 };

package/apis/admin/upd.ts

@@ -1,52 +1,52 @@
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '更新管理员',
-    fields: { id: '@id', ...adminTable },
-    required: ['id'],
+    name: "更新管理员",
+    fields: { id: "@id", ...adminTable },
+    required: ["id"],
     handler: async (befly, ctx) => {
         const { id, username, nickname, roleCode, ...updateData } = ctx.body;
 
         // 检查管理员是否存在
         const admin = await befly.db.getOne({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             where: { id }
         });
 
         if (!admin?.id) {
-            return befly.tool.No('管理员不存在');
+            return befly.tool.No("管理员不存在");
         }
 
         // 检查用户名是否已被其他管理员使用
         if (username && username !== admin.username) {
             const existingUsername = await befly.db.getOne({
-                table: 'addon_admin_admin',
+                table: "addon_admin_admin",
                 where: { username, id: { $ne: id } }
             });
             if (existingUsername?.id) {
-                return befly.tool.No('用户名已被使用');
+                return befly.tool.No("用户名已被使用");
             }
         }
 
         // 检查昵称是否已被其他管理员使用
         if (nickname && nickname !== admin.nickname) {
             const existingNickname = await befly.db.getOne({
-                table: 'addon_admin_admin',
+                table: "addon_admin_admin",
                 where: { nickname, id: { $ne: id } }
             });
             if (existingNickname?.id) {
-                return befly.tool.No('昵称已被使用');
+                return befly.tool.No("昵称已被使用");
             }
         }
 
         // 检查角色是否存在
         if (roleCode && roleCode !== admin.roleCode) {
             const role = await befly.db.getOne({
-                table: 'addon_admin_role',
+                table: "addon_admin_role",
                 where: { code: roleCode }
             });
             if (!role?.id) {
-                return befly.tool.No('角色不存在');
+                return befly.tool.No("角色不存在");
             }
         }
 
@@ -58,11 +58,11 @@ export default {
 
         // 更新管理员信息
         await befly.db.updData({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             data: dataToUpdate,
             where: { id }
         });
 
-        return befly.tool.Yes('更新成功');
+        return befly.tool.Yes("更新成功");
     }
 };

package/apis/api/all.ts

@@ -1,6 +1,6 @@
-export default {
-    name: '获取所有接口',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取所有接口",
+    handler: async (befly) => {
         try {
             // 从缓存获取所有接口
             let allApis = await befly.cache.getApis();
@@ -8,8 +8,8 @@
             // 如果缓存不存在，从数据库查询并缓存
             if (allApis.length === 0) {
                 const result = await befly.db.getAll({
-                    table: 'addon_admin_api',
-                    orderBy: ['id#ASC']
+                    table: "addon_admin_api",
+                    orderBy: ["id#ASC"]
                 });
                 allApis = result.lists;
 
@@ -19,10 +19,10 @@
                 }
             }
 
-            return befly.tool.Yes('操作成功', { lists: allApis });
+            return befly.tool.Yes("操作成功", { lists: allApis });
         } catch (error: any) {
-            befly.logger.error({ err: error }, '获取接口列表失败');
-            return befly.tool.No('获取接口列表失败');
+            befly.logger.error({ err: error }, "获取接口列表失败");
+            return befly.tool.No("获取接口列表失败");
         }
     }
 };

package/apis/api/list.ts

@@ -1,27 +1,27 @@
 export default {
-    name: '获取接口列表',
+    name: "获取接口列表",
     fields: {
-        page: '@page',
-        limit: '@limit',
-        keyword: '@keyword',
-        state: '@state'
+        page: "@page",
+        limit: "@limit",
+        keyword: "@keyword",
+        state: "@state"
     },
     handler: async (befly, ctx) => {
         try {
             const result = await befly.db.getList({
-                table: 'addon_admin_api',
+                table: "addon_admin_api",
                 where: {
                     $or: ctx.body.keyword ? [{ name$like: `%${ctx.body.keyword}%` }, { path$like: `%${ctx.body.keyword}%` }] : undefined
                 },
-                orderBy: ['id#ASC'],
+                orderBy: ["id#ASC"],
                 page: ctx.body.page,
                 limit: ctx.body.limit
             });
 
-            return befly.tool.Yes('操作成功', result);
+            return befly.tool.Yes("操作成功", result);
         } catch (error: any) {
-            befly.logger.error({ err: error }, '获取接口列表失败');
-            return befly.tool.No('获取接口列表失败');
+            befly.logger.error({ err: error }, "获取接口列表失败");
+            return befly.tool.No("获取接口列表失败");
         }
     }
 };

package/apis/auth/login.ts

@@ -1,103 +1,103 @@
-import { UAParser } from 'ua-parser-js';
+import { UAParser } from "ua-parser-js";
 
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '管理员登录',
+    name: "管理员登录",
     auth: false,
     fields: {
         account: {
-            name: '账号',
-            type: 'string',
+            name: "账号",
+            type: "string",
             min: 3,
             max: 100
         },
         password: adminTable.password,
         loginType: {
-            name: '登录类型',
-            type: 'string',
-            regexp: '^(username|email|phone)$'
+            name: "登录类型",
+            type: "string",
+            regexp: "^(username|email|phone)$"
         }
     },
-    required: ['account', 'password', 'loginType'],
+    required: ["account", "password", "loginType"],
     handler: async (befly, ctx) => {
         // 解析 User-Agent
-        const userAgent = ctx.req.headers.get('user-agent') || '';
+        const userAgent = ctx.req.headers.get("user-agent") || "";
         const uaResult = UAParser(userAgent);
 
         // 日志数据（公共部分）
         const logData = {
             adminId: 0,
             username: ctx.body.account,
-            nickname: '',
-            ip: ctx.ip || 'unknown',
+            nickname: "",
+            ip: ctx.ip || "unknown",
             userAgent: userAgent.substring(0, 500),
-            browserName: uaResult.browser.name || '',
-            browserVersion: uaResult.browser.version || '',
-            osName: uaResult.os.name || '',
-            osVersion: uaResult.os.version || '',
-            deviceType: uaResult.device.type || 'desktop',
-            deviceVendor: uaResult.device.vendor || '',
-            deviceModel: uaResult.device.model || '',
-            engineName: uaResult.engine.name || '',
-            cpuArchitecture: uaResult.cpu.architecture || '',
+            browserName: uaResult.browser.name || "",
+            browserVersion: uaResult.browser.version || "",
+            osName: uaResult.os.name || "",
+            osVersion: uaResult.os.version || "",
+            deviceType: uaResult.device.type || "desktop",
+            deviceVendor: uaResult.device.vendor || "",
+            deviceModel: uaResult.device.model || "",
+            engineName: uaResult.engine.name || "",
+            cpuArchitecture: uaResult.cpu.architecture || "",
             loginTime: Date.now(),
             loginResult: 0,
-            failReason: ''
+            failReason: ""
         };
 
         // 根据登录类型构建查询条件
         const whereCondition: Record<string, any> = {};
-        if (ctx.body.loginType === 'username') {
+        if (ctx.body.loginType === "username") {
             whereCondition.username = ctx.body.account;
-        } else if (ctx.body.loginType === 'email') {
+        } else if (ctx.body.loginType === "email") {
             whereCondition.email = ctx.body.account;
-        } else if (ctx.body.loginType === 'phone') {
+        } else if (ctx.body.loginType === "phone") {
             whereCondition.phone = ctx.body.account;
         }
 
         // 查询管理员
         const admin = await befly.db.getOne({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             where: whereCondition
         });
 
         if (!admin?.id) {
-            logData.failReason = '账号不存在';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('账号或密码错误');
+            logData.failReason = "账号不存在";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("账号或密码错误");
         }
 
         // 更新日志数据（已找到用户）
         logData.adminId = admin.id;
         logData.username = admin.username;
-        logData.nickname = admin.nickname || '';
+        logData.nickname = admin.nickname || "";
 
         // 验证密码
         try {
             const isValid = await befly.cipher.verifyPassword(ctx.body.password, admin.password);
             if (!isValid) {
-                logData.failReason = '密码错误';
-                await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-                return befly.tool.No('账号或密码错误');
+                logData.failReason = "密码错误";
+                await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+                return befly.tool.No("账号或密码错误");
             }
         } catch (error: any) {
-            befly.logger.error({ err: error }, '密码验证失败');
-            logData.failReason = '密码格式错误';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('密码格式错误，请重新设置密码');
+            befly.logger.error({ err: error }, "密码验证失败");
+            logData.failReason = "密码格式错误";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("密码格式错误，请重新设置密码");
         }
 
         // 检查账号状态（state=1 表示正常，state=2 表示禁用）
         if (admin.state === 2) {
-            logData.failReason = '账号已被禁用';
-            await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
-            return befly.tool.No('账号已被禁用');
+            logData.failReason = "账号已被禁用";
+            await befly.db.insData({ table: "addon_admin_login_log", data: logData });
+            return befly.tool.No("账号已被禁用");
         }
 
         // 登录成功，记录日志
         logData.loginResult = 1;
-        await befly.db.insData({ table: 'addon_admin_login_log', data: logData });
+        await befly.db.insData({ table: "addon_admin_login_log", data: logData });
 
         // 生成 JWT Token（包含核心身份信息）
         const token = await befly.jwt.sign(
@@ -108,14 +108,14 @@ export default {
                 roleType: admin.roleType
             },
             {
-                expiresIn: '30d'
+                expiresIn: "30d"
             }
         );
 
         // 返回用户信息（不包含密码）
         const { password: _, ...userWithoutPassword } = admin;
 
-        return befly.tool.Yes('登录成功', {
+        return befly.tool.Yes("登录成功", {
             token: token,
             userInfo: userWithoutPassword
         });

package/apis/auth/sendSmsCode.ts

@@ -1,12 +1,12 @@
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '发送短信验证码',
+    name: "发送短信验证码",
     auth: false,
     fields: {
         phone: adminTable.phone
     },
-    required: ['phone'],
+    required: ["phone"],
     handler: async (befly, ctx) => {
         // 生成6位数验证码
         const code = Math.floor(100000 + Math.random() * 900000).toString();
@@ -19,12 +19,12 @@ export default {
         // 如果项目没有 Redis,也可以存储到数据库中
         if (befly.redis) {
             const key = `sms_code:${ctx.body.phone}`;
-            await befly.redis.set(key, code, 'EX', 300); // 5分钟过期
+            await befly.redis.set(key, code, "EX", 300); // 5分钟过期
         }
 
         // 开发环境下返回验证码(生产环境应该删除)
-        const isDev = befly.config.nodeEnv === 'development';
+        const isDev = befly.config.nodeEnv === "development";
 
-        return befly.tool.Yes('验证码已发送', isDev ? { code } : null);
+        return befly.tool.Yes("验证码已发送", isDev ? { code } : null);
     }
 };