befly 3.8.20 → 3.8.24

package/checks/checkApi.ts

@@ -0,0 +1,92 @@
+// 内部依赖
+import { existsSync } from 'node:fs';
+
+// 外部依赖
+import { isPlainObject } from 'es-toolkit/compat';
+import { scanAddons, getAddonDir, addonDirExists, scanFiles } from 'befly-util';
+
+// 相对导入
+import { Logger } from '../lib/logger.js';
+import { projectApiDir } from '../paths.js';
+
+/**
+ * 检查所有 API 定义
+ */
+export async function checkApi(): Promise<void> {
+    try {
+        // 收集所有 API 文件
+        const allApiFiles: Array<{ file: string; displayName: string; apiPath: string }> = [];
+
+        // 收集项目 API 文件
+        if (existsSync(projectApiDir)) {
+            const files = await scanFiles(projectApiDir);
+            for (const { filePath, relativePath } of files) {
+                allApiFiles.push({
+                    file: filePath,
+                    displayName: '用户',
+                    apiPath: relativePath
+                });
+            }
+        }
+
+        // 收集组件 API 文件
+        const addons = scanAddons();
+        for (const addon of addons) {
+            if (!addonDirExists(addon, 'apis')) continue;
+            const addonApiDir = getAddonDir(addon, 'apis');
+
+            const files = await scanFiles(addonApiDir);
+            for (const { filePath, relativePath } of files) {
+                allApiFiles.push({
+                    file: filePath,
+                    displayName: `组件${addon}`,
+                    apiPath: relativePath
+                });
+            }
+        }
+
+        // 合并进行验证逻辑
+        for (const item of allApiFiles) {
+            const { apiPath } = item;
+
+            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 (api.method && !['GET', 'POST'].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(`[${item.displayName}] 接口 ${apiPath} 解析失败`, error);
+            }
+        }
+    } catch (error: any) {
+        Logger.error('API 定义检查过程中出错', error);
+        throw error;
+    }
+}

package/checks/checkApp.ts

@@ -0,0 +1,31 @@
+// 内部依赖
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+
+// 相对导入
+import { Logger } from '../lib/logger.js';
+import { projectApiDir, projectDir } from '../paths.js';
+
+/**
+ * 检查项目结构
+ */
+export async function checkApp(): Promise<void> {
+    try {
+        // 检查项目 apis 目录下是否存在名为 addon 的目录
+        if (existsSync(projectApiDir)) {
+            const addonDir = join(projectApiDir, 'addon');
+            if (existsSync(addonDir)) {
+                throw new Error('项目 apis 目录下不能存在名为 addon 的目录，addon 是保留名称，用于组件接口路由');
+            }
+        }
+
+        // 检查并创建 logs 目录
+        const logsDir = join(projectDir, 'logs');
+        if (!existsSync(logsDir)) {
+            mkdirSync(logsDir, { recursive: true });
+        }
+    } catch (error: any) {
+        Logger.error('项目结构检查过程中出错', error);
+        throw error;
+    }
+}

package/checks/checkTable.ts

