befly 3.16.5 → 3.16.7

package/dist/index.js

@@ -29,7 +29,6 @@ import { SyncTable } from "./sync/syncTable";
 import { CoreError, isCoreError } from "./types/coreError";
 // 工具
 import { calcPerfTime } from "./utils/calcPerfTime";
-import { getProcessRole } from "./utils/processInfo";
 import { scanSources } from "./utils/scanSources";
 /**
  * Befly 框架核心类
@@ -97,20 +96,65 @@ export class Befly {
             // 启动期依赖完整性检查：避免 sync 阶段出现 undefined 调用
             // 注意：这里不做兼容别名（例如 dbHelper=db），要求上下文必须注入标准字段。
             this.assertStartContextReady();
-            // 5. 自动同步 (仅主进程执行，避免集群模式下重复执行)
-            await new SyncTable(this.context).run(tables);
-            await syncApi(this.context, apis);
-            await syncMenu(this.context, checkedMenus);
-            const devEmail = this.config.devEmail;
-            const devPassword = this.config.devPassword;
-            if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
-                await syncDev(this.context, { devEmail: devEmail, devPassword: devPassword });
+            // 5. 自动同步（包含删除差集/写缓存等强副作用）
+            // 多进程/多实例场景下必须避免并发执行：使用 Redis 分布式锁保证全局单点。
+            const syncLockKey = "sync:lock";
+            const syncReadyKey = "sync:ready";
+            const syncLockTtlMs = 10 * 60 * 1000;
+            const syncWaitReadyMaxMs = 120 * 1000;
+            const syncWaitPollMs = 250;
+            const syncToken = `${process.pid}:${Bun.nanoseconds()}`;
+            const ctx = this.context;
+            const acquired = await ctx.redis.tryAcquireLock(syncLockKey, syncToken, syncLockTtlMs);
+            if (acquired) {
+                Logger.info({ key: syncLockKey, msg: "✅ 已获取启动同步锁，将执行自动同步" });
+                // 清空 ready：避免其他实例读取到上一次同步的 ready 而误判当前同步已完成
+                await ctx.redis.del(syncReadyKey);
+                try {
+                    await new SyncTable(ctx).run(tables);
+                    await syncApi(ctx, apis);
+                    await syncMenu(ctx, checkedMenus);
+                    const devEmail = this.config.devEmail;
+                    const devPassword = this.config.devPassword;
+                    if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
+                        await syncDev(ctx, { devEmail: devEmail, devPassword: devPassword });
+                    }
+                    else {
+                        Logger.debug("跳过 syncDev：未配置 devEmail/devPassword");
+                    }
+                    // 缓存同步：统一在所有 DB 同步完成后执行
+                    await syncCache(ctx);
+                    // 写入 ready：通知其他实例可继续启动（保留 1 小时，下一次同步会先清空）
+                    await ctx.redis.setString(syncReadyKey, String(Date.now()), 60 * 60);
+                }
+                finally {
+                    const released = await ctx.redis.releaseLock(syncLockKey, syncToken);
+                    if (!released) {
+                        Logger.warn({ key: syncLockKey, msg: "同步锁未能主动释放（将依赖 TTL 自动释放）" });
+                    }
+                }
             }
             else {
-                Logger.debug("跳过 syncDev：未配置 devEmail/devPassword");
+                Logger.info({ key: syncLockKey, msg: "启动同步锁被占用：等待同步完成标记" });
+                const waitStart = Date.now();
+                while (true) {
+                    const ready = await ctx.redis.getString(syncReadyKey);
+                    if (typeof ready === "string" && ready.length > 0) {
+                        Logger.info({ key: syncReadyKey, msg: "✅ 检测到同步完成标记，将跳过自动同步" });
+                        break;
+                    }
+                    const elapsed = Date.now() - waitStart;
+                    if (elapsed >= syncWaitReadyMaxMs) {
+                        throw new CoreError({
+                            kind: "runtime",
+                            message: `启动等待同步完成超时（${syncWaitReadyMaxMs}ms）：请检查是否有实例卡在同步阶段或 Redis 锁 TTL 过长`,
+                            logged: true,
+                            meta: { subsystem: "start", operation: "waitSyncReady" }
+                        });
+                    }
+                    await Bun.sleep(syncWaitPollMs);
+                }
             }
-            // 缓存同步：统一在所有同步完成后执行（cacheApis + cacheMenus + rebuildRoleApiPermissions）
-            await syncCache(this.context);
             // 3. 加载钩子
             this.hooks = await loadHooks(hooks);
             // 4. 加载所有 API
@@ -152,10 +196,7 @@ export class Befly {
                 }
             });
             const finalStartupTime = calcPerfTime(serverStartTime);
-            const processRole = getProcessRole(env);
-            const roleLabel = processRole.role === "primary" ? "主进程" : `工作进程 #${processRole.instanceId}`;
-            const envLabel = processRole.env === "standalone" ? "" : ` [${processRole.env}]`;
-            Logger.info(`${this.config.appName} 启动成功! (${roleLabel}${envLabel})`);
+            Logger.info(`${this.config.appName} 启动成功!`);
             Logger.info(`服务器启动耗时: ${finalStartupTime}`);
             Logger.info(`服务器监听地址: ${server.url}`);
             // 注意：作为库代码，这里不注册 SIGINT/SIGTERM 处理器，也不调用 process.exit。

package/dist/lib/cacheHelper.d.ts

@@ -37,7 +37,9 @@ export declare class CacheHelper {
     private redis;
     constructor(deps: CacheHelperDeps);
     private assertApiPathname;
+    private assertMenuPathname;
     private assertApiPathList;
+    private assertMenuPathList;
     /**
      * 缓存所有接口到 Redis
      */
