befly 3.9.38 → 3.9.39

package/lib/cacheHelper.ts

@@ -3,10 +3,11 @@
  * 负责在服务器启动时缓存接口、菜单和角色权限到 Redis
  */
 
-import { Logger } from './logger.js';
-import { RedisKeys } from 'befly-shared/redisKeys';
+import type { BeflyContext } from "../types/befly.js";
 
-import type { BeflyContext } from '../types/befly.js';
+import { makeRouteKey } from "../utils/route.js";
+import { CacheKeys } from "./cacheKeys.js";
+import { Logger } from "./logger.js";
 
 /**
  * 缓存助手类
@@ -14,6 +15,104 @@ import type { BeflyContext } from '../types/befly.js';
 export class CacheHelper {
     private befly: BeflyContext;
 
+    private static readonly API_ID_IN_CHUNK_SIZE = 1000;
+
+    private normalizeNumberIdList(value: unknown): number[] {
+        if (value === null || value === undefined) return [];
+
+        const normalizeSingle = (item: unknown): number | null => {
+            if (typeof item === "number") {
+                if (!Number.isFinite(item)) return null;
+                const intValue = Math.trunc(item);
+                return Number.isSafeInteger(intValue) ? intValue : null;
+            }
+            if (typeof item === "bigint") {
+                const intValue = Number(item);
+                return Number.isSafeInteger(intValue) ? intValue : null;
+            }
+            if (typeof item === "string") {
+                const trimmed = item.trim();
+                if (!trimmed) return null;
+                const intValue = Number.parseInt(trimmed, 10);
+                return Number.isSafeInteger(intValue) ? intValue : null;
+            }
+            return null;
+        };
+
+        if (Array.isArray(value)) {
+            const ids: number[] = [];
+            for (const item of value) {
+                const id = normalizeSingle(item);
+                if (id !== null) ids.push(id);
+            }
+            return ids;
+        }
+
+        if (typeof value === "string") {
+            const str = value.trim();
+            if (!str) return [];
+
+            if (str.startsWith("[")) {
+                try {
+                    const parsed = JSON.parse(str);
+                    return this.normalizeNumberIdList(parsed);
+                } catch {
+                    // ignore
+                }
+            }
+
+            const ids: number[] = [];
+            const parts = str.split(",");
+            for (const part of parts) {
+                const id = normalizeSingle(part);
+                if (id !== null) ids.push(id);
+            }
+            return ids;
+        }
+
+        const single = normalizeSingle(value);
+        return single === null ? [] : [single];
+    }
+
+    private chunkNumberArray(arr: number[], chunkSize: number): number[][] {
+        if (chunkSize <= 0) {
+            throw new Error(`chunkSize 必须为正整数 (chunkSize: ${chunkSize})`);
+        }
+        if (arr.length === 0) return [];
+
+        const chunks: number[][] = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            chunks.push(arr.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+
+    private async buildApiPathMapByIds(apiIds: number[]): Promise<Map<number, string>> {
+        const uniqueIds = Array.from(new Set(apiIds));
+        if (uniqueIds.length === 0) {
+            return new Map();
+        }
+
+        const apiMap = new Map<number, string>();
+        const chunks = this.chunkNumberArray(uniqueIds, CacheHelper.API_ID_IN_CHUNK_SIZE);
+
+        for (const chunk of chunks) {
+            const apis = await this.befly.db.getAll({
+                table: "addon_admin_api",
+                fields: ["id", "method", "path"],
+                where: {
+                    id$in: chunk
+                }
+            });
+
+            for (const api of apis.lists) {
+                apiMap.set(api.id, makeRouteKey(api.method, api.path));
+            }
+        }
+
+        return apiMap;
+    }
+
     /**
      * 构造函数
      * @param befly - Befly 上下文
@@ -28,26 +127,25 @@ export class CacheHelper {
     async cacheApis(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.befly.db.tableExists('addon_admin_api');
+            const tableExists = await this.befly.db.tableExists("addon_admin_api");
             if (!tableExists) {
-                Logger.warn('⚠️ 接口表不存在，跳过接口缓存');
+                Logger.warn("⚠️ 接口表不存在，跳过接口缓存");
                 return;
             }
 
             // 从数据库查询所有接口
             const apiList = await this.befly.db.getAll({
-                table: 'addon_admin_api',
-                orderBy: ['addonName#ASC', 'path#ASC']
+                table: "addon_admin_api"
             });
 
             // 缓存到 Redis
-            const result = await this.befly.redis.setObject(RedisKeys.apisAll(), apiList.lists);
+            const result = await this.befly.redis.setObject(CacheKeys.apisAll(), apiList.lists);
 
             if (result === null) {
-                Logger.warn('⚠️ 接口缓存失败');
+                Logger.warn("⚠️ 接口缓存失败");
             }
         } catch (error: any) {
-            Logger.error({ err: error }, '⚠️ 接口缓存异常');
+            Logger.error({ err: error }, "⚠️ 接口缓存异常");
         }
     }
 
@@ -57,102 +155,139 @@ export class CacheHelper {
     async cacheMenus(): Promise<void> {
         try {
             // 检查表是否存在
-            const tableExists = await this.befly.db.tableExists('addon_admin_menu');
+            const tableExists = await this.befly.db.tableExists("addon_admin_menu");
             if (!tableExists) {
-                Logger.warn('⚠️ 菜单表不存在，跳过菜单缓存');
+                Logger.warn("⚠️ 菜单表不存在，跳过菜单缓存");
                 return;
             }
 
             // 从数据库查询所有菜单
             const menus = await this.befly.db.getAll({
-                table: 'addon_admin_menu',
-                orderBy: ['sort#ASC', 'id#ASC']
+                table: "addon_admin_menu"
             });
 
             // 缓存到 Redis
-            const result = await this.befly.redis.setObject(RedisKeys.menusAll(), menus.lists);
+            const result = await this.befly.redis.setObject(CacheKeys.menusAll(), menus.lists);
 
             if (result === null) {
-                Logger.warn('⚠️ 菜单缓存失败');
+                Logger.warn("⚠️ 菜单缓存失败");
             }
         } catch (error: any) {
-            Logger.warn({ err: error }, '⚠️ 菜单缓存异常');
+            Logger.warn({ err: error }, "⚠️ 菜单缓存异常");
         }
     }
 
     /**
      * 缓存所有角色的接口权限到 Redis
-     * 优化：使用 Promise.all 利用 Bun Redis 自动 pipeline 特性
+     * 全量重建：清理所有角色权限缓存并重建
+     * - 极简方案：每个角色一个 Set，直接覆盖更新（DEL + SADD）
      */
