befly 3.0.0 → 3.0.1

package/utils/redisHelper.ts

@@ -6,114 +6,30 @@
 import { RedisClient } from 'bun';
 import { Env } from '../config/env.js';
 import { Logger } from './logger.js';
+import { getRedis } from './database.js';
 
 /**
  * Redis 键前缀
  */
 const prefix = Env.REDIS_KEY_PREFIX ? `${Env.REDIS_KEY_PREFIX}:` : '';
 
-/**
- * 构建 Redis 连接 URL
- * @returns Redis 连接 URL
- */
-function buildRedisUrl(): string {
-    const { REDIS_HOST, REDIS_PORT, REDIS_USERNAME, REDIS_PASSWORD, REDIS_DB } = Env;
-
-    // 构建认证部分
-    let auth = '';
-    if (REDIS_USERNAME && REDIS_PASSWORD) {
-        auth = `${REDIS_USERNAME}:${REDIS_PASSWORD}@`;
-    } else if (REDIS_PASSWORD) {
-        auth = `:${REDIS_PASSWORD}@`;
-    }
-
-    // 构建完整 URL
-    const url = `redis://${auth}${REDIS_HOST}:${REDIS_PORT}/${REDIS_DB}`;
-
-    return url;
-}
-
-/**
- * Redis 客户端实例
- */
-let redisClient: RedisClient | null = null;
-
-/**
- * 初始化 Redis 客户端
- * @returns Redis 客户端实例
- * @throws 如果连接失败
- */
-export const initRedisClient = async (): Promise<RedisClient> => {
-    if (!redisClient) {
-        try {
-            const url = buildRedisUrl();
-            redisClient = new RedisClient(url, {
-                // 连接超时（毫秒）
-                connectionTimeout: 10000,
-                // 空闲超时设为 0，表示永不超时
-                idleTimeout: 0,
-                // 断开连接时自动重连
-                autoReconnect: true,
-                // 最大重连次数，0 表示无限重连
-                maxRetries: 0,
-                // 断开连接时缓存命令
-                enableOfflineQueue: true,
-                // 自动管道化命令
-                enableAutoPipelining: true
-            });
-
-            // 测试连接是否成功
-            await redisClient.ping();
-            Logger.info('Redis 连接成功');
-        } catch (error: any) {
-            redisClient = null;
-            Logger.error({
-                msg: 'Redis 连接失败',
-                message: error.message,
-                code: error.code,
-                stack: error.stack
-            });
-            throw new Error(`Redis 连接失败: ${error.message}`);
-        }
-    }
-    return redisClient;
-};
-
 /**
  * 获取 Redis 客户端
  * @returns Redis 客户端实例
- * @throws 如果连接失败
+ * @throws 如果客户端未初始化
  */
-export const getRedisClient = async (): Promise<RedisClient> => {
-    if (!redisClient) {
-        return await initRedisClient();
+function getClient(): RedisClient {
+    const client = getRedis();
+    if (!client) {
+        throw new Error('Redis 客户端未初始化，请先调用 initDatabase() 或 initRedisOnly()');
     }
-    return redisClient;
-};
-
-/**
- * 关闭 Redis 连接
- */
-export const closeRedisClient = (): void => {
-    if (redisClient) {
-        redisClient.close();
-        redisClient = null;
-    }
-};
+    return client;
+}
 
 /**
  * Redis 助手对象
  */
 export const RedisHelper = {
-    /**
-     * 获取 Redis 客户端实例
-     * @returns Redis 客户端
-     * @throws 如果连接失败
-     */
-    async getRedisClient(): Promise<RedisClient> {
-        return await getRedisClient();
-    },
-
     /**
      * 设置对象到 Redis
      * @param key - 键名
@@ -123,7 +39,7 @@ export const RedisHelper = {
      */
     async setObject<T = any>(key: string, obj: T, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const data = JSON.stringify(obj);
             const pkey = `${prefix}${key}`;
 
@@ -132,11 +48,7 @@ export const RedisHelper = {
             }
             return await client.set(pkey, data);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis setObject 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis setObject 错误', error);
             return null;
         }
     },
@@ -148,16 +60,12 @@ export const RedisHelper = {
      */
     async getObject<T = any>(key: string): Promise<T | null> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             const data = await client.get(pkey);
             return data ? JSON.parse(data) : null;
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis getObject 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis getObject 错误', error);
             return null;
         }
     },
