befly 3.8.19 → 3.8.20

package/README.md

@@ -55,7 +55,6 @@ bun run main.ts
 
 ```typescript
 // apis/user/hello.ts
-import { Yes } from 'befly';
 import type { ApiRoute } from 'befly';
 
 export default {
@@ -63,9 +62,12 @@ export default {
     auth: false, // 公开接口
     fields: {},
     handler: async (befly, ctx) => {
-        return Yes('Hello, Befly!', {
-            timestamp: Date.now()
-        });
+        return {
+            msg: 'Hello, Befly!',
+            data: {
+                timestamp: Date.now()
+            }
+        };
     }
 } as ApiRoute;
 ```
@@ -77,7 +79,6 @@ export default {
 ### TypeScript 全面支持
 
 ```typescript
-import { Yes } from 'befly';
 import type { ApiRoute, BeflyContext } from 'befly';
 import type { User } from './types/models';
 
@@ -97,7 +98,7 @@ export default {
             where: { id }
         });
 
-        return Yes('查询成功', user);
+        return { msg: '查询成功', data: user };
     }
 } as ApiRoute;
 ```

package/bunfig.toml

@@ -1,3 +1,3 @@
+env = false
 [install]
-# 使用隔离模式
 linker = "isolated"

package/lib/database.ts

@@ -4,11 +4,10 @@
  */
 
 import { SQL, RedisClient } from 'bun';
-import { Env } from '../env.js';
 import { Logger } from './logger.js';
 import { DbHelper } from './dbHelper.js';
 import { RedisHelper } from './redisHelper.js';
-import type { BeflyContext } from '../types/befly.js';
+import type { BeflyContext, DatabaseConfig, RedisConfig } from '../types/befly.js';
 import type { SqlClientOptions } from '../types/database.js';
 
 /**
@@ -26,50 +25,49 @@ export class Database {
 
     /**
      * 连接 SQL 数据库
-     * @param options - SQL 客户端配置选项
+     * @param config - 数据库配置
      * @returns SQL 客户端实例
      */
-    static async connectSql(options: SqlClientOptions = {}): Promise<SQL> {
+    static async connectSql(config: DatabaseConfig): Promise<SQL> {
         // 构建数据库连接字符串
-        const type = Env.DB_TYPE || '';
-        const host = Env.DB_HOST || '';
-        const port = Env.DB_PORT;
-        const user = encodeURIComponent(Env.DB_USER || '');
-        const password = encodeURIComponent(Env.DB_PASS || '');
-        const database = encodeURIComponent(Env.DB_NAME || '');
+        const type = config.type || 'mysql';
+        const host = config.host || '127.0.0.1';
+        const port = config.port || 3306;
+        const user = encodeURIComponent(config.username || 'root');
+        const password = encodeURIComponent(config.password || 'root');
+        const database = encodeURIComponent(config.database || 'befly_demo');
 
         let finalUrl: string;
         if (type === 'sqlite') {
             finalUrl = database;
         } else {
             if (!host || !database) {
-                throw new Error('数据库配置不完整，请检查环境变量');
+                throw new Error('数据库配置不完整，请检查配置参数');
             }
             finalUrl = `${type}://${user}:${password}@${host}:${port}/${database}`;
         }
 
         let sql: SQL;
 
-        if (Env.DB_TYPE === 'sqlite') {
+        if (type === 'sqlite') {
             sql = new SQL(finalUrl);
         } else {
             sql = new SQL({
                 url: finalUrl,
-                max: options.max ?? 1,
-                bigint: false,
-                ...options
+                max: config.poolMax ?? 1,
+                bigint: false
             });
         }
 
         try {
-            const timeout = options.connectionTimeout ?? 30000;
+            const timeout = 30000;
 
             const healthCheckPromise = (async () => {
                 let version = '';
-                if (Env.DB_TYPE === 'sqlite') {
+                if (type === 'sqlite') {
                     const v = await sql`SELECT sqlite_version() AS version`;
                     version = v?.[0]?.version;
-                } else if (Env.DB_TYPE === 'postgresql' || Env.DB_TYPE === 'postgres') {
+                } else if (type === 'postgresql' || type === 'postgres') {
                     const v = await sql`SELECT version() AS version`;
                     version = v?.[0]?.version;
                 } else {
@@ -157,21 +155,26 @@ export class Database {
 
     /**
      * 连接 Redis
+     * @param config - Redis 配置
      * @returns Redis 客户端实例
      */
-    static async connectRedis(): Promise<RedisClient> {
+    static async connectRedis(config: RedisConfig = {}): Promise<RedisClient> {
         try {
             // 构建 Redis URL
-            const { REDIS_HOST, REDIS_PORT, REDIS_USERNAME, REDIS_PASSWORD, REDIS_DB } = Env;
+            const host = config.host || '127.0.0.1';
+            const port = config.port || 6379;
+            const username = config.username || '';
+            const password = config.password || '';
+            const db = config.db || 0;
 
             let auth = '';
-            if (REDIS_USERNAME && REDIS_PASSWORD) {
-                auth = `${REDIS_USERNAME}:${REDIS_PASSWORD}@`;
-            } else if (REDIS_PASSWORD) {
-                auth = `:${REDIS_PASSWORD}@`;
+            if (username && password) {
+                auth = `${username}:${password}@`;
+            } else if (password) {
+                auth = `:${password}@`;
             }
 
-            const url = `redis://${auth}${REDIS_HOST}:${REDIS_PORT}/${REDIS_DB}`;
+            const url = `redis://${auth}${host}:${port}/${db}`;
 
             const redis = new RedisClient(url, {
                 connectionTimeout: 30000,

package/lib/dbHelper.ts

@@ -5,7 +5,7 @@
 
 import { snakeCase } from 'es-toolkit/string';
 import { SqlBuilder } from './sqlBuilder.js';
-import { keysToCamel, arrayKeysToCamel, keysToSnake, fieldClear } from '../util.js';
+import { keysToCamel, arrayKeysToCamel, keysToSnake, fieldClear } from 'befly-util';
 import { Logger } from '../lib/logger.js';
 import type { WhereConditions } from '../types/common.js';
 import type { BeflyContext } from '../types/befly.js';
@@ -204,8 +204,8 @@ export class DbHelper {
     /**
      * 清理数据或 where 条件（默认排除 null 和 undefined）
      */
-    private cleanFields<T extends Record<string, any>>(data: T | undefined | null, excludeValues: any[] = [null, undefined], keepValues: Record<string, any> = {}): Partial<T> {
-        return fieldClear(data || ({} as T), excludeValues, keepValues);
+    public cleanFields<T extends Record<string, any>>(data: T, excludeValues: any[] = [null, undefined], keepValues: Record<string, any> = {}): Partial<T> {
+        return fieldClear(data || ({} as T), { excludeValues, keepMap: keepValues });
     }
 
     /**

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');
-    }
 }