-    async cacheRolePermissions(): Promise<void> {
+    async rebuildRoleApiPermissions(): Promise<void> {
         try {
             // 检查表是否存在
-            const apiTableExists = await this.befly.db.tableExists('addon_admin_api');
-            const roleTableExists = await this.befly.db.tableExists('addon_admin_role');
+            const apiTableExists = await this.befly.db.tableExists("addon_admin_api");
+            const roleTableExists = await this.befly.db.tableExists("addon_admin_role");
 
             if (!apiTableExists || !roleTableExists) {
-                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
+                Logger.warn("⚠️ 接口或角色表不存在，跳过角色权限缓存");
                 return;
             }
 
-            // 并行查询角色和接口（利用自动 pipeline）
-            const [roles, allApis] = await Promise.all([
-                this.befly.db.getAll({
-                    table: 'addon_admin_role'
-                }),
-                this.befly.db.getAll({
-                    table: 'addon_admin_api'
-                })
-            ]);
+            // 查询所有角色（仅取必要字段）
+            const roles = await this.befly.db.getAll({
+                table: "addon_admin_role",
+                fields: ["code", "apis"]
+            });
+
+            const roleApiIdsMap = new Map<string, number[]>();
+            const allApiIdsSet = new Set<number>();
 
-            // 构建接口 ID -> 路径的映射（避免重复过滤）
-            const apiMap = new Map<number, string>();
-            for (const api of allApis.lists) {
-                apiMap.set(api.id, `${api.method}${api.path}`);
+            for (const role of roles.lists) {
+                if (!role?.code) continue;
+                const apiIds = this.normalizeNumberIdList(role.apis);
+                roleApiIdsMap.set(role.code, apiIds);
+                for (const id of apiIds) {
+                    allApiIdsSet.add(id);
+                }
             }
 
-            // 收集需要缓存的角色权限
-            const cacheOperations: Array<{ roleCode: string; apiPaths: string[] }> = [];
+            const roleCodes = Array.from(roleApiIdsMap.keys());
+            if (roleCodes.length === 0) {
+                Logger.info("✅ 没有需要缓存的角色权限");
+                return;
+            }
 
-            for (const role of roles.lists) {
-                if (!role.apis) continue;
-
-                // 解析角色的接口 ID 列表并映射到路径
-                const apiPaths: string[] = [];
-                const apiIds = role.apis.split(',');
-
-                for (const idStr of apiIds) {
-                    const id = parseInt(idStr.trim());
-                    if (!isNaN(id)) {
-                        const path = apiMap.get(id);
-                        if (path) {
-                            apiPaths.push(path);
-                        }
+            // 构建所有需要的 API 映射（按 ID 分块使用 $in，避免全表扫描/避免超长 IN）
+            const allApiIds = Array.from(allApiIdsSet);
+            const apiMap = await this.buildApiPathMapByIds(allApiIds);
+
+            // 清理所有角色的缓存 key（保证幂等）
+            const roleKeys = roleCodes.map((code) => CacheKeys.roleApis(code));
+            await this.befly.redis.delBatch(roleKeys);
+
+            // 批量写入新缓存（只写入非空权限）
+            const items: Array<{ key: string; members: string[] }> = [];
+
+            for (const roleCode of roleCodes) {
+                const apiIds = roleApiIdsMap.get(roleCode) || [];
+                const membersSet = new Set<string>();
+
+                for (const id of apiIds) {
+                    const apiPath = apiMap.get(id);
+                    if (apiPath) {
+                        membersSet.add(apiPath);
                     }
                 }
 
-                if (apiPaths.length > 0) {
-                    cacheOperations.push({ roleCode: role.code, apiPaths: apiPaths });
+                const members = Array.from(membersSet).sort();
+
+                if (members.length > 0) {
+                    items.push({ key: CacheKeys.roleApis(roleCode), members: members });
                 }
             }
 
-            if (cacheOperations.length === 0) {
-                Logger.info('✅ 没有需要缓存的角色权限');
-                return;
+            if (items.length > 0) {
+                await this.befly.redis.saddBatch(items);
             }
 
-            // 批量删除旧缓存（利用自动 pipeline）
-            const deletePromises = cacheOperations.map((op) => this.befly.redis.del(RedisKeys.roleApis(op.roleCode)));
-            await Promise.all(deletePromises);
+            // 极简方案不做版本/ready/meta：重建完成即生效
+        } catch (error: any) {
+            Logger.warn({ err: error }, "⚠️ 角色权限缓存异常");
+        }
+    }
+
+    /**
+     * 增量刷新单个角色的接口权限缓存
+     * - apiIds 为空数组：仅清理缓存（防止残留）
+     * - apiIds 非空：使用 $in 最小查询，DEL 后 SADD
+     */
+    async refreshRoleApiPermissions(roleCode: string, apiIds: number[]): Promise<void> {
+        if (!roleCode || typeof roleCode !== "string") {
+            throw new Error("roleCode 必须是非空字符串");
+        }
+        const normalizedIds = this.normalizeNumberIdList(apiIds);
+        const roleKey = CacheKeys.roleApis(roleCode);
+
+        // 空数组短路：避免触发 $in 空数组异常，同时保证清理残留
+        if (normalizedIds.length === 0) {
+            await this.befly.redis.del(roleKey);
+            return;
+        }
 
-            // 批量添加新缓存（利用自动 pipeline）
-            const addPromises = cacheOperations.map((op) => this.befly.redis.sadd(RedisKeys.roleApis(op.roleCode), op.apiPaths));
-            const results = await Promise.all(addPromises);
+        const apiMap = await this.buildApiPathMapByIds(normalizedIds);
+        const membersSet = new Set<string>();
+        for (const id of normalizedIds) {
+            const apiPath = apiMap.get(id);
+            if (apiPath) {
+                membersSet.add(apiPath);
+            }
+        }
 
-            // 统计成功缓存的角色数
-            const cachedRoles = results.filter((r) => r > 0).length;
-        } catch (error: any) {
-            Logger.warn({ err: error }, '⚠️ 角色权限缓存异常');
+        const members = Array.from(membersSet);
+
+        await this.befly.redis.del(roleKey);
+        if (members.length > 0) {
+            await this.befly.redis.sadd(roleKey, members);
         }
     }
 
@@ -167,7 +302,7 @@ export class CacheHelper {
         await this.cacheMenus();
 
         // 3. 缓存角色权限
-        await this.cacheRolePermissions();
+        await this.rebuildRoleApiPermissions();
     }
 
     /**
@@ -176,10 +311,10 @@ export class CacheHelper {
      */
     async getApis(): Promise<any[]> {
         try {
-            const apis = await this.befly.redis.getObject<any[]>(RedisKeys.apisAll());
+            const apis = await this.befly.redis.getObject<any[]>(CacheKeys.apisAll());
             return apis || [];
         } catch (error: any) {
-            Logger.error({ err: error }, '获取接口缓存失败');
+            Logger.error({ err: error }, "获取接口缓存失败");
             return [];
         }
     }
@@ -190,10 +325,10 @@ export class CacheHelper {
      */
     async getMenus(): Promise<any[]> {
         try {
-            const menus = await this.befly.redis.getObject<any[]>(RedisKeys.menusAll());
+            const menus = await this.befly.redis.getObject<any[]>(CacheKeys.menusAll());
             return menus || [];
         } catch (error: any) {
-            Logger.error({ err: error }, '获取菜单缓存失败');
+            Logger.error({ err: error }, "获取菜单缓存失败");
             return [];
         }
     }
@@ -205,10 +340,10 @@ export class CacheHelper {
      */
     async getRolePermissions(roleCode: string): Promise<string[]> {
         try {
-            const permissions = await this.befly.redis.smembers(RedisKeys.roleApis(roleCode));
+            const permissions = await this.befly.redis.smembers(CacheKeys.roleApis(roleCode));
             return permissions || [];
         } catch (error: any) {
-            Logger.error({ err: error, roleCode: roleCode }, '获取角色权限缓存失败');
+            Logger.error({ err: error, roleCode: roleCode }, "获取角色权限缓存失败");
             return [];
         }
     }
@@ -221,9 +356,9 @@ export class CacheHelper {
      */
     async checkRolePermission(roleCode: string, apiPath: string): Promise<boolean> {
         try {
-            return await this.befly.redis.sismember(RedisKeys.roleApis(roleCode), apiPath);
+            return await this.befly.redis.sismember(CacheKeys.roleApis(roleCode), apiPath);
         } catch (error: any) {
-            Logger.error({ err: error, roleCode: roleCode }, '检查角色权限失败');
+            Logger.error({ err: error, roleCode: roleCode }, "检查角色权限失败");
             return false;
         }
     }
@@ -235,14 +370,14 @@ export class CacheHelper {
      */
     async deleteRolePermissions(roleCode: string): Promise<boolean> {
         try {
-            const result = await this.befly.redis.del(RedisKeys.roleApis(roleCode));
+            const result = await this.befly.redis.del(CacheKeys.roleApis(roleCode));
             if (result > 0) {
                 Logger.info(`✅ 已删除角色 ${roleCode} 的权限缓存`);
                 return true;
             }
             return false;
         } catch (error: any) {
-            Logger.error({ err: error, roleCode: roleCode }, '删除角色权限缓存失败');
+            Logger.error({ err: error, roleCode: roleCode }, "删除角色权限缓存失败");
             return false;
         }
     }

package/lib/cacheKeys.ts

@@ -0,0 +1,38 @@
+/**
+ * Cache Key 统一管理
+ * 所有缓存键在此统一定义，避免硬编码分散
+ */
+
+/**
+ * Cache Key 生成函数集合
+ */
+export class CacheKeys {
+    /** 所有接口缓存 */
+    static apisAll(): string {
+        return "befly:apis:all";
+    }
+
+    /** 所有菜单缓存 */
+    static menusAll(): string {
+        return "befly:menus:all";
+    }
+
+    /** 角色信息缓存（完整角色对象） */
+    static roleInfo(roleCode: string): string {
+        return `befly:role:info:${roleCode}`;
+    }
+
+    /**
+     * 角色接口权限缓存（Set 集合）
+     * - key: befly:role:apis:${roleCode}
+     * - member: METHOD/path
+     */
+    static roleApis(roleCode: string): string {
+        return `befly:role:apis:${roleCode}`;
+    }
+
+    /** 表结构缓存 */
+    static tableColumns(table: string): string {
+        return `befly:table:columns:${table}`;
+    }
+}

package/lib/cipher.ts

@@ -1,11 +1,11 @@
-/**
+/**
  * 加密工具类 - TypeScript 版本
  * 提供各种哈希、HMAC、密码加密等功能
  */
 
-import { createSign } from 'node:crypto';
+import type { EncodingType, HashAlgorithm, PasswordHashOptions } from "../types/crypto.js";
 
-import type { EncodingType, HashAlgorithm, PasswordHashOptions } from 'befly-shared/types';
+import { createSign } from "node:crypto";
 
 /**
  * 加密工具类
@@ -17,8 +17,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns MD5 哈希值
      */
-    static md5(data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('md5');
+    static md5(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("md5");
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -30,8 +30,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-MD5 签名
      */
-    static hmacMd5(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('md5', key);
+    static hmacMd5(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("md5", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -42,8 +42,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns SHA-1 哈希值
      */
-    static sha1(data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha1');
+    static sha1(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha1");
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -55,8 +55,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA1 签名
      */
-    static hmacSha1(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha1', key);
+    static hmacSha1(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha1", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -67,8 +67,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns SHA-256 哈希值
      */
-    static sha256(data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha256');
+    static sha256(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha256");
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -80,8 +80,8 @@ export class Cipher {
      * @param encoding - 输出编码（'hex' | 'base64' | 'base64url'）
      * @returns RSA-SHA256 签名
      */
-    static rsaSha256(data: string, privateKey: string | Buffer, encoding: 'hex' | 'base64' | 'base64url' = 'hex'): string {
-        const sign = createSign('RSA-SHA256');
+    static rsaSha256(data: string, privateKey: string | Buffer, encoding: "hex" | "base64" | "base64url" = "hex"): string {
+        const sign = createSign("RSA-SHA256");
         sign.update(data);
         const signature = sign.sign(privateKey, encoding);
         return signature;
@@ -94,8 +94,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA256 签名
      */
-    static hmacSha256(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha256', key);
+    static hmacSha256(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha256", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -106,8 +106,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns SHA-512 哈希值
      */
-    static sha512(data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha512');
+    static sha512(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha512");
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -119,8 +119,8 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA512 签名
      */
-    static hmacSha512(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
-        const hasher = new Bun.CryptoHasher('sha512', key);
+    static hmacSha512(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+        const hasher = new Bun.CryptoHasher("sha512", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
@@ -132,7 +132,7 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns 哈希值
      */
-    static hash(algorithm: HashAlgorithm, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
+    static hash(algorithm: HashAlgorithm, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
         const hasher = new Bun.CryptoHasher(algorithm);
         hasher.update(data);
         return hasher.digest(encoding);
@@ -146,7 +146,7 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC 签名
      */
-    static hmac(algorithm: HashAlgorithm, key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = 'hex'): string {
+    static hmac(algorithm: HashAlgorithm, key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
         const hasher = new Bun.CryptoHasher(algorithm, key);
         hasher.update(data);
         return hasher.digest(encoding);
@@ -159,7 +159,7 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns 文件哈希值
      */
-    static async hashFile(filePath: string, algorithm: HashAlgorithm = 'sha256', encoding: EncodingType = 'hex'): Promise<string> {
+    static async hashFile(filePath: string, algorithm: HashAlgorithm = "sha256", encoding: EncodingType = "hex"): Promise<string> {
         const file = Bun.file(filePath);
         const hasher = new Bun.CryptoHasher(algorithm);
 
@@ -192,7 +192,7 @@ export class Cipher {
      */
     static async hashPassword(password: string, options: PasswordHashOptions = {}): Promise<string> {
         const finalOptions = {
-            algorithm: 'bcrypt',
+            algorithm: "bcrypt",
             ...options
         } as any;
         return await Bun.password.hash(password, finalOptions);
@@ -219,7 +219,7 @@ export class Cipher {
      * @returns Base64 编码的字符串
      */
     static base64Encode(data: string): string {
-        return Buffer.from(data, 'utf8').toString('base64');
+        return Buffer.from(data, "utf8").toString("base64");
     }
 
     /**
@@ -228,7 +228,7 @@ export class Cipher {
      * @returns 解码后的字符串
      */
     static base64Decode(data: string): string {
-        return Buffer.from(data, 'base64').toString('utf8');
+        return Buffer.from(data, "base64").toString("utf8");
     }
 
     /**
@@ -239,9 +239,9 @@ export class Cipher {
     static randomString(length: number): string {
         const bytes = Math.ceil(length / 2);
         const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
-        let result = '';
+        let result = "";
         for (let i = 0; i < randomBytes.length; i++) {
-            result += randomBytes[i].toString(16).padStart(2, '0');
+            result += randomBytes[i].toString(16).padStart(2, "0");
         }
         return result.slice(0, length);
     }
@@ -254,6 +254,6 @@ export class Cipher {
      */
     static fastHash(data: string | Uint8Array, seed: number = 0): number {
         const result = Bun.hash(data, seed);
-        return typeof result === 'bigint' ? Number(result) : result;
+        return typeof result === "bigint" ? Number(result) : result;
     }
 }