@befly-addon/admin 1.1.29 → 1.1.31

package/apis/admin/cacheRefresh.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * 刷新全部缓存接口
  *
  * 功能：
@@ -12,42 +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',
-                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
-                    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',
-                    fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
-                    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;
@@ -59,42 +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',
-                    fields: ['id', 'name', 'code', 'menus', 'apis']
+                    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 admin = await befly.db.getOne({
-            table: 'addon_admin_admin',
+        const adminData = await befly.db.getOne({
+            table: "addon_admin_admin",
             where: { id: ctx.body.id }
         });
 
-        if (!admin) {
-            return befly.tool.No('管理员不存在');
+        if (!adminData?.id) {
+            return befly.tool.No("管理员不存在");
         }
 
         // 不能删除 dev 角色的管理员
-        if (admin.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,51 +1,19 @@
-/**
- * 获取用户信息接口
- *
- * @returns 返回 admin 表的字段（不含 password）以及关联的角色信息（小驼峰格式）:
- *  - id, name, email, phone, roleId, roleCode, state
- *  - lastLoginTime, lastLoginIp
- *  - createdAt, updatedAt
- *  - role: 角色完整信息（包含 menus 和 apis 权限）
- */
-
 export default {
-    name: '获取用户信息',
+    name: "获取管理员信息",
     fields: {
-        id: '@id'
+        id: "@id"
     },
     handler: async (befly, ctx) => {
-        // 从 JWT token 中获取用户ID
-        const userId = ctx.user?.id;
-
-        if (!userId) {
-            return befly.tool.No('未授权');
-        }
-
-        // 查询用户信息（框架自动转换为小驼峰）
-        const admin = await befly.db.getOne({
-            table: 'addon_admin_admin',
-            where: { id: userId }
+        const adminData = await befly.db.getOne({
+            table: "addon_admin_admin",
+            fields: ["!password"],
+            where: { id: ctx.user?.id }
         });
 
-        if (!admin) {
-            return befly.tool.No('用户不存在');
+        if (!adminData?.id) {
+            return befly.tool.No("管理员不存在");
         }
 
-        // 查询角色信息（使用 roleCode 而非 roleId，框架自动转换为小驼峰）
-        let roleInfo = null;
-        if (admin.roleCode) {
-            roleInfo = await befly.db.getOne({
-                table: 'addon_admin_role',
-                where: { code: admin.roleCode }
-            });
-        }
-
-        // 返回用户信息（不包含密码，字段已是小驼峰格式）
-        const { password: _, ...userWithoutPassword } = admin;
-
-        return befly.tool.Yes('获取成功', {
-            ...userWithoutPassword,
-            role: roleInfo
-        });
+        return befly.tool.Yes("查询成功", adminData);
     }
 };

package/apis/admin/ins.ts

@@ -1,31 +1,40 @@
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '添加管理员',
+    name: "添加管理员",
     fields: adminTable,
-    required: ['username', 'password', 'roleId'],
+    required: ["username", "password", "roleCode"],
     handler: async (befly, ctx) => {
         // 检查用户名是否已存在
-        if (ctx.body.username) {
-            const existingByUsername = await befly.db.getOne({
-                table: 'addon_admin_admin',
-                where: { username: ctx.body.username }
+        const existingByUsername = await befly.db.getOne({
+            table: "addon_admin_admin",
+            where: { username: ctx.body.username }
+        });
+
+        if (existingByUsername?.id) {
+            return befly.tool.No("用户名已被使用");
+        }
+
+        // 检查昵称是否已存在
+        if (ctx.body.nickname) {
+            const existingByNickname = await befly.db.getOne({
+                table: "addon_admin_admin",
+                where: { nickname: ctx.body.nickname }
             });
 
-            if (existingByUsername) {
-                return befly.tool.No('用户名已被使用');
+            if (existingByNickname?.id) {
+                return befly.tool.No("昵称已被使用");
             }
         }
 
         // 查询角色信息
-        const role = await befly.db.getOne({
-            table: 'addon_admin_role',
-            where: { id: ctx.body.roleId },
-            columns: ['code']
+        const roleData = await befly.db.getOne({
+            table: "addon_admin_role",
+            where: { code: ctx.body.roleCode }
         });
 
-        if (!role?.code) {
-            return befly.tool.No('角色不存在');
+        if (!roleData?.id) {
+            return befly.tool.No("角色不存在");
         }
 
         // 加密密码
@@ -33,19 +42,17 @@ export default {
 
         // 创建管理员
         const adminId = await befly.db.insData({
-            table: 'addon_admin_admin',
+            table: "addon_admin_admin",
             data: {
                 username: ctx.body.username,
                 password: hashedPassword,
                 nickname: ctx.body.nickname,
-                roleId: ctx.body.roleId,
-                roleCode: role.code
+                roleCode: ctx.body.roleCode
             }
         });
 
-        return befly.tool.Yes('添加成功', {
-            id: adminId,
-            username: ctx.body.username
+        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',
-            page: ctx.body.page || 1,
-            limit: ctx.body.limit || 10,
+            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,33 +1,68 @@
-/**
- * 更新管理员信息
- */
-
-import adminTable from '../../tables/admin.json';
+import adminTable from "../../tables/admin.json";
 
 export default {
-    name: '更新管理员',
-    fields: adminTable,
-    required: ['id'],
+    name: "更新管理员",
+    fields: { id: "@id", ...adminTable },
+    required: ["id"],
     handler: async (befly, ctx) => {
-        const { id, ...updateData } = ctx.body;
+        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",
+                where: { username, id: { $ne: id } }
+            });
+            if (existingUsername?.id) {
+                return befly.tool.No("用户名已被使用");
+            }
+        }
+
+        // 检查昵称是否已被其他管理员使用
+        if (nickname && nickname !== admin.nickname) {
+            const existingNickname = await befly.db.getOne({
+                table: "addon_admin_admin",
+                where: { nickname, id: { $ne: id } }
+            });
+            if (existingNickname?.id) {
+                return befly.tool.No("昵称已被使用");
+            }
+        }
+
+        // 检查角色是否存在
+        if (roleCode && roleCode !== admin.roleCode) {
+            const role = await befly.db.getOne({
+                table: "addon_admin_role",
+                where: { code: roleCode }
+            });
+            if (!role?.id) {
+                return befly.tool.No("角色不存在");
+            }
         }
 
+        // 构建更新数据
+        const dataToUpdate: Record<string, any> = { ...updateData };
+        if (username) dataToUpdate.username = username;
+        if (nickname) dataToUpdate.nickname = nickname;
+        if (roleCode) dataToUpdate.roleCode = roleCode;
+
         // 更新管理员信息
         await befly.db.updData({
-            table: 'addon_admin_admin',
-            data: updateData,
+            table: "addon_admin_admin",
+            data: dataToUpdate,
             where: { id }
         });
 
-        return befly.tool.Yes('更新成功');
+        return befly.tool.Yes("更新成功");
     }
 };

package/apis/api/all.ts

@@ -1,24 +1,28 @@
-export default {
-    name: '获取所有接口',
-    handler: async (befly, ctx) => {
+export default {
+    name: "获取所有接口",
+    handler: async (befly) => {
         try {
             // 从缓存获取所有接口
             let allApis = await befly.cache.getApis();
 
-            // 如果缓存不存在，从数据库查询
+            // 如果缓存不存在，从数据库查询并缓存
             if (allApis.length === 0) {
                 const result = await befly.db.getAll({
-                    table: 'addon_admin_api',
-                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
-                    orderBy: ['addonName#ASC', 'path#ASC']
+                    table: "addon_admin_api",
+                    orderBy: ["id#ASC"]
                 });
                 allApis = result.lists;
+
+                // 缓存到 Redis
+                if (allApis.length > 0) {
+                    await befly.cache.cacheApis();
+                }
             }
 
-            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,36 +1,27 @@
-import type { ApiRoute } from 'befly';
-
 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 { page = 1, limit = 30, keyword = '' } = ctx.body;
-
-            // 构建查询条件
-            const where: Record<string, any> = {};
-            if (keyword) {
-                where.$or = [{ name: { $like: `%${keyword}%` } }, { path: { $like: `%${keyword}%` } }];
-            }
-
             const result = await befly.db.getList({
-                table: 'addon_admin_api',
-                fields: ['id', 'name', 'path', 'method', 'description', 'addon_name', 'addon_title'],
-                where: where,
-                orderBy: ['addon_name#ASC', 'path#ASC'],
-                page: page,
-                limit: limit
+                table: "addon_admin_api",
+                where: {
+                    $or: ctx.body.keyword ? [{ name$like: `%${ctx.body.keyword}%` }, { path$like: `%${ctx.body.keyword}%` }] : undefined
+                },
+                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("获取接口列表失败");
         }
     }
-} as ApiRoute;
+};