@@ -52,12 +54,24 @@ export declare class CacheHelper {
      * - 极简方案：每个角色一个 Set，直接覆盖更新（DEL + SADD）
      */
     rebuildRoleApiPermissions(): Promise<void>;
+    /**
+     * 缓存所有角色的菜单权限到 Redis
+     * 全量重建：清理所有角色菜单权限缓存并重建
+     * - 每个角色一个 Set，直接覆盖更新（DEL + SADD）
+     */
+    rebuildRoleMenuPermissions(): Promise<void>;
     /**
      * 增量刷新单个角色的接口权限缓存
      * - apiIds 为空数组：仅清理缓存（防止残留）
      * - apiIds 非空：使用 $in 最小查询，DEL 后 SADD
      */
     refreshRoleApiPermissions(roleCode: string, apiPaths: string[]): Promise<void>;
+    /**
+     * 增量刷新单个角色的菜单权限缓存
+     * - menuPaths 为空数组：仅清理缓存（防止残留）
+     * - menuPaths 非空：DEL 后 SADD
+     */
+    refreshRoleMenuPermissions(roleCode: string, menuPaths: string[]): Promise<void>;
     /**
      * 缓存所有数据
      */
@@ -78,6 +92,12 @@ export declare class CacheHelper {
      * @returns 接口路径列表
      */
     getRolePermissions(roleCode: string): Promise<string[]>;
+    /**
+     * 获取角色的菜单权限
+     * @param roleCode - 角色代码
+     * @returns 菜单路径列表（menu.path）
+     */
+    getRoleMenuPermissions(roleCode: string): Promise<string[]>;
     /**
      * 检查角色是否有指定接口权限
      * @param roleCode - 角色代码
@@ -85,11 +105,24 @@ export declare class CacheHelper {
      * @returns 是否有权限
      */
     checkRolePermission(roleCode: string, apiPath: string): Promise<boolean>;
+    /**
+     * 检查角色是否有指定菜单权限
+     * @param roleCode - 角色代码
+     * @param menuPath - 菜单路径（menu.path）
+     * @returns 是否有权限
+     */
+    checkRoleMenuPermission(roleCode: string, menuPath: string): Promise<boolean>;
     /**
      * 删除角色的接口权限缓存
      * @param roleCode - 角色代码
      * @returns 是否删除成功
      */
     deleteRolePermissions(roleCode: string): Promise<boolean>;
+    /**
+     * 删除角色的菜单权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    deleteRoleMenuPermissions(roleCode: string): Promise<boolean>;
 }
 export {};

package/dist/lib/cacheHelper.js

@@ -34,6 +34,25 @@ export class CacheHelper {
         }
         return trimmed;
     }
+    assertMenuPathname(value, errorPrefix) {
+        if (typeof value !== "string") {
+            throw new Error(`${errorPrefix} 必须是字符串`);
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            throw new Error(`${errorPrefix} 不允许为空字符串`);
+        }
+        if (!trimmed.startsWith("/")) {
+            throw new Error(`${errorPrefix} 必须是 pathname（以 / 开头）`);
+        }
+        if (trimmed.includes(" ")) {
+            throw new Error(`${errorPrefix} 不允许包含空格`);
+        }
+        if (trimmed.length > 1 && trimmed.endsWith("/")) {
+            throw new Error(`${errorPrefix} 不允许以 / 结尾`);
+        }
+        return trimmed;
+    }
     assertApiPathList(value, roleCode) {
         if (value === null || value === undefined)
             return [];
@@ -64,6 +83,35 @@ export class CacheHelper {
         }
         return out;
     }
+    assertMenuPathList(value, roleCode) {
+        if (value === null || value === undefined)
+            return [];
+        let list = value;
+        // 兼容历史/手工数据：menus 可能被存成 JSON 字符串或 "null"
+        if (typeof list === "string") {
+            const trimmed = list.trim();
+            if (trimmed === "" || trimmed === "null") {
+                return [];
+            }
+            if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+                try {
+                    list = JSON.parse(trimmed);
+                }
+                catch {
+                    throw new Error(`角色菜单权限数据不合法：addon_admin_role.menus JSON 解析失败，roleCode=${roleCode}`);
+                }
+            }
+        }
+        if (!Array.isArray(list)) {
+            const typeLabel = typeof list;
+            throw new Error(`角色菜单权限数据不合法：addon_admin_role.menus 必须是字符串数组或 JSON 数组字符串，roleCode=${roleCode}，type=${typeLabel}`);
+        }
+        const out = [];
+        for (const item of list) {
+            out.push(this.assertMenuPathname(item, `角色菜单权限数据不合法：addon_admin_role.menus 元素，roleCode=${roleCode}`));
+        }
+        return out;
+    }
     /**
      * 缓存所有接口到 Redis
      */
@@ -175,6 +223,66 @@ export class CacheHelper {
             });
         }
     }
