befly 3.8.19 → 3.8.21

package/lib/jwt.ts

@@ -4,13 +4,28 @@
  */
 
 import { createHmac } from 'crypto';
-import { Env } from '../env.js';
 import type { JwtPayload, JwtSignOptions, JwtVerifyOptions, JwtAlgorithm, JwtHeader, JwtDecoded } from '../types/jwt';
+import type { AuthConfig } from '../types/befly';
 
 /**
  * JWT 工具类
  */
 export class Jwt {
+    /** 默认配置 */
+    private static config: AuthConfig = {
+        secret: 'befly-secret',
+        expiresIn: '7d',
+        algorithm: 'HS256'
+    };
+
+    /**
+     * 配置 JWT
+     * @param config - JWT 配置
+     */
+    static configure(config: AuthConfig) {
+        this.config = { ...this.config, ...config };
+    }
+
     /** 算法映射 */
     private static readonly ALGORITHMS: Record<JwtAlgorithm, string> = {
         HS256: 'sha256',
@@ -94,23 +109,15 @@ export class Jwt {
     }
 
     /**
-     * 签名 JWT token
-     * @param payload - JWT载荷数据
-     * @param options - 签名选项（自动使用 Env.JWT_SECRET）
-     * @returns JWT token字符串
+     * 签名生成 Token
+     * @param payload - 数据载荷
+     * @param options - 签名选项
+     * @returns Token 字符串
      */
-    static sign(payload: JwtPayload, options?: JwtSignOptions): string {
-        if (!payload || typeof payload !== 'object') {
-            throw new Error('载荷必须是非空对象');
-        }
-
-        const secret = options?.secret || Env.JWT_SECRET;
-        if (!secret) {
-            throw new Error('JWT密钥未配置');
-        }
-
-        const opts = options || {};
-        const algorithm = (opts.algorithm || Env.JWT_ALGORITHM || 'HS256') as JwtAlgorithm;
+    static async sign(payload: JwtPayload, options: JwtSignOptions = {}): Promise<string> {
+        const secret = options.secret || this.config.secret || 'befly-secret';
+        const expiresIn = options.expiresIn || this.config.expiresIn || '7d';
+        const algorithm = (options.algorithm || this.config.algorithm || 'HS256') as JwtAlgorithm;
 
         const now = Math.floor(Date.now() / 1000);
 
@@ -125,22 +132,18 @@ export class Jwt {
         // 创建 payload
         const jwtPayload: JwtPayload = { ...payload, iat: now };
 
-        if (opts.expiresIn) {
-            const expSeconds = Jwt.parseExpiration(opts.expiresIn);
-            jwtPayload.exp = now + expSeconds;
-        } else {
-            // 使用默认过期时间
-            const defaultExpiry = Env.JWT_EXPIRES_IN || '7d';
-            const expSeconds = Jwt.parseExpiration(defaultExpiry);
+        if (expiresIn) {
+            const expSeconds = Jwt.parseExpiration(expiresIn);
             jwtPayload.exp = now + expSeconds;
         }
-        if (opts.issuer) jwtPayload.iss = opts.issuer;
-        if (opts.audience) jwtPayload.aud = opts.audience;
-        if (opts.subject) jwtPayload.sub = opts.subject;
-        if (opts.notBefore) {
-            jwtPayload.nbf = typeof opts.notBefore === 'number' ? opts.notBefore : now + Jwt.parseExpiration(opts.notBefore);
+
+        if (options.issuer) jwtPayload.iss = options.issuer;
+        if (options.audience) jwtPayload.aud = options.audience;
+        if (options.subject) jwtPayload.sub = options.subject;
+        if (options.notBefore) {
+            jwtPayload.nbf = typeof options.notBefore === 'number' ? options.notBefore : now + Jwt.parseExpiration(options.notBefore);
         }
-        if (opts.jwtId) jwtPayload.jti = opts.jwtId;
+        if (options.jwtId) jwtPayload.jti = options.jwtId;
 
         const encodedPayload = Jwt.base64UrlEncode(JSON.stringify(jwtPayload));
 
@@ -152,78 +155,66 @@ export class Jwt {
     }
 
     /**
-     * 验证 JWT token
-     * @param token - JWT token字符串
-     * @param options - 验证选项（自动使用 Env.JWT_SECRET）
-     * @returns 解码后的载荷数据
+     * 验证 Token
+     * @param token - Token 字符串
+     * @param options - 验证选项
+     * @returns 解码后的载荷
      */
-    static verify(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verify<T = JwtPayload>(token: string, options: JwtVerifyOptions = {}): Promise<T> {
         if (!token || typeof token !== 'string') {
             throw new Error('Token必须是非空字符串');
         }
 
-        const secret = options?.secret || Env.JWT_SECRET;
-        if (!secret) {
-            throw new Error('JWT密钥未配置');
-        }
-
-        const opts = options || {};
+        const secret = options.secret || this.config.secret || 'befly-secret';
+        const algorithm = (options.algorithm || this.config.algorithm || 'HS256') as JwtAlgorithm;
 
         const parts = token.split('.');
         if (parts.length !== 3) {
-            throw new Error('JWT格式无效');
+            throw new Error('Token 格式无效');
         }
 
-        try {
-            // 解析 header 和 payload
-            const header = JSON.parse(Jwt.base64UrlDecode(parts[0])) as JwtHeader;
-            const payload = JSON.parse(Jwt.base64UrlDecode(parts[1])) as JwtPayload;
-            const signature = parts[2];
+        const [headerB64, payloadB64, signature] = parts;
 
-            // 验证算法
-            if (!Jwt.ALGORITHMS[header.alg]) {
-                throw new Error(`不支持的算法: ${header.alg}`);
-            }
+        // 验证签名
+        const data = `${headerB64}.${payloadB64}`;
+        const expectedSignature = Jwt.createSignature(algorithm, secret, data);
 
-            // 验证签名
-            const data = `${parts[0]}.${parts[1]}`;
-            const expectedSignature = Jwt.createSignature(header.alg, secret, data);
+        if (!Jwt.constantTimeCompare(signature, expectedSignature)) {
+            throw new Error('Token 签名无效');
+        }
 
-            if (!Jwt.constantTimeCompare(signature, expectedSignature)) {
-                throw new Error('Token签名无效');
-            }
+        // 解码 payload
+        const payloadStr = Jwt.base64UrlDecode(payloadB64);
+        let payload: JwtPayload;
+        try {
+            payload = JSON.parse(payloadStr);
+        } catch (e) {
+            throw new Error('Token 载荷无效');
+        }
 
-            // 验证时间
+        // 验证过期时间
+        if (!options.ignoreExpiration) {
             const now = Math.floor(Date.now() / 1000);
-
-            if (!opts.ignoreExpiration && payload.exp && payload.exp < now) {
-                throw new Error('Token已过期 (expired)');
-            }
-            if (!opts.ignoreNotBefore && payload.nbf && payload.nbf > now) {
-                throw new Error('Token尚未生效');
-            }
-
-            // 验证 issuer、audience、subject
-            if (opts.issuer && payload.iss !== opts.issuer) {
-                throw new Error('Token发行者无效');
-            }
-            if (opts.audience) {
-                const audiences = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
-                if (!audiences.includes(opts.audience)) {
-                    throw new Error('Token受众无效');
-                }
-            }
-            if (opts.subject && payload.sub !== opts.subject) {
-                throw new Error('Token主题无效');
+            if (payload.exp && payload.exp < now) {
+                throw new Error('Token 已过期');
             }
+        }
 
-            return payload;
-        } catch (error: any) {
-            if (error.message.includes('JWT') || error.message.includes('Token') || error.message.includes('无效') || error.message.includes('过期') || error.message.includes('不支持')) {
-                throw error;
-            }
-            throw new Error('Token验证失败: ' + error.message);
+        // 验证其他声明
+        if (options.issuer && payload.iss !== options.issuer) {
+            throw new Error('Token issuer 无效');
         }
+        if (options.audience && payload.aud !== options.audience) {
+            throw new Error('Token audience 无效');
+        }
+        if (options.subject && payload.sub !== options.subject) {
+            throw new Error('Token subject 无效');
+        }
+        if (options.jwtId && payload.jti !== options.jwtId) {
+            throw new Error('Token jwtId 无效');
+        }
+
+        return payload as T;
     }
 
     /**
@@ -341,14 +332,14 @@ export class Jwt {
     /**
      * 创建用户 token（快捷方法）
      */
-    static create(payload: JwtPayload): string {
+    static async create(payload: JwtPayload): Promise<string> {
         return this.sign(payload);
     }
 
     /**
      * 检查 token（快捷方法）
      */
-    static check(token: string): JwtPayload {
+    static async check(token: string): Promise<JwtPayload> {
         return this.verify(token);
     }
 
@@ -362,64 +353,64 @@ export class Jwt {
     /**
      * 签名用户认证 token
      */
-    static signUserToken(userInfo: JwtPayload, options?: JwtSignOptions): string {
+    static async signUserToken(userInfo: JwtPayload, options?: JwtSignOptions): Promise<string> {
         return this.sign(userInfo, options);
     }
 
     /**
      * 签名 API 访问 token
      */
-    static signAPIToken(payload: JwtPayload, options?: JwtSignOptions): string {
+    static async signAPIToken(payload: JwtPayload, options?: JwtSignOptions): Promise<string> {
         return this.sign(payload, { audience: 'api', expiresIn: '1h', ...options });
     }
 
     /**
      * 签名刷新 token
      */
-    static signRefreshToken(payload: JwtPayload, options?: JwtSignOptions): string {
+    static async signRefreshToken(payload: JwtPayload, options?: JwtSignOptions): Promise<string> {
         return this.sign(payload, { audience: 'refresh', expiresIn: '30d', ...options });
     }
 
     /**
      * 签名临时 token (用于重置密码等)
      */
-    static signTempToken(payload: JwtPayload, options?: JwtSignOptions): string {
+    static async signTempToken(payload: JwtPayload, options?: JwtSignOptions): Promise<string> {
         return this.sign(payload, { audience: 'temporary', expiresIn: '15m', ...options });
     }
 
     /**
      * 验证用户认证 token
      */
-    static verifyUserToken(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verifyUserToken(token: string, options?: JwtVerifyOptions): Promise<JwtPayload> {
         return this.verify(token, options);
     }
 
     /**
      * 验证 API 访问 token
      */
-    static verifyAPIToken(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verifyAPIToken(token: string, options?: JwtVerifyOptions): Promise<JwtPayload> {
         return this.verify(token, { audience: 'api', ...options });
     }
 
     /**
      * 验证刷新 token
      */
-    static verifyRefreshToken(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verifyRefreshToken(token: string, options?: JwtVerifyOptions): Promise<JwtPayload> {
         return this.verify(token, { audience: 'refresh', ...options });
     }
 
     /**
      * 验证临时 token
      */
-    static verifyTempToken(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verifyTempToken(token: string, options?: JwtVerifyOptions): Promise<JwtPayload> {
         return this.verify(token, { audience: 'temporary', ...options });
     }
 
     /**
      * 验证 token 并检查权限
      */
-    static verifyWithPermissions(token: string, requiredPermissions: string | string[], options?: JwtVerifyOptions): JwtPayload {
-        const payload = this.verify(token, options);
+    static async verifyWithPermissions(token: string, requiredPermissions: string | string[], options?: JwtVerifyOptions): Promise<JwtPayload> {
+        const payload = await this.verify(token, options);
 
         if (!payload.permissions) {
             throw new Error('Token中不包含权限信息');
@@ -438,8 +429,8 @@ export class Jwt {
     /**
      * 验证 token 并检查角色
      */
-    static verifyWithRoles(token: string, requiredRoles: string | string[], options?: JwtVerifyOptions): JwtPayload {
-        const payload = this.verify(token, options);
+    static async verifyWithRoles(token: string, requiredRoles: string | string[], options?: JwtVerifyOptions): Promise<JwtPayload> {
+        const payload = await this.verify(token, options);
 
         if (!payload.role && !payload.roles) {
             throw new Error('Token中不包含角色信息');
@@ -460,7 +451,7 @@ export class Jwt {
     /**
      * 软验证 token (忽略过期时间)
      */
-    static verifySoft(token: string, options?: JwtVerifyOptions): JwtPayload {
+    static async verifySoft(token: string, options?: JwtVerifyOptions): Promise<JwtPayload> {
         return this.verify(token, { ignoreExpiration: true, ...options });
     }
 }

package/lib/logger.ts

@@ -5,8 +5,19 @@
 
 import { join } from 'pathe';
 import { appendFile, stat } from 'node:fs/promises';
-import { Env } from '../env.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import type { LogLevel } from '../types/common.js';
+import type { LoggerConfig } from '../types/befly.js';
+
+/**
+ * 日志上下文存储
+ */
+export interface LogContext {
+    requestId?: string;
+    [key: string]: any;
+}
+
+export const logContextStorage = new AsyncLocalStorage<LogContext>();
 
 /**
  * 日志消息类型
@@ -34,6 +45,23 @@ export class Logger {
     /** 当前使用的日志文件缓存 */
     private static currentFiles: Map<string, string> = new Map();
 
+    /** 日志配置 */
+    private static config: LoggerConfig = {
+        debug: 1,
+        excludeFields: 'password,token,secret',
+        dir: './logs',
+        console: 1,
+        maxSize: 10 * 1024 * 1024
+    };
+
+    /**
+     * 配置日志器
+     * @param config - 日志配置
+     */
+    static configure(config: LoggerConfig) {
+        this.config = { ...this.config, ...config };
+    }
+
     /**
      * 记录日志
      * @param level - 日志级别
@@ -41,7 +69,7 @@ export class Logger {
      */
     static async log(level: LogLevel, message: LogMessage): Promise<void> {
         // debug 日志特殊处理：仅当 LOG_DEBUG=1 时才记录
-        if (level === 'debug' && Env.LOG_DEBUG !== 1) return;
+        if (level === 'debug' && this.config.debug !== 1) return;
 
         // 格式化消息
         const timestamp = formatDate();
@@ -56,10 +84,15 @@ export class Logger {
 
         // 格式化日志消息
         const levelStr = level.toUpperCase().padStart(5);
-        const logMessage = `[${timestamp}] ${levelStr} - ${content}`;
+
+        // 获取上下文中的 requestId
+        const store = logContextStorage.getStore();
+        const requestId = store?.requestId ? ` [${store.requestId}]` : '';
+
+        const logMessage = `[${timestamp}]${requestId} ${levelStr} - ${content}`;
 
         // 控制台输出
-        if (Env.LOG_TO_CONSOLE === 1) {
+        if (this.config.console === 1) {
             console.log(logMessage);
         }
 
@@ -82,6 +115,7 @@ export class Logger {
      */
     static async writeToFile(message: string, level: LogLevel = 'info'): Promise<void> {
         try {
+            const logDir = this.config.dir || './logs';
             // 确定文件前缀
             const prefix = level === 'debug' ? 'debug' : new Date().toISOString().split('T')[0];
 
@@ -91,7 +125,7 @@ export class Logger {
             if (currentLogFile) {
                 try {
                     const stats = await stat(currentLogFile);
-                    if (stats.size >= Env.LOG_MAX_SIZE) {
+                    if (stats.size >= (this.config.maxSize || 10 * 1024 * 1024)) {
                         this.currentFiles.delete(prefix);
                         currentLogFile = undefined;
                     }
@@ -104,7 +138,7 @@ export class Logger {
             // 查找或创建新文件
             if (!currentLogFile) {
                 const glob = new Bun.Glob(`${prefix}.*.log`);
-                const files = await Array.fromAsync(glob.scan(Env.LOG_DIR || 'logs'));
+                const files = await Array.fromAsync(glob.scan(this.config.dir || 'logs'));
 
                 // 按索引排序并查找可用文件
                 const getIndex = (f: string) => parseInt(f.match(/\.(\d+)\.log$/)?.[1] || '0');
@@ -112,10 +146,11 @@ export class Logger {
 
                 let foundFile = false;
                 for (let i = files.length - 1; i >= 0; i--) {
-                    const filePath = join(Env.LOG_DIR || 'logs', files[i]);
+                    const filePath = join(this.config.dir || 'logs', files[i]);
                     try {
                         const stats = await stat(filePath);
-                        if (stats.size < Env.LOG_MAX_SIZE) {
+                        // 检查文件大小
+                        if (stats.size < (this.config.maxSize || 10 * 1024 * 1024)) {
                             currentLogFile = filePath;
                             foundFile = true;
                             break;
@@ -128,7 +163,7 @@ export class Logger {
                 // 没有可用文件,创建新文件
                 if (!foundFile) {
                     const maxIndex = files.length > 0 ? Math.max(...files.map(getIndex)) : -1;
-                    currentLogFile = join(Env.LOG_DIR || 'logs', `${prefix}.${maxIndex + 1}.log`);
+                    currentLogFile = join(this.config.dir || 'logs', `${prefix}.${maxIndex + 1}.log`);
                 }
 
                 this.currentFiles.set(prefix, currentLogFile);
@@ -194,18 +229,4 @@ export class Logger {
     static clearCache(): void {
         this.currentFiles.clear();
     }
-
-    /**
-     * 打印当前运行环境
-     * 用于命令开始时提示用户当前环境
-     */
-    static printEnv(): void {
-        console.log('========================================');
-        console.log('开始执行完整同步流程');
-        console.log(`当前环境: ${Env.NODE_ENV || 'development'}`);
-        console.log(`项目名称: ${Env.APP_NAME}`);
-        console.log(`数据库地址: ${Env.DB_HOST}`);
-        console.log(`数据库名称: ${Env.DB_NAME}`);
-        console.log('========================================\n');
-    }
 }

package/lib/redisHelper.ts

@@ -4,30 +4,27 @@
  */
 
 import { RedisClient } from 'bun';
-import { Env } from '../env.js';
 import { Logger } from '../lib/logger.js';
 import { Database } from './database.js';
 
-/**
- * Redis 键前缀
- */
-const prefix = Env.REDIS_KEY_PREFIX ? `${Env.REDIS_KEY_PREFIX}:` : '';
-
 /**
  * Redis 助手类
  */
 export class RedisHelper {
     private client: RedisClient;
+    private prefix: string;
 
     /**
      * 构造函数
+     * @param prefix - Key 前缀
      */
-    constructor() {
+    constructor(prefix: string = '') {
         const client = Database.getRedis();
         if (!client) {
             throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
         }
         this.client = client;
+        this.prefix = prefix ? `${prefix}:` : '';
     }
 
     /**
@@ -40,7 +37,7 @@ export class RedisHelper {
     async setObject<T = any>(key: string, obj: T, ttl: number | null = null): Promise<string | null> {
         try {
             const data = JSON.stringify(obj);
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
 
             if (ttl) {
                 return await this.client.setex(pkey, ttl, data);
@@ -59,7 +56,7 @@ export class RedisHelper {
      */
     async getObject<T = any>(key: string): Promise<T | null> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             const data = await this.client.get(pkey);
             return data ? JSON.parse(data) : null;
         } catch (error: any) {
@@ -74,7 +71,7 @@ export class RedisHelper {
      */
     async delObject(key: string): Promise<void> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis delObject 错误', error);
@@ -90,7 +87,7 @@ export class RedisHelper {
      */
     async genTimeID(): Promise<number> {
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
-        const key = `${prefix}time_id_counter:${timestamp}`;
+        const key = `${this.prefix}time_id_counter:${timestamp}`;
 
         const counter = await this.client.incr(key);
         await this.client.expire(key, 1);
@@ -118,7 +115,7 @@ export class RedisHelper {
         }
 
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
-        const key = `${prefix}time_id_counter:${timestamp}`;
+        const key = `${this.prefix}time_id_counter:${timestamp}`;
 
         // 使用 INCRBY 一次性获取 N 个连续计数
         const startCounter = await this.client.incrby(key, count);
@@ -143,7 +140,7 @@ export class RedisHelper {
      */
     async setString(key: string, value: string, ttl: number | null = null): Promise<string | null> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             if (ttl) {
                 return await this.client.setex(pkey, ttl, value);
             }
@@ -160,7 +157,7 @@ export class RedisHelper {
      */
     async getString(key: string): Promise<string | null> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.get(pkey);
         } catch (error: any) {
             Logger.error('Redis getString 错误', error);
@@ -174,7 +171,7 @@ export class RedisHelper {
      */
     async exists(key: string): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.exists(pkey);
         } catch (error: any) {
             Logger.error('Redis exists 错误', error);
@@ -189,7 +186,7 @@ export class RedisHelper {
      */
     async expire(key: string, seconds: number): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.expire(pkey, seconds);
         } catch (error: any) {
             Logger.error('Redis expire 错误', error);
@@ -203,7 +200,7 @@ export class RedisHelper {
      */
     async ttl(key: string): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.ttl(pkey);
         } catch (error: any) {
             Logger.error('Redis ttl 错误', error);
@@ -221,7 +218,7 @@ export class RedisHelper {
         try {
             if (members.length === 0) return 0;
 
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.sadd(pkey, ...members);
         } catch (error: any) {
             Logger.error('Redis sadd 错误', error);
@@ -237,7 +234,7 @@ export class RedisHelper {
      */
     async sismember(key: string, member: string): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.sismember(pkey, member);
         } catch (error: any) {
             Logger.error('Redis sismember 错误', error);
@@ -252,7 +249,7 @@ export class RedisHelper {
      */
     async scard(key: string): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.scard(pkey);
         } catch (error: any) {
             Logger.error('Redis scard 错误', error);
@@ -267,7 +264,7 @@ export class RedisHelper {
      */
     async smembers(key: string): Promise<string[]> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.smembers(pkey);
         } catch (error: any) {
             Logger.error('Redis smembers 错误', error);
@@ -282,7 +279,7 @@ export class RedisHelper {
      */
     async del(key: string): Promise<number> {
         try {
-            const pkey = `${prefix}${key}`;
+            const pkey = `${this.prefix}${key}`;
             return await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis del 错误', error);