befly 3.9.40 → 3.10.0

package/checks/checkTable.ts

@@ -1,31 +1,7 @@
-// 类型导入
 import type { FieldDefinition } from "../types/validate.js";
-
-// 内部依赖
-import { existsSync } from "node:fs";
-
-// 外部依赖
-import { basename } from "pathe";
+import type { ScanFileResult } from "../utils/scanFiles.js";
 
 import { Logger } from "../lib/logger.js";
-import { projectTableDir } from "../paths.js";
-import { scanAddons, getAddonDir } from "../utils/addonHelper.js";
-// 相对导入
-import { scanFiles } from "../utils/scanFiles.js";
-
-/**
- * 表文件信息接口
- */
-interface TableFileInfo {
-    /** 表文件路径 */
-    file: string;
-    /** 文件类型：project（项目）或 addon（组件） */
-    type: "project" | "addon";
-    /** 如果是 addon 类型，记录 addon 名称 */
-    addonName?: string;
-    /** 类型名称（用于日志） */
-    typeName: string;
-}
 
 /**
  * 保留字段列表
@@ -65,202 +41,180 @@ 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");
-            for (const { filePath } of files) {
-                allTableFiles.push({
-                    file: filePath,
-                    type: "project",
-                    typeName: "项目"
-                });
-            }
+export async function checkTable(tables: ScanFileResult[]): Promise<void> {
+    // 收集所有表文件
+    let hasError = false;
+
+    // 合并进行验证逻辑
+    for (const item of tables) {
+        if (item.type !== "table") {
+            continue;
         }
 
-        // 收集 addon 表字段定义文件
-        const addons = scanAddons();
-        for (const addonName of addons) {
-            const addonTablesDir = getAddonDir(addonName, "tables");
+        const sourceName = typeof item.sourceName === "string" ? item.sourceName : "";
 
-            // 检查 addon tables 目录是否存在
-            if (!existsSync(addonTablesDir)) {
+        try {
+            const fileName = item.fileName;
+            const table = item.content || {};
+            // 1) 文件名小驼峰校验
+            if (!LOWER_CAMEL_CASE_REGEX.test(fileName)) {
+                Logger.warn(`${sourceName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                hasError = true;
                 continue;
             }
 
-            const files = await scanFiles(addonTablesDir, "*.json");
-            for (const { filePath } of files) {
-                allTableFiles.push({
-                    file: filePath,
-                    type: "addon",
-                    typeName: `组件${addonName}`,
-                    addonName: addonName
-                });
-            }
-        }
+            // 检查 table 中的每个验证规则
+            for (const [colKey, fieldDef] of Object.entries(table)) {
+                if (typeof fieldDef !== "object" || fieldDef === null || Array.isArray(fieldDef)) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 规则必须为对象`);
+                    hasError = true;
+                    continue;
+                }
 
-        // 合并进行验证逻辑
-        for (const item of allTableFiles) {
-            const fileName = basename(item.file);
-            const fileBaseName = basename(item.file, ".json");
+                // 检查是否使用了保留字段
+                if (RESERVED_FIELDS.includes(colKey as any)) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
+                    hasError = true;
+                }
+
+                // 直接使用字段对象
+                const field = fieldDef as FieldDefinition;
+
+                // 检查是否存在非法属性
+                const fieldKeys = Object.keys(field);
+                const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key as any));
+                if (illegalProps.length > 0) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
+                    hasError = true;
+                }
 
-            try {
-                // 1) 文件名小驼峰校验
-                if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
-                    Logger.warn(`${item.typeName}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                // 检查必填字段：name, type
+                if (!field.name || typeof field.name !== "string") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
+                    hasError = true;
+                    continue;
+                }
+                if (!field.type || typeof field.type !== "string") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 缺少必填字段 type 或类型错误`);
                     hasError = true;
                     continue;
                 }
 
-                // 动态导入 JSON 文件
-                const tableModule = await import(item.file, { with: { type: "json" } });
-                const table = tableModule.default;
+                // 检查可选字段的类型
+                if (field.min !== undefined && !(field.min === null || typeof field.min === "number")) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
+                    hasError = true;
+                }
+                if (field.max !== undefined && !(field.max === null || typeof field.max === "number")) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
+                    hasError = true;
+                }
+                if (field.detail !== undefined && typeof field.detail !== "string") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                    hasError = true;
+                }
+                if (field.index !== undefined && typeof field.index !== "boolean") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                    hasError = true;
+                }
+                if (field.unique !== undefined && typeof field.unique !== "boolean") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+                    hasError = true;
+                }
+                if (field.nullable !== undefined && typeof field.nullable !== "boolean") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                    hasError = true;
+                }
+                if (field.unsigned !== undefined && typeof field.unsigned !== "boolean") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                    hasError = true;
+                }
+                if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== "string") {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                    hasError = true;
+                }
 
-                // 检查 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;
-                    }
+                const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault } = field;
 
-                    // 检查是否使用了保留字段
-                    if (RESERVED_FIELDS.includes(colKey as any)) {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
-                        hasError = true;
-                    }
+                // 字段名称必须为中文、数字、字母、下划线、短横线、空格
+                if (!FIELD_NAME_REGEX.test(fieldName)) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                    hasError = true;
+                }
 
-                    // 直接使用字段对象
-                    const field = fieldDef as FieldDefinition;
+                // 字段类型必须为string,number,text,array_string,array_text之一
+                if (!FIELD_TYPES.includes(fieldType as any)) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join("、")}之一`);
+                    hasError = true;
+                }
 
-                    // 检查是否存在非法属性
-                    const fieldKeys = Object.keys(field);
-                    const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key as any));
-                    if (illegalProps.length > 0) {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
-                        hasError = true;
-                    }
+                // unsigned 仅对 number 类型有效（且仅 MySQL 语义上生效）
+                if (fieldType !== "number" && field.unsigned !== undefined) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型为 ${fieldType}，不允许设置 unsigned（仅 number 类型有效）`);
+                    hasError = true;
+                }
 
-                    // 检查必填字段：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;
-                    }
+                // 约束：unique 与 index 不能同时为 true（否则会重复索引），必须阻断启动。
+                if (field.unique === true && field.index === true) {
+                    Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 和 index 不能同时设置，请删除其一（否则会创建重复索引）`);
+                    hasError = true;
+                }
 
-                    // 检查可选字段的类型
-                    if (field.min !== undefined && !(field.min === null || typeof field.min === "number")) {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
+                // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
+                if (fieldMin !== undefined && fieldMax !== undefined && fieldMin !== null && fieldMax !== null) {
+                    if (fieldMin > fieldMax) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                         hasError = true;
                     }
-                    if (field.max !== undefined && !(field.max === null || typeof field.max === "number")) {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 max 类型错误，必须为 null 或数字`);
+                }
+
+                // 类型联动校验 + 默认值规则
+                if (fieldType === "text" || fieldType === "array_text" || fieldType === "array_number_text") {
+                    // text / array_text / array_number_text：min/max 必须为 null，默认值必须为 null，且不支持索引/唯一约束
+                    if (fieldMin !== undefined && fieldMin !== null) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 的 ${fieldType} 类型最小值应为 null，当前为 "${fieldMin}"`);
                         hasError = true;
                     }
-                    if (field.detail !== undefined && typeof field.detail !== "string") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 detail 类型错误，必须为字符串`);
+                    if (fieldMax !== undefined && fieldMax !== null) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 的 ${fieldType} 类型最大长度应为 null，当前为 "${fieldMax}"`);
                         hasError = true;
                     }
-                    if (field.index !== undefined && typeof field.index !== "boolean") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 index 类型错误，必须为布尔值`);
+                    if (fieldDefault !== undefined && fieldDefault !== null) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                         hasError = true;
                     }
-                    if (field.unique !== undefined && typeof field.unique !== "boolean") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unique 类型错误，必须为布尔值`);
+
+                    if (field.index === true) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持创建索引（index=true 无效）`);
                         hasError = true;
                     }
-                    if (field.nullable !== undefined && typeof field.nullable !== "boolean") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 nullable 类型错误，必须为布尔值`);
+                    if (field.unique === true) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持唯一约束（unique=true 无效）`);
                         hasError = true;
                     }
-                    if (field.unsigned !== undefined && typeof field.unsigned !== "boolean") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 unsigned 类型错误，必须为布尔值`);
+                } else if (fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
+                    if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== "number")) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                         hasError = true;
-                    }
-                    if (field.regexp !== undefined && field.regexp !== null && typeof field.regexp !== "string") {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
+                    } else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                         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("、")}之一`);
+                } else if (fieldType === "number") {
+                    // number 类型：default 如果存在，必须为 null 或 number
+                    if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== "number") {
+                        Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
                         hasError = true;
                     }
-
-                    // 检查 unique 和 index 冲突（警告但不阻断）
-                    if (field.unique && field.index) {
-                        Logger.warn(`${item.typeName}表 ${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 约束会自动创建唯一索引，index=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" || fieldType === "array_number_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;
             }
+        } catch (error: any) {
+            Logger.error(`${sourceName}表 ${item.fileName} 解析失败`, error);
+            hasError = true;
         }
+    }
 
-        if (hasError) {
-            throw new Error("表结构检查失败");
-        }
-    } catch (error: any) {
-        Logger.error("数据表定义检查过程中出错", error);
-        throw error;
+    if (hasError) {
+        throw new Error("表结构检查失败");
     }
 }

package/docs/README.md

@@ -77,7 +77,7 @@
 
 ### 运维篇
 
-13. **[Sync](./reference/sync.md)** - syncDb、syncApi、syncMenu、syncDev 命令
+13. **[Sync](./reference/sync.md)** - syncTable、syncData（内部：syncApi、syncMenu、syncDev）
 
 ## 常用链接
 

package/docs/api/api.md

@@ -208,7 +208,7 @@ interface RequestContext {
     /** 请求头 */
     headers: Headers;
 