+    /**
+     * 缓存所有角色的菜单权限到 Redis
+     * 全量重建：清理所有角色菜单权限缓存并重建
+     * - 每个角色一个 Set，直接覆盖更新（DEL + SADD）
+     */
+    async rebuildRoleMenuPermissions() {
+        try {
+            // 检查表是否存在
+            const roleTableExists = await this.db.tableExists("addon_admin_role");
+            if (!roleTableExists.data) {
+                Logger.warn("⚠️ 角色表不存在，跳过角色菜单权限缓存");
+                return;
+            }
+            // 查询所有角色（仅取必要字段）
+            const roles = await this.db.getAll({
+                table: "addon_admin_role",
+                fields: ["code", "menus"]
+            });
+            const roleMenuPathsMap = new Map();
+            for (const role of roles.data.lists) {
+                if (!role?.code)
+                    continue;
+                const menuPaths = this.assertMenuPathList(role.menus, role.code);
+                roleMenuPathsMap.set(role.code, menuPaths);
+            }
+            const roleCodes = Array.from(roleMenuPathsMap.keys());
+            if (roleCodes.length === 0) {
+                Logger.info("✅ 没有需要缓存的角色菜单权限");
+                return;
+            }
+            // 清理所有角色的缓存 key（保证幂等）
+            const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
+            await this.redis.delBatch(roleKeys);
+            // 批量写入新缓存（只写入非空权限）
+            const items = [];
+            for (const roleCode of roleCodes) {
+                const menuPaths = roleMenuPathsMap.get(roleCode) || [];
+                const members = Array.from(new Set(menuPaths)).sort();
+                if (members.length > 0) {
+                    items.push({ key: CacheKeys.roleMenus(roleCode), members: members });
+                }
+            }
+            if (items.length > 0) {
+                await this.redis.saddBatch(items);
+            }
+        }
+        catch (error) {
+            Logger.error({ err: error, msg: "⚠️ 角色菜单权限缓存异常（将阻断启动）" });
+            throw new CoreError({
+                kind: "runtime",
+                message: "⚠️ 角色菜单权限缓存异常（将阻断启动）",
+                logged: true,
+                cause: error,
+                meta: {
+                    subsystem: "cache",
+                    operation: "rebuildRoleMenuPermissions"
+                }
+            });
+        }
+    }
     /**
      * 增量刷新单个角色的接口权限缓存
      * - apiIds 为空数组：仅清理缓存（防止残留）
@@ -200,6 +308,31 @@ export class CacheHelper {
             await this.redis.sadd(roleKey, members);
         }
     }
+    /**
+     * 增量刷新单个角色的菜单权限缓存
+     * - menuPaths 为空数组：仅清理缓存（防止残留）
+     * - menuPaths 非空：DEL 后 SADD
+     */
+    async refreshRoleMenuPermissions(roleCode, menuPaths) {
+        if (!roleCode || typeof roleCode !== "string") {
+            throw new Error("roleCode 必须是非空字符串");
+        }
+        if (!Array.isArray(menuPaths)) {
+            throw new Error("menuPaths 必须是数组");
+        }
+        const normalizedPaths = menuPaths.map((p) => this.assertMenuPathname(p, `refreshRoleMenuPermissions: menuPaths 元素，roleCode=${roleCode}`));
+        const roleKey = CacheKeys.roleMenus(roleCode);
+        // 空数组短路：保证清理残留
+        if (normalizedPaths.length === 0) {
+            await this.redis.del(roleKey);
+            return;
+        }
+        const members = Array.from(new Set(normalizedPaths));
+        await this.redis.del(roleKey);
+        if (members.length > 0) {
+            await this.redis.sadd(roleKey, members);
+        }
+    }
     /**
      * 缓存所有数据
      */
