befly 3.8.1 → 3.8.3

package/check.ts

@@ -3,11 +3,14 @@
  * 验证表定义文件的格式和规则
  */
 
-import { basename } from 'pathe';
+import { basename, relative } from 'pathe';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { isPlainObject } from 'es-toolkit/compat';
 import { Logger } from './lib/logger.js';
-import { parseRule } from './util.js';
-import { projectTableDir } from './paths.js';
-import { Addon } from './lib/addon.js';
+import { projectTableDir, projectApiDir } from './paths.js';
+import { scanAddons, getAddonDir, addonDirExists } from './util.js';
+import type { FieldDefinition } from './types/common.d.ts';
 
 /**
  * 表文件信息接口
@@ -54,16 +57,10 @@ const MAX_VARCHAR_LENGTH = 65535;
  * 检查表定义文件
  * @throws 当检查失败时抛出异常
  */
-export const checkDefault = async function (): Promise<void> {
+export const checkTable = async function (): Promise<boolean> {
     try {
         const tablesGlob = new Bun.Glob('*.json');
 
-        // 统计信息
-        let totalFiles = 0;
-        let totalRules = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-
         // 收集所有表文件
         const allTableFiles: TableFileInfo[] = [];
 
@@ -73,167 +70,276 @@ export const checkDefault = async function (): Promise<void> {
             absolute: true,
             onlyFiles: true
         })) {
-            allTableFiles.push({ file: file, type: 'project' });
+            allTableFiles.push({
+                file: file,
+                typeCode: 'project',
+                typeName: '项目'
+            });
         }
 
         // 收集 addon 表字段定义文件
-        const addons = Addon.scan();
+        const addons = scanAddons();
         for (const addonName of addons) {
-            const addonTablesDir = Addon.getDir(addonName, 'tables');
+            const addonTablesDir = getAddonDir(addonName, 'tables');
 
             for await (const file of tablesGlob.scan({
                 cwd: addonTablesDir,
                 absolute: true,
                 onlyFiles: true
             })) {
-                allTableFiles.push({ file: file, type: 'addon', addonName: addonName });
+                allTableFiles.push({
+                    file: file,
+                    typeCode: 'addon',
+                    typeName: `组件${addonName}`,
+                    addonName: addonName
+                });
             }
         }
 
         // 合并进行验证逻辑
-        for (const { file, type, addonName } of allTableFiles) {
-            totalFiles++;
-            const fileName = basename(file);
-            const fileBaseName = basename(file, '.json');
-            const fileType = type === 'project' ? '项目' : `组件${addonName}`;
+        for (const item of allTableFiles) {
+            const fileName = basename(item.file);
+            const fileBaseName = basename(item.file, '.json');
 
             try {
                 // 1) 文件名小驼峰校验
                 if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
-                    Logger.warn(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，记录错误并计为无效文件，继续下一个文件
-                    invalidFiles++;
+                    Logger.warn(`${item.typeName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
                     continue;
                 }
 
-                // 读取并解析 JSON 文件
-                const table = await Bun.file(file).json();
-                let fileValid = true;
-                let fileRules = 0;
+                // 动态导入 JSON 文件
+                const tableModule = await import(item.file, { with: { type: 'json' } });
+                const table = tableModule.default;
 
                 // 检查 table 中的每个验证规则
-                for (const [colKey, rule] of Object.entries(table)) {
-                    if (typeof rule !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
-                        fileValid = false;
+                for (const [colKey, fieldDef] of Object.entries(table)) {
+                    if (typeof fieldDef !== 'object' || fieldDef === null || Array.isArray(fieldDef)) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
                         continue;
                     }
 
-                    // 验证规则格式
-                    fileRules++;
-                    totalRules++;
-
                     // 检查是否使用了保留字段
                     if (RESERVED_FIELDS.includes(colKey as any)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
                     }
 
-                    // 使用 parseRule 解析字段规则
-                    let parsed;
-                    try {
-                        parsed = parseRule(rule);
-                    } catch (error: any) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
-                        fileValid = false;
+                    // 直接使用字段对象
+                    const field = fieldDef as FieldDefinition;
+
+                    // 检查必填字段：name, type, min, max
+                    if (!field.name || typeof field.name !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                        continue;
+                    }
+                    if (!field.type || typeof field.type !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
+                        continue;
+                    }
+                    if (field.min === undefined) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 min`);
+                        continue;
+                    }
+                    if (field.max === undefined) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 max`);
                         continue;
                     }
 
-                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regex: fieldRegx } = parsed;
+                    // 检查可选字段的类型
+                    if (field.detail !== undefined && typeof field.detail !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                    }
+                    if (field.index !== undefined && typeof field.index !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                    }
+                    if (field.unique !== undefined && typeof field.unique !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                    }
+                    if (field.nullable !== undefined && typeof field.nullable !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                    }
+                    if (field.unsigned !== undefined && typeof field.unsigned !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                    }
+                    if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                    }
+
+                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regexp: fieldRegexp } = field;
 
                     // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
                     if (!FIELD_NAME_REGEX.test(fieldName)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                     }
 
                     // 第2个值：字段类型必须为string,number,text,array_string,array_text之一
                     if (!FIELD_TYPES.includes(fieldType as any)) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
                     }
 
                     // 第3/4个值：需要是 null 或 数字
                     if (!(fieldMin === null || typeof fieldMin === 'number')) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
                     }
                     if (!(fieldMax === null || typeof fieldMax === 'number')) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
-                        fileValid = false;
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
                     }
 
                     // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                     if (fieldMin !== null && fieldMax !== null) {
                         if (fieldMin > fieldMax) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                         }
                     }
 
-                    // 第6个值：是否创建索引必须为0或1
-                    if (fieldIndex !== 0 && fieldIndex !== 1) {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
-                        fileValid = false;
-                    }
-
-                    // 第7个值：必须为null或正则表达式（parseRule已经验证过了）
-                    // parseRule 已经将正则字符串转换为 RegExp 或 null，这里不需要再验证
-
                     // 第4个值与类型联动校验 + 默认值规则
                     if (fieldType === 'text') {
-                        // text：min/max 必须为 null，默认值必须为 'null'
+                        // text：min/max 必须为 null，默认值必须为 null
                         if (fieldMin !== null) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                         }
                         if (fieldMax !== null) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                         }
-                        if (fieldDefault !== 'null') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
-                            fileValid = false;
+                        if (fieldDefault !== null) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                         }
                     } else if (fieldType === 'string' || fieldType === 'array') {
                         if (fieldMax === null || typeof fieldMax !== 'number') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                         } else if (fieldMax > MAX_VARCHAR_LENGTH) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
-                            fileValid = false;
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                         }
                     } else if (fieldType === 'number') {
-                        if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
-                            fileValid = false;
+                        // number 类型：default 如果存在，必须为 null 或 number
+                        if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== 'number') {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
                         }
                     }
                 }
+            } catch (error: any) {
+                Logger.error(`${item.typeName}表 ${fileName} 解析失败`, error);
+            }
+        }
+
+        return true;
+    } catch (error: any) {
+        Logger.error('数据表定义检查过程中出错', error);
+        return false;
+    }
+};
+
+/**
+ * 检查所有 API 定义
+ */
+export const checkApi = async function (): Promise<boolean> {
+    try {
+        const apiGlob = new Bun.Glob('**/*.ts');
+
+        // 收集所有 API 文件
+        const allApiFiles: Array<{ file: string; displayName: string }> = [];
+
+        // 收集项目 API 文件
+        if (existsSync(projectApiDir)) {
+            for await (const file of apiGlob.scan({
+                cwd: projectApiDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                allApiFiles.push({
+                    file: file,
+                    displayName: '用户'
+                });
+            }
+        }
+
+        // 收集组件 API 文件
+        const addons = scanAddons();
+        for (const addon of addons) {
+            if (!addonDirExists(addon, 'apis')) continue;
+            const addonApiDir = getAddonDir(addon, 'apis');
+
+            for await (const file of apiGlob.scan({
+                cwd: addonApiDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                allApiFiles.push({
+                    file: file,
+                    displayName: `组件${addon}`
+                });
+            }
+        }
+
+        // 合并进行验证逻辑
+        for (const item of allApiFiles) {
+            const fileName = basename(item.file).replace(/\.ts$/, '');
+            const apiPath = relative(item.displayName === '用户' ? projectApiDir : getAddonDir(item.displayName.replace('组件', ''), 'apis'), item.file).replace(/\.ts$/, '');
+
+            // 跳过以下划线开头的文件
+            if (apiPath.indexOf('_') !== -1) continue;
+
+            try {
+                // Windows 下路径需要转换为正斜杠格式
+                const filePath = item.file.replace(/\\/g, '/');
+                const apiImport = await import(filePath);
+                const api = apiImport.default;
+
+                // 验证必填属性：name 和 handler
+                if (typeof api.name !== 'string' || api.name.trim() === '') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 name 属性必须是非空字符串`);
+                    continue;
+                }
+                if (typeof api.handler !== 'function') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 handler 属性必须是函数`);
+                    continue;
+                }
 
-                if (fileValid) {
-                    validFiles++;
-                    // Logger.info(`${fileType}表 ${fileName} 验证通过（${fileRules} 个字段）`);
-                } else {
-                    invalidFiles++;
+                // 验证可选属性的类型（如果提供了）
+                if (api.method && !['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(api.method.toUpperCase())) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 method 属性必须是有效的 HTTP 方法`);
+                }
+                if (api.auth !== undefined && typeof api.auth !== 'boolean') {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 auth 属性必须是布尔值 (true=需登录, false=公开)`);
+                }
+                if (api.fields && !isPlainObject(api.fields)) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 fields 属性必须是对象`);
+                }
+                if (api.required && !Array.isArray(api.required)) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 required 属性必须是数组`);
+                }
+                if (api.required && api.required.some((item: any) => typeof item !== 'string')) {
+                    Logger.warn(`[${item.displayName}] 接口 ${apiPath} 的 required 属性必须是字符串数组`);
                 }
             } catch (error: any) {
-                Logger.error(`${fileType}表 ${fileName} 解析失败`, error);
-                invalidFiles++;
+                Logger.error(`[${item.displayName}] 接口 ${apiPath} 解析失败`, error);
             }
         }
 
-        // 输出统计信息
-        // Logger.info(`  总文件数: ${totalFiles}`);
-        // Logger.info(`  总规则数: ${totalRules}`);
-        // Logger.info(`  通过文件: ${validFiles}`);
-        // Logger.info(`  失败文件: ${invalidFiles}`);
+        return true;
+    } catch (error: any) {
+        Logger.error('API 定义检查过程中出错', error);
+        return false;
+    }
+};
 
-        if (invalidFiles > 0) {
-            throw new Error('表定义检查失败，请修复上述错误后重试');
+/**
+ * 检查项目结构
+ */
+export const checkApp = async function (): Promise<boolean> {
+    try {
+        // 检查项目 apis 目录下是否存在名为 addon 的目录
+        if (existsSync(projectApiDir)) {
+            const addonDir = join(projectApiDir, 'addon');
+            if (existsSync(addonDir)) {
+                Logger.error('项目 apis 目录下不能存在名为 addon 的目录，addon 是保留名称，用于组件接口路由');
+                return false;
+            }
         }
+
+        return true;
     } catch (error: any) {
-        Logger.error('数据表定义检查过程中出错', error);
-        throw error;
+        Logger.error('项目结构检查过程中出错', error);
+        return false;
     }
 };

package/env.ts

@@ -18,14 +18,14 @@ const coreEnv: EnvConfig = {
     NODE_ENV: process.env.NODE_ENV || 'development',
     APP_NAME: isProd ? '野蜂飞舞正式环境' : '野蜂飞舞开发环境',
     APP_PORT: 3000,
-    APP_HOST: isProd ? '127.0.0.1' : '0.0.0.0',
+    APP_HOST: '127.0.0.1',
     DEV_EMAIL: 'dev@qq.com',
     DEV_PASSWORD: '123456',
     BODY_LIMIT: 10485760, // 10MB
     PARAMS_CHECK: false,
 
     // ========== 日志配置 ==========
-    LOG_DEBUG: isProd ? 0 : 1,
+    LOG_DEBUG: 0,
     LOG_EXCLUDE_FIELDS: 'password,token,secret',
     LOG_DIR: './logs',
     LOG_TO_CONSOLE: 1,
@@ -55,7 +55,7 @@ const coreEnv: EnvConfig = {
     REDIS_KEY_PREFIX: 'befly',
 
     // ========== JWT 配置 ==========
-    JWT_SECRET: isProd ? 'befly-dev-secret' : 'befly-prod-secret',
+    JWT_SECRET: 'befly-secret',
     JWT_EXPIRES_IN: '7d',
     JWT_ALGORITHM: 'HS256',
 

package/{plugins/cache.ts → lib/cacheHelper.ts}

@@ -1,21 +1,23 @@
-/**
- * 缓存插件 - TypeScript 版本
+/**
+ * 缓存助手 - TypeScript 版本
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
-import { Logger } from '../lib/logger.js';
-import type { Plugin } from '../types/plugin.js';
+import { Logger } from './logger.js';
 import type { BeflyContext } from '../types/befly.js';
-import type { ApiRoute } from '../types/api.js';
 
 /**
- * 缓存管理器类
+ * 缓存助手类
  */
-class CacheManager {
-    private appContext: BeflyContext;
+export class CacheHelper {
+    private befly: BeflyContext;
 
-    constructor(appContext: BeflyContext) {
-        this.appContext = appContext;
+    /**
+     * 构造函数
+     * @param befly - Befly 上下文
+     */
+    constructor(befly: BeflyContext) {
+        this.befly = befly;
     }
 
     /**
@@ -24,21 +26,21 @@ class CacheManager {
     async cacheApis(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.appContext.db.tableExists('core_api');
+            const tableExists = await this.befly.db.tableExists('core_api');
             if (!tableExists) {
                 Logger.warn('⚠️ 接口表不存在，跳过接口缓存');
                 return;
             }
 
             // 从数据库查询所有接口（与 apiAll.ts 保持一致）
-            const apiList = await this.appContext.db.getAll({
+            const apiList = await this.befly.db.getAll({
                 table: 'core_api',
                 fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
                 orderBy: ['addonName#ASC', 'path#ASC']
             });
 
             // 缓存到 Redis
-            const result = await this.appContext.redis.setObject('apis:all', apiList);
+            const result = await this.befly.redis.setObject('apis:all', apiList);
 
             if (result === null) {
                 Logger.warn('⚠️ 接口缓存失败');
@@ -56,21 +58,21 @@ class CacheManager {
     async cacheMenus(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.appContext.db.tableExists('core_menu');
+            const tableExists = await this.befly.db.tableExists('core_menu');
             if (!tableExists) {
                 Logger.warn('⚠️ 菜单表不存在，跳过菜单缓存');
                 return;
             }
 
             // 从数据库查询所有菜单
-            const menus = await this.appContext.db.getAll({
+            const menus = await this.befly.db.getAll({
                 table: 'core_menu',
                 fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
                 orderBy: ['sort#ASC', 'id#ASC']
             });
 
             // 缓存到 Redis
-            const result = await this.appContext.redis.setObject('menus:all', menus);
+            const result = await this.befly.redis.setObject('menus:all', menus);
 
             if (result === null) {
                 Logger.warn('⚠️ 菜单缓存失败');
@@ -89,8 +91,8 @@ class CacheManager {
     async cacheRolePermissions(): Promise<void> {
         try {
             // 检查表是否存在
-            const apiTableExists = await this.appContext.db.tableExists('core_api');
-            const roleTableExists = await this.appContext.db.tableExists('core_role');
+            const apiTableExists = await this.befly.db.tableExists('core_api');
+            const roleTableExists = await this.befly.db.tableExists('core_role');
 
             if (!apiTableExists || !roleTableExists) {
                 Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
@@ -98,13 +100,13 @@ class CacheManager {
             }
 
             // 查询所有角色
-            const roles = await this.appContext.db.getAll({
+            const roles = await this.befly.db.getAll({
                 table: 'core_role',
                 fields: ['id', 'code', 'apis']
             });
 
             // 查询所有接口（用于权限映射）
-            const allApis = await this.appContext.db.getAll({
+            const allApis = await this.befly.db.getAll({
                 table: 'core_api',
                 fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
             });
@@ -129,10 +131,10 @@ class CacheManager {
                 const redisKey = `role:apis:${role.code}`;
 
                 // 先删除旧数据
-                await this.appContext.redis.del(redisKey);
+                await this.befly.redis.del(redisKey);
 
                 // 批量添加到 Set
-                const result = await this.appContext.redis.sadd(redisKey, roleApiPaths);
+                const result = await this.befly.redis.sadd(redisKey, roleApiPaths);
 
                 if (result > 0) {
                     cachedRoles++;
@@ -164,23 +166,85 @@ class CacheManager {
 
         Logger.info('========== 数据缓存完成 ==========\n');
     }
-}
 
-/**
- * 缓存插件
- */
-const cachePlugin: Plugin = {
-    name: '_cache',
-    after: ['_db', '_redis'],
+    /**
+     * 获取缓存的所有接口
+     * @returns 接口列表
+     */
+    async getApis(): Promise<any[]> {
+        try {
+            const apis = await this.befly.redis.getObject<any[]>('apis:all');
+            return apis || [];
+        } catch (error: any) {
+            Logger.error('获取接口缓存失败:', error);
+            return [];
+        }
+    }
+
+    /**
+     * 获取缓存的所有菜单
+     * @returns 菜单列表
+     */
+    async getMenus(): Promise<any[]> {
+        try {
+            const menus = await this.befly.redis.getObject<any[]>('menus:all');
+            return menus || [];
+        } catch (error: any) {
+            Logger.error('获取菜单缓存失败:', error);
+            return [];
+        }
+    }
 
-    async onInit(befly: BeflyContext): Promise<CacheManager> {
+    /**
+     * 获取角色的接口权限
+     * @param roleCode - 角色代码
+     * @returns 接口路径列表
+     */
+    async getRolePermissions(roleCode: string): Promise<string[]> {
+        try {
+            const redisKey = `role:apis:${roleCode}`;
+            const permissions = await this.befly.redis.smembers(redisKey);
+            return permissions || [];
+        } catch (error: any) {
+            Logger.error(`获取角色 ${roleCode} 权限缓存失败:`, error);
+            return [];
+        }
+    }
+
+    /**
+     * 检查角色是否有指定接口权限
+     * @param roleCode - 角色代码
+     * @param apiPath - 接口路径（格式：METHOD/path）
+     * @returns 是否有权限
+     */
+    async checkRolePermission(roleCode: string, apiPath: string): Promise<boolean> {
         try {
-            const cacheManager = new CacheManager(befly);
-            return cacheManager;
+            const redisKey = `role:apis:${roleCode}`;
+            const result = await this.befly.redis.sismember(redisKey, apiPath);
+            return result === 1;
         } catch (error: any) {
-            throw error;
+            Logger.error(`检查角色 ${roleCode} 权限失败:`, error);
+            return false;
         }
     }
-};
 
-export default cachePlugin;
+    /**
+     * 删除角色的接口权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRolePermissions(roleCode: string): Promise<boolean> {
+        try {
+            const redisKey = `role:apis:${roleCode}`;
+            const result = await this.befly.redis.del(redisKey);
+            if (result > 0) {
+                Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
+                return true;
+            }
+            return false;
+        } catch (error: any) {
+            Logger.error(`删除角色 ${roleCode} 权限缓存失败:`, error);
+            return false;
+        }
+    }
+}