@@ -168,56 +76,53 @@ export const RedisHelper = {
      */
     async delObject(key: string): Promise<void> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             await client.del(pkey);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis delObject 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis delObject 错误', error);
         }
     },
 
     /**
      * 生成基于时间的唯一 ID
-     * 格式: Date.now()(13位) + 3位自增 = 16位纯数字
-     * 容量: 1000/毫秒 = 1,000,000/秒
-     * @returns 唯一 ID (16位纯数字)
+     * 格式: 秒级时间戳(10位) + 4位自增 = 14位纯数字
+     * 容量: 10000/秒 = 864,000,000/天
+     * 范围: 到 2286年9月
+     * @returns 唯一 ID (14位纯数字)
      */
     async genTimeID(): Promise<number> {
-        const client = await getRedisClient();
-        const timestamp = Date.now();
+        const client = getClient();
+        const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
         const counter = await client.incr(key);
         await client.expire(key, 1);
 
-        const counterSuffix = (counter % 1000).toString().padStart(3, '0');
+        const counterSuffix = (counter % 10000).toString().padStart(4, '0');
 
         return Number(`${timestamp}${counterSuffix}`);
     },
 
     /**
      * 批量生成基于时间的唯一 ID
-     * 格式: Date.now()(13位) + 3位自增 = 16位纯数字
+     * 格式: 秒级时间戳(10位) + 4位自增 = 14位纯数字
      * @param count - 需要生成的 ID 数量
-     * @returns ID 数组 (16位纯数字)
+     * @returns ID 数组 (14位纯数字)
      */
     async genTimeIDBatch(count: number): Promise<number[]> {
         if (count <= 0) {
             return [];
         }
 
-        // 限制单次批量生成数量
+        // 限制单次批量生成数量（每秒最多10000个）
         const MAX_BATCH_SIZE = 10000;
         if (count > MAX_BATCH_SIZE) {
             throw new Error(`批量大小 ${count} 超过最大限制 ${MAX_BATCH_SIZE}`);
         }
 
-        const client = await getRedisClient();
-        const timestamp = Date.now();
+        const client = getClient();
+        const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
         // 使用 INCRBY 一次性获取 N 个连续计数
@@ -228,7 +133,7 @@ export const RedisHelper = {
         const ids: number[] = [];
         for (let i = 0; i < count; i++) {
             const counter = startCounter - count + i + 1; // 计算每个 ID 的计数值
-            const counterSuffix = (counter % 1000).toString().padStart(3, '0');
+            const counterSuffix = (counter % 10000).toString().padStart(4, '0');
             ids.push(Number(`${timestamp}${counterSuffix}`));
         }
 
@@ -243,18 +148,14 @@ export const RedisHelper = {
      */
     async setString(key: string, value: string, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             if (ttl) {
                 return await client.setEx(pkey, ttl, value);
             }
             return await client.set(pkey, value);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis setString 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis setString 错误', error);
             return null;
         }
     },
@@ -265,15 +166,11 @@ export const RedisHelper = {
      */
     async getString(key: string): Promise<string | null> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             return await client.get(pkey);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis getString 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis getString 错误', error);
             return null;
         }
     },
@@ -284,15 +181,11 @@ export const RedisHelper = {
      */
     async exists(key: string): Promise<number> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             return await client.exists(pkey);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis exists 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis exists 错误', error);
             return 0;
         }
     },