@@ -210,6 +343,8 @@ export class CacheHelper {
         await this.cacheMenus();
         // 3. 缓存角色权限
         await this.rebuildRoleApiPermissions();
+        // 4. 缓存角色菜单权限
+        await this.rebuildRoleMenuPermissions();
     }
     /**
      * 获取缓存的所有接口
@@ -254,6 +389,21 @@ export class CacheHelper {
             return [];
         }
     }
+    /**
+     * 获取角色的菜单权限
+     * @param roleCode - 角色代码
+     * @returns 菜单路径列表（menu.path）
+     */
+    async getRoleMenuPermissions(roleCode) {
+        try {
+            const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
+            return permissions || [];
+        }
+        catch (error) {
+            Logger.error({ err: error, roleCode: roleCode, msg: "获取角色菜单权限缓存失败" });
+            return [];
+        }
+    }
     /**
      * 检查角色是否有指定接口权限
      * @param roleCode - 角色代码
@@ -270,6 +420,22 @@ export class CacheHelper {
             return false;
         }
     }
+    /**
+     * 检查角色是否有指定菜单权限
+     * @param roleCode - 角色代码
+     * @param menuPath - 菜单路径（menu.path）
+     * @returns 是否有权限
+     */
+    async checkRoleMenuPermission(roleCode, menuPath) {
+        try {
+            const pathname = this.assertMenuPathname(menuPath, "checkRoleMenuPermission: menuPath");
+            return await this.redis.sismember(CacheKeys.roleMenus(roleCode), pathname);
+        }
+        catch (error) {
+            Logger.error({ err: error, roleCode: roleCode, msg: "检查角色菜单权限失败" });
+            return false;
+        }
+    }
     /**
      * 删除角色的接口权限缓存
      * @param roleCode - 角色代码
@@ -289,4 +455,23 @@ export class CacheHelper {
             return false;
         }
     }
+    /**
+     * 删除角色的菜单权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    async deleteRoleMenuPermissions(roleCode) {
+        try {
+            const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
+            if (result > 0) {
+                Logger.info(`✅ 已删除角色 ${roleCode} 的菜单权限缓存`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            Logger.error({ err: error, roleCode: roleCode, msg: "删除角色菜单权限缓存失败" });
+            return false;
+        }
+    }
 }

package/dist/lib/cacheKeys.d.ts

@@ -12,6 +12,12 @@ export declare class CacheKeys {
     static menusAll(): string;
     /** 角色信息缓存（完整角色对象） */
     static roleInfo(roleCode: string): string;