@@ -0,0 +1,247 @@
+// 内部依赖
+import { existsSync } from 'node:fs';
+
+// 外部依赖
+import { basename } from 'pathe';
+import { scanAddons, getAddonDir, scanFiles } from 'befly-util';
+
+// 相对导入
+import { Logger } from '../lib/logger.js';
+import { projectTableDir } from '../paths.js';
+
+// 类型导入
+import type { FieldDefinition } from '../types/common.js';
+
+/**
+ * 表文件信息接口
+ */
+interface TableFileInfo {
+    /** 表文件路径 */
+    file: string;
+    /** 文件类型：project（项目）或 addon（组件） */
+    type: 'project' | 'addon';
+    /** 如果是 addon 类型，记录 addon 名称 */
+    addonName?: string;
+    /** 类型名称（用于日志） */
+    typeName: string;
+}
+
+/**
+ * 保留字段列表
+ */
+const RESERVED_FIELDS = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'] as const;
+
+/**
+ * 允许的字段类型
+ */
+const FIELD_TYPES = ['string', 'number', 'text', 'array_string', 'array_text'] as const;
+
+/**
+ * 小驼峰命名正则
+ * 可选：以下划线开头（用于特殊文件，如通用字段定义）
+ * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
+ * 示例：userTable、testCustomers、common
+ */
+const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
+
+/**
+ * 字段名称正则
+ * 必须为中文、数字、字母、下划线、短横线、空格
+ */
+const FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
+
+/**
+ * VARCHAR 最大长度限制
+ */
+const MAX_VARCHAR_LENGTH = 65535;
+
+/**
+ * 检查表定义文件
+ * @throws 当检查失败时抛出异常
+ */
+export async function checkTable(): Promise<void> {
+    try {
+        // 收集所有表文件
+        const allTableFiles: TableFileInfo[] = [];
+        let hasError = false;
+
+        // 收集项目表字段定义文件（如果目录存在）
+        if (existsSync(projectTableDir)) {
+            const files = await scanFiles(projectTableDir, '*.json', false);
+            for (const { filePath } of files) {
+                allTableFiles.push({
+                    file: filePath,
+                    type: 'project',
+                    typeName: '项目'
+                });
+            }
+        }
+
+        // 收集 addon 表字段定义文件
+        const addons = scanAddons();
+        for (const addonName of addons) {
+            const addonTablesDir = getAddonDir(addonName, 'tables');
+
+            // 检查 addon tables 目录是否存在
+            if (!existsSync(addonTablesDir)) {
+                continue;
+            }
+
+            const files = await scanFiles(addonTablesDir, '*.json', false);
+            for (const { filePath } of files) {
+                allTableFiles.push({
+                    file: filePath,
+                    type: 'addon',
+                    typeName: `组件${addonName}`,
+                    addonName: 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(`${item.typeName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                    hasError = true;
+                    continue;
+                }
+
+                // 动态导入 JSON 文件
+                const tableModule = await import(item.file, { with: { type: 'json' } });
+                const table = tableModule.default;
+
+                // 检查 table 中的每个验证规则
+                for (const [colKey, fieldDef] of Object.entries(table)) {
+                    if (typeof fieldDef !== 'object' || fieldDef === null || Array.isArray(fieldDef)) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
+                        hasError = true;
+                        continue;
+                    }
+
+                    // 检查是否使用了保留字段
+                    if (RESERVED_FIELDS.includes(colKey as any)) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
+                        hasError = true;
+                    }
+
+                    // 直接使用字段对象
+                    const field = fieldDef as FieldDefinition;
+
+                    // 检查必填字段：name, type
+                    if (!field.name || typeof field.name !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                        hasError = true;
+                        continue;
+                    }
+                    if (!field.type || typeof field.type !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
+                        hasError = true;
+                        continue;
+                    }
+
+                    // 检查可选字段的类型
+                    if (field.min !== undefined && !(field.min === null || typeof field.min === 'number')) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
+                        hasError = true;
+                    }
+                    if (field.max !== undefined && !(field.max === null || typeof field.max === 'number')) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
+                        hasError = true;
+                    }
+                    if (field.detail !== undefined && typeof field.detail !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                        hasError = true;
+                    }
+                    if (field.index !== undefined && typeof field.index !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                        hasError = true;
+                    }
+                    if (field.unique !== undefined && typeof field.unique !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                        hasError = true;
+                    }
+                    if (field.nullable !== undefined && typeof field.nullable !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                        hasError = true;
+                    }
+                    if (field.unsigned !== undefined && typeof field.unsigned !== 'boolean') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                        hasError = true;
+                    }
+                    if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== 'string') {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                        hasError = true;
+                    }
+
+                    const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault } = field;
+
+                    // 字段名称必须为中文、数字、字母、下划线、短横线、空格
+                    if (!FIELD_NAME_REGEX.test(fieldName)) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                        hasError = true;
+                    }
+
+                    // 字段类型必须为string,number,text,array_string,array_text之一
+                    if (!FIELD_TYPES.includes(fieldType as any)) {
+                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
+                        hasError = true;
+                    }
+
+                    // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
+                    if (fieldMin !== undefined && fieldMax !== undefined && fieldMin !== null && fieldMax !== null) {
+                        if (fieldMin > fieldMax) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
+                            hasError = true;
+                        }
+                    }
+
+                    // 类型联动校验 + 默认值规则
+                    if (fieldType === 'text') {
+                        // text：min/max 应该为 null，默认值必须为 null
+                        if (fieldMin !== undefined && fieldMin !== null) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最小值应为 null，当前为 "${fieldMin}"`);
+                            hasError = true;
+                        }
+                        if (fieldMax !== undefined && fieldMax !== null) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度应为 null，当前为 "${fieldMax}"`);
+                            hasError = true;
+                        }
+                        if (fieldDefault !== undefined && fieldDefault !== null) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
+                            hasError = true;
+                        }
+                    } else if (fieldType === 'string' || fieldType === 'array_string') {
+                        if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== 'number')) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
+                            hasError = true;
+                        } else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
+                            hasError = true;
+                        }
+                    } else if (fieldType === 'number') {
+                        // number 类型：default 如果存在，必须为 null 或 number
+                        if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== 'number') {
+                            Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
+                            hasError = true;
+                        }
+                    }
+                }
+            } catch (error: any) {
+                Logger.error(`${item.typeName}表 ${fileName} 解析失败`, error);
+                hasError = true;
+            }
+        }
+
+        if (hasError) {
+            throw new Error('表结构检查失败');
+        }
+    } catch (error: any) {
+        Logger.error('数据表定义检查过程中出错', error);
+        throw error;
+    }
+}

package/config.ts

@@ -0,0 +1,71 @@
+/**
+ * Befly 默认配置
+ * 包含所有配置项的默认值
+ */
+import type { BeflyOptions } from './types/befly.js';
+
+export const defaultOptions: Required<Omit<BeflyOptions, 'devPassword'>> = {
+    // ========== 核心参数 ==========
+    nodeEnv: 'development',
+    appName: 'Befly App',
+    appPort: 3000,
+    appHost: '127.0.0.1',
+    devEmail: 'dev@qq.com',
+    bodyLimit: 1048576, // 1MB
+    tz: 'Asia/Shanghai',
+    dbCache: 0,
+
+    // ========== 日志配置 ==========
+    logger: {
+        debug: 1,
+        excludeFields: 'password,token,secret',
+        dir: './logs',
+        console: 1,
+        maxSize: 10485760 // 10MB
+    },
+
+    // ========== 数据库配置 ==========
+    db: {
+        enable: 0,
+        type: 'sqlite',
+        host: '127.0.0.1',
+        port: 3306,
+        username: 'root',
+        password: '',
+        database: 'befly',
+        poolMax: 1
+    },
+
+    // ========== Redis 配置 ==========
+    redis: {
+        host: '127.0.0.1',
+        port: 6379,
+        username: '',
+        password: '',
+        db: 0,
+        prefix: 'befly:'
+    },
+
+    // ========== 认证配置 ==========
+    auth: {
+        secret: 'befly-secret',
+        expiresIn: '7d',
+        algorithm: 'HS256'
+    },
+
+    // ========== CORS 配置 ==========
+    cors: {
+        origin: '*',
+        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+        allowedHeaders: 'Content-Type,Authorization',
+        exposedHeaders: '',
+        maxAge: 86400,
+        credentials: 'true'
+    },
+
+    // ========== 禁用配置 ==========
+    /** 禁用的钩子列表 */
+    disableHooks: [],
+    /** 禁用的插件列表 */
+    disablePlugins: []
+};

package/hooks/auth.ts

@@ -0,0 +1,30 @@
+import type { Hook } from '../types/hook.js';
+import { Jwt } from '../lib/jwt.js';
+
+const hook: Hook = {
+    after: ['cors'],
+    order: 5,
+    handler: async (befly, ctx, next) => {
+        // 初始化配置（如果有）
+        // 注意：Hook 没有 onInit，如果需要初始化，可以在 handler 首次执行时做，或者保留 Plugin 机制专门做初始化
+        // 这里 auth 插件原本有 onInit 来配置 Jwt，现在需要迁移
+        // 临时方案：直接在 handler 里判断是否配置过，或者让 Jwt 自身处理配置
+
+        const authHeader = ctx.req.headers.get('authorization');
+
+        if (authHeader && authHeader.startsWith('Bearer ')) {
+            const token = authHeader.substring(7);
+
+            try {
+                const payload = await Jwt.verify(token);
+                ctx.user = payload;
+            } catch (error: any) {
+                ctx.user = {};
+            }
+        } else {
+            ctx.user = {};
+        }
+        await next();
+    }
+};
+export default hook;

package/hooks/cors.ts

@@ -0,0 +1,48 @@
+// 相对导入
+import { setCorsOptions } from '../util.js';
+
+// 类型导入
+import type { Hook } from '../types/hook.js';
+import type { CorsConfig } from '../types/befly.js';
+
+/**
+ * CORS 跨域处理钩子
+ * 设置跨域响应头并处理 OPTIONS 预检请求
+ */
+const hook: Hook = {
+    after: ['errorHandler'],
+    order: 2,
+    handler: async (befly, ctx, next) => {
+        const req = ctx.req;
+
+        // 合并默认配置和用户配置
+        const defaultConfig: CorsConfig = {
+            origin: '*',
+            methods: 'GET, POST, PUT, DELETE, OPTIONS',
+            allowedHeaders: 'Content-Type, Authorization, authorization, token',
+            exposedHeaders: 'Content-Range, X-Content-Range, Authorization, authorization, token',
+            maxAge: 86400,
+            credentials: 'true'
+        };
+
+        const userConfig = (hook as any).config || {};
+        const config = { ...defaultConfig, ...userConfig };
+
+        // 设置 CORS 响应头
+        const headers = setCorsOptions(req, config);
+
+        ctx.corsHeaders = headers;
+
+        // 处理 OPTIONS 预检请求
+        if (req.method === 'OPTIONS') {
+            ctx.response = new Response(null, {
+                status: 204,
+                headers: headers
+            });
+            return;
+        }
+
+        await next();
+    }
+};
+export default hook;

package/hooks/errorHandler.ts

@@ -0,0 +1,23 @@
+// 相对导入
+import { Logger } from '../lib/logger.js';
+import { JsonResponse } from '../util.js';
+
+// 类型导入
+import type { Hook } from '../types/hook.js';
+
+const hook: Hook = {
+    order: 1,
+    handler: async (befly, ctx, next) => {
+        try {
+            await next();
+        } catch (err: any) {
+            // 记录错误信息
+            const apiPath = ctx.api ? `${ctx.req.method}${new URL(ctx.req.url).pathname}` : ctx.req.url;
+            Logger.error(`Request Error: ${apiPath}`, err);
+
+            // 设置错误响应
+            ctx.response = JsonResponse(ctx, '内部服务错误');
+        }
+    }
+};
+export default hook;

package/hooks/parser.ts

@@ -0,0 +1,67 @@
+// 外部依赖
+import { isPlainObject, isEmpty } from 'es-toolkit/compat';
+import { pickFields } from 'befly-util';
+
+// 相对导入
+import { Xml } from '../lib/xml.js';
+import { JsonResponse } from '../util.js';
+
+// 类型导入
+import type { Hook } from '../types/hook.js';
+
+/**
+ * 请求参数解析钩子
+ * - GET 请求：解析 URL 查询参数
+ * - POST 请求：解析 JSON 或 XML 请求体
+ * - 根据 API 定义的 fields 过滤字段
+ */
+const hook: Hook = {
+    after: ['auth'],
+    order: 10,
+    handler: async (befly, ctx, next) => {
+        if (!ctx.api) return next();
+
+        // GET 请求：解析查询参数
+        if (ctx.req.method === 'GET') {
+            const url = new URL(ctx.req.url);
+            if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
+                ctx.body = pickFields(Object.fromEntries(url.searchParams), Object.keys(ctx.api.fields));
+            } else {
+                ctx.body = Object.fromEntries(url.searchParams);
+            }
+        } else if (ctx.req.method === 'POST') {
+            // POST 请求：解析请求体
+            const contentType = ctx.req.headers.get('content-type') || '';
+            try {
+                // JSON 格式
+                if (contentType.includes('application/json')) {
+                    const body = await ctx.req.json();
+                    if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
+                        ctx.body = pickFields(body, Object.keys(ctx.api.fields));
+                    } else {
+                        ctx.body = body;
+                    }
+                } else if (contentType.includes('application/xml') || contentType.includes('text/xml')) {
+                    // XML 格式
+                    const text = await ctx.req.text();
+                    const body = await Xml.parse(text);
+                    if (isPlainObject(ctx.api.fields) && !isEmpty(ctx.api.fields)) {
+                        ctx.body = pickFields(body, Object.keys(ctx.api.fields));
+                    } else {
+                        ctx.body = body;
+                    }
+                } else {
+                    // 不支持的 Content-Type
+                    ctx.response = JsonResponse(ctx, '无效的请求参数格式');
+                    return;
+                }
+            } catch (e) {
+                // 解析失败
+                ctx.response = JsonResponse(ctx, '无效的请求参数格式');
+                return;
+            }
+        }
+        await next();
+    }
+};
+export default hook;

package/hooks/permission.ts

@@ -0,0 +1,54 @@
+// 相对导入
+import { JsonResponse } from '../util.js';
+
+// 类型导入
+import type { Hook } from '../types/hook.js';
+
+/**
+ * 权限检查钩子
+ * - 接口无需权限（auth=false）：直接通过
+ * - 用户未登录：返回 401
+ * - 开发者角色（dev）：最高权限，直接通过
+ * - 其他角色：检查 Redis 中的角色权限集合
+ */
+const hook: Hook = {
+    after: ['parser'],
+    order: 20,
+    handler: async (befly, ctx, next) => {
+        if (!ctx.api) return next();
+
+        // 1. 接口无需权限
+        if (ctx.api.auth === false) {
+            return next();
+        }
+
+        // 2. 用户未登录
+        if (!ctx.user || !ctx.user.userId) {
+            ctx.response = JsonResponse(ctx, '未登录', 401);
+            return;
+        }
+
+        // 3. 开发者权限（最高权限）
+        if (ctx.user.roleCode === 'dev') {
+            return next();
+        }
+
+        // 4. 角色权限检查
+        let hasPermission = false;
+        if (ctx.user.roleCode && befly.redis) {
+            // 验证角色权限
+            const apiPath = `${ctx.req.method}${new URL(ctx.req.url).pathname}`;
+            const roleApisKey = `role:apis:${ctx.user.roleCode}`;
+            const isMember = await befly.redis.sismember(roleApisKey, apiPath);
+            hasPermission = isMember === 1;
+        }
+
+        if (!hasPermission) {
+            ctx.response = JsonResponse(ctx, '无权访问', 403);
+            return;
+        }
+
+        await next();
+    }
+};
+export default hook;