@@ -304,15 +197,11 @@ export const RedisHelper = {
      */
     async expire(key: string, seconds: number): Promise<number> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             return await client.expire(pkey, seconds);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis expire 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis expire 错误', error);
             return 0;
         }
     },
@@ -323,16 +212,110 @@ export const RedisHelper = {
      */
     async ttl(key: string): Promise<number> {
         try {
-            const client = await getRedisClient();
+            const client = getClient();
             const pkey = `${prefix}${key}`;
             return await client.ttl(pkey);
         } catch (error: any) {
-            Logger.error({
-                msg: 'Redis ttl 错误',
-                message: error.message,
-                stack: error.stack
-            });
+            Logger.error('Redis ttl 错误', error);
             return -1;
         }
+    },
+
+    /**
+     * 向 Set 中添加一个或多个成员
+     * @param key - 键名
+     * @param members - 成员数组
+     * @returns 成功添加的成员数量
+     */
+    async sadd(key: string, members: string[]): Promise<number> {
+        try {
+            if (members.length === 0) return 0;
+
+            const client = getClient();
+            const pkey = `${prefix}${key}`;
+            return await client.sadd(pkey, ...members);
+        } catch (error: any) {
+            Logger.error('Redis sadd 错误', error);
+            return 0;
+        }
+    },
+
+    /**
+     * 判断成员是否在 Set 中
+     * @param key - 键名
+     * @param member - 成员
+     * @returns 1 表示存在，0 表示不存在
+     */
+    async sismember(key: string, member: string): Promise<number> {
+        try {
+            const client = getClient();
+            const pkey = `${prefix}${key}`;
+            return await client.sismember(pkey, member);
+        } catch (error: any) {
+            Logger.error('Redis sismember 错误', error);
+            return 0;
+        }
+    },
+
+    /**
+     * 获取 Set 的成员数量
+     * @param key - 键名
+     * @returns 成员数量
+     */
+    async scard(key: string): Promise<number> {
+        try {
+            const client = getClient();
+            const pkey = `${prefix}${key}`;
+            return await client.scard(pkey);
+        } catch (error: any) {
+            Logger.error('Redis scard 错误', error);
+            return 0;
+        }
+    },
+
+    /**
+     * 获取 Set 的所有成员
+     * @param key - 键名
+     * @returns 成员数组
+     */
+    async smembers(key: string): Promise<string[]> {
+        try {
+            const client = getClient();
+            const pkey = `${prefix}${key}`;
+            return await client.smembers(pkey);
+        } catch (error: any) {
+            Logger.error('Redis smembers 错误', error);
+            return [];
+        }
+    },
+
+    /**
+     * 删除键
+     * @param key - 键名
+     * @returns 删除的键数量
+     */
+    async del(key: string): Promise<number> {
+        try {
+            const client = getClient();
+            const pkey = `${prefix}${key}`;
+            return await client.del(pkey);
+        } catch (error: any) {
+            Logger.error('Redis del 错误', error);
+            return 0;
+        }
+    },
+
+    /**
+     * 测试 Redis 连接
+     * @returns ping 响应结果
+     */
+    async ping(): Promise<string> {
+        try {
+            const client = getClient();
+            return await client.ping();
+        } catch (error: any) {
+            Logger.error('Redis ping 错误', error);
+            throw error;
+        }
     }
 };

package/{types/context.ts → utils/requestContext.ts}

@@ -106,14 +106,14 @@ export class RequestContext {
      * @param key - 参数键名
      */
     has(key: string): boolean {
-        return key in this.params;
+        return key in this.body;
     }
 
     /**
      * 获取所有参数
      */
     all(): Record<string, any> {
-        return { ...this.params };
+        return { ...this.body };
     }
 
     /**
@@ -162,6 +162,6 @@ export class RequestContext {
      * 获取用户角色
      */
     getUserRole(): string | null {
-        return this.user.role || this.user.role_type || null;
+        return this.user.role || this.user.roleType || null;
     }
 }