+    /**
+     * 角色菜单权限缓存（Set 集合）
+     * - key: role:menus:${roleCode}
+     * - member: menu.path（例如 /permission/role）
+     */
+    static roleMenus(roleCode: string): string;
     /**
      * 角色接口权限缓存（Set 集合）
      * - key: role:apis:${roleCode}

package/dist/lib/cacheKeys.js

@@ -18,6 +18,14 @@ export class CacheKeys {
     static roleInfo(roleCode) {
         return `role:info:${roleCode}`;
     }
+    /**
+     * 角色菜单权限缓存（Set 集合）
+     * - key: role:menus:${roleCode}
+     * - member: menu.path（例如 /permission/role）
+     */
+    static roleMenus(roleCode) {
+        return `role:menus:${roleCode}`;
+    }
     /**
      * 角色接口权限缓存（Set 集合）
      * - key: role:apis:${roleCode}

package/dist/lib/redisHelper.d.ts

@@ -49,6 +49,14 @@ export declare class RedisHelper {
      * @param ttl - 过期时间（秒）
      */
     setString(key: string, value: string, ttl?: number | null): Promise<string | null>;
+    /**
+     * 尝试获取分布式锁（SET key token NX PX ttlMs）
+     */
+    tryAcquireLock(key: string, token: string, ttlMs: number): Promise<boolean>;
+    /**
+     * 释放分布式锁（原子校验 token 后删除）
+     */
+    releaseLock(key: string, token: string): Promise<boolean>;
     /**
      * 获取字符串值
      * @param key - 键名

package/dist/lib/redisHelper.js

@@ -150,6 +150,63 @@ export class RedisHelper {
             return null;
         }
     }
+    /**
+     * 尝试获取分布式锁（SET key token NX PX ttlMs）
+     */
+    async tryAcquireLock(key, token, ttlMs) {
+        try {
+            if (!key || typeof key !== "string") {
+                throw new Error("tryAcquireLock: key 必须是非空字符串");
+            }
+            if (!token || typeof token !== "string") {
+                throw new Error("tryAcquireLock: token 必须是非空字符串");
+            }
+            if (!(typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0)) {
+                throw new Error("tryAcquireLock: ttlMs 必须是正数");
+            }
+            const pkey = `${this.prefix}${key}`;
+            const startTime = Date.now();
+            const ttlMsString = String(Math.floor(ttlMs));
+            const res = await this.client.set(pkey, token, "NX", "PX", ttlMsString);
+            const duration = Date.now() - startTime;
+            this.logSlow("SET NX PX", pkey, duration, { ttlMs: ttlMs });
+            return res === "OK";
+        }
+        catch (error) {
+            Logger.error({ err: error, msg: "Redis tryAcquireLock 错误" });
+            return false;
+        }
+    }
+    /**
+     * 释放分布式锁（原子校验 token 后删除）
+     */
+    async releaseLock(key, token) {
+        try {
+            if (!key || typeof key !== "string") {
+                throw new Error("releaseLock: key 必须是非空字符串");
+            }
+            if (!token || typeof token !== "string") {
+                throw new Error("releaseLock: token 必须是非空字符串");
+            }
+            const pkey = `${this.prefix}${key}`;
+            // 注意：Bun.RedisClient 当前未暴露 Lua/EVAL 等原子 compare-and-del API。
+            // 这里使用 get + del 的最小窗口实现；理论上存在极端竞态（TTL 恰好过期并被他人抢占）。
+            // 对启动期同步场景来说风险可接受；同时锁本身带 TTL，最坏情况下依赖 TTL 自动释放。
+            const startTime = Date.now();
+            const current = await this.client.get(pkey);
+            if (current !== token) {
+                return false;
+            }
+            const deleted = await this.client.del(pkey);
+            const duration = Date.now() - startTime;
+            this.logSlow("GET+DEL", pkey, duration);
+            return deleted > 0;
+        }
+        catch (error) {
+            Logger.error({ err: error, msg: "Redis releaseLock 错误" });
+            return false;
+        }
+    }
     /**
      * 获取字符串值
      * @param key - 键名
@@ -298,7 +355,9 @@ export class RedisHelper {
             const startTime = Date.now();
             const res = await this.client.sadd(pkey, ...members);
             const duration = Date.now() - startTime;
-            this.logSlow("SADD", pkey, duration, { membersCount: members.length });
+            this.logSlow("SADD", pkey, duration, {
+                membersCount: members.length
+            });
             return res;
         }
         catch (error) {

package/dist/sync/syncCache.js

@@ -9,4 +9,6 @@ export async function syncCache(ctx) {
     await ctx.cache.cacheMenus();
     // 3) 重建角色权限缓存（严格模式下要求 role.apis 必须为 pathname 字符串数组）
     await ctx.cache.rebuildRoleApiPermissions();
+    // 4) 重建角色菜单权限缓存（role.menus 为 menu.path 字符串数组）
+    await ctx.cache.rebuildRoleMenuPermissions();
 }

package/dist/types/cache.d.ts

@@ -20,10 +20,18 @@ export interface CacheHelper {
      * 全量重建所有角色的接口权限缓存
      */
     rebuildRoleApiPermissions(): Promise<void>;