-    /** API 路由路径（如 POST/api/user/login） */
+    /** API 路由路径（url.pathname，例如 /api/user/login；与 method 无关） */
     route: string;
 
     /** 请求唯一 ID */

package/docs/guide/quickstart.md

@@ -208,15 +208,24 @@ CREATE DATABASE my_api CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
 ## 同步数据库
 
-### 运行同步命令
+### 自动同步
 
-```bash
-# 全量同步（表结构 + API + 菜单 + 开发账户）
-bun befly sync
+服务启动时会在**主进程**自动执行同步流程：
+
+1. `syncTable()`：同步表结构
+2. `syncData()`：固定顺序执行 `syncApi` → `syncMenu` → `syncDev`
 
-# 或单独同步
-bun befly sync:db      # 只同步表结构
-bun befly sync:api     # 只同步 API 路由
+如需手动触发，可在代码中调用（一般不建议在请求路径中调用）：
+
+```typescript
+import { syncData } from "../sync/syncData.js";
+import { syncTable } from "../sync/syncTable.js";
+import { scanSources } from "../utils/scanSources.js";
+
+// ctx：BeflyContext（需已具备 ctx.db / ctx.redis / ctx.config）
+const sources = await scanSources();
+await syncTable(ctx, sources.tables);
+await syncData();
 ```
 
 ### 验证同步结果
@@ -299,8 +308,6 @@ curl -X POST http://localhost:3000/api/user/login \
 ```bash
 # 开发
 bun run dev          # 启动开发服务