+    /**
+     * 全量重建所有角色的菜单权限缓存
+     */
+    rebuildRoleMenuPermissions(): Promise<void>;
     /**
      * 增量刷新单个角色的接口权限缓存
      */
     refreshRoleApiPermissions(roleCode: string, apiPaths: string[]): Promise<void>;
+    /**
+     * 增量刷新单个角色的菜单权限缓存
+     */
+    refreshRoleMenuPermissions(roleCode: string, menuPaths: string[]): Promise<void>;
     /**
      * 缓存所有数据（接口、菜单、角色权限）
      */
@@ -44,6 +52,12 @@ export interface CacheHelper {
      * @returns 接口路径列表
      */
     getRolePermissions(roleCode: string): Promise<string[]>;
+    /**
+     * 获取角色的菜单权限
+     * @param roleCode - 角色代码
+     * @returns 菜单路径列表（menu.path）
+     */
+    getRoleMenuPermissions(roleCode: string): Promise<string[]>;
     /**
      * 检查角色是否有指定接口权限
      * @param roleCode - 角色代码
@@ -51,12 +65,25 @@ export interface CacheHelper {
      * @returns 是否有权限
      */
     checkRolePermission(roleCode: string, apiPath: string): Promise<boolean>;
+    /**
+     * 检查角色是否有指定菜单权限
+     * @param roleCode - 角色代码
+     * @param menuPath - 菜单路径（menu.path）
+     * @returns 是否有权限
+     */
+    checkRoleMenuPermission(roleCode: string, menuPath: string): Promise<boolean>;
     /**
      * 删除角色的接口权限缓存
      * @param roleCode - 角色代码
      * @returns 是否删除成功
      */
     deleteRolePermissions(roleCode: string): Promise<boolean>;
+    /**
+     * 删除角色的菜单权限缓存
+     * @param roleCode - 角色代码
+     * @returns 是否删除成功
+     */
+    deleteRoleMenuPermissions(roleCode: string): Promise<boolean>;
 }
 /**
  * CacheHelper 构造函数类型

package/dist/types/redis.d.ts

@@ -61,6 +61,16 @@ export interface RedisHelper {
         seconds: number;
     }>): Promise<number>;
     ping(): Promise<string>;
+    /**
+     * 尝试获取分布式锁（SET key value NX PX ttlMs）
+     * @returns true=获取成功；false=未获取到（被占用）
+     */
+    tryAcquireLock(key: string, token: string, ttlMs: number): Promise<boolean>;
+    /**
+     * 释放分布式锁（仅当 value==token 时删除）
+     * @returns true=释放成功；false=未释放（锁不存在/不归属/实现不支持）
+     */
+    releaseLock(key: string, token: string): Promise<boolean>;
 }
 /**
  * RedisHelper 构造函数类型

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.16.5",
-    "gitHead": "3e615600f8069fb7b34939f2361df811129331a0",
+    "version": "3.16.7",
+    "gitHead": "adac857f86168208b2e5359dc039a66cb34b50a9",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [
@@ -58,7 +58,7 @@
     },
     "dependencies": {
         "fast-jwt": "^6.1.0",
-        "fast-xml-parser": "^5.3.3",
+        "fast-xml-parser": "^5.3.4",
         "pathe": "^2.0.3"
     },
     "engines": {