-bun befly sync       # 同步数据库
-bun befly sync:db    # 只同步表结构
 
 # 生产
 bun run build        # 构建

package/docs/hooks/hook.md

@@ -541,7 +541,7 @@ export default hook;
         "defaultLimit": 1000,
         "defaultWindow": 60,
         "key": "ip",
-        "skipRoutes": ["/api/health", "GET/api/metrics"],
+        "skipRoutes": ["/api/health", "/api/metrics"],
         "rules": [
             {
                 "route": "/api/auth/*",
@@ -550,7 +550,7 @@ export default hook;
                 "key": "ip"
             },
             {
-                "route": "POST/api/order/create",
+                "route": "/api/order/create",
                 "limit": 5,
                 "window": 60,
                 "key": "user"

package/docs/hooks/rateLimit.md

@@ -22,7 +22,7 @@
                 "key": "ip"
             }
         ],
-        "skipRoutes": ["GET/api/health"]
+        "skipRoutes": ["/api/health"]
     }
 }
 ```

package/docs/infra/redis.md

@@ -221,8 +221,8 @@ const count = await befly.redis.expireBatch([
 
 ```typescript
 const count = await befly.redis.saddBatch([
-    { key: "role:admin:apis", members: ["GET/api/user", "POST/api/user"] },
-    { key: "role:editor:apis", members: ["GET/api/article", "POST/api/article"] }
+    { key: "role:admin:apis", members: ["/api/user"] },
+    { key: "role:editor:apis", members: ["/api/article"] }
 ]);
 // 返回: 成功添加的总成员数量
 ```
@@ -231,8 +231,8 @@ const count = await befly.redis.saddBatch([
 
 ```typescript
 const results = await befly.redis.sismemberBatch([
-    { key: "role:admin:apis", member: "GET/api/user" },
-    { key: "role:admin:apis", member: "DELETE/api/user" }
+    { key: "role:admin:apis", member: "/api/user" },
+    { key: "role:admin:apis", member: "/api/user/delete" }
 ]);
 // 返回: [true, false]
 ```
@@ -333,7 +333,7 @@ return befly.tool.No("请求过于频繁");
 ```typescript
 // 极简方案：每个角色一个 Set
 const roleApisKey = CacheKeys.roleApis("admin");
-const hasPermission = await befly.redis.sismember(roleApisKey, "POST/api/user/add");
+const hasPermission = await befly.redis.sismember(roleApisKey, "/api/user/add");
 // 返回: true
 ```
 
@@ -473,14 +473,14 @@ const menus = await befly.cache.getMenus();
 
 // 获取角色权限
 const permissions = await befly.cache.getRolePermissions("admin");
-// 返回: ['GET/api/user/list', 'POST/api/user/add', ...]
+// 返回: ['/api/user/list', '/api/user/add', ...]
 ```
 
 ### 权限检查
 
 ```typescript
 // 检查角色是否有指定接口权限
-const hasPermission = await befly.cache.checkRolePermission("admin", "POST/api/user/add");
+const hasPermission = await befly.cache.checkRolePermission("admin", "/api/user/add");
 // 返回: true 或 false
 ```