befly 3.10.17 → 3.10.19

package/{lib/cipher.ts → dist/lib/cipher.js}

@@ -2,11 +2,7 @@
  * 加密工具类 - TypeScript 版本
  * 提供各种哈希、HMAC、密码加密等功能
  */
-
-import type { EncodingType, HashAlgorithm, PasswordHashOptions } from "../types/crypto.js";
-
 import { createSign } from "node:crypto";
-
 /**
  * 加密工具类
  */
@@ -17,12 +13,11 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns MD5 哈希值
      */
-    static md5(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static md5(data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("md5");
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * HMAC-MD5 签名
      * @param key - 密钥
@@ -30,24 +25,22 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-MD5 签名
      */
-    static hmacMd5(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hmacMd5(key, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("md5", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * SHA-1 哈希
      * @param data - 要哈希的数据
      * @param encoding - 输出编码
      * @returns SHA-1 哈希值
      */
-    static sha1(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static sha1(data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha1");
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * HMAC-SHA1 签名
      * @param key - 密钥
@@ -55,24 +48,22 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA1 签名
      */
-    static hmacSha1(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hmacSha1(key, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha1", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * SHA-256 哈希
      * @param data - 要哈希的数据
      * @param encoding - 输出编码
      * @returns SHA-256 哈希值
      */
-    static sha256(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static sha256(data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha256");
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * RSA-SHA256 签名
      * @param data - 要签名的数据
@@ -80,13 +71,12 @@ export class Cipher {
      * @param encoding - 输出编码（'hex' | 'base64' | 'base64url'）
      * @returns RSA-SHA256 签名
      */
-    static rsaSha256(data: string, privateKey: string | Buffer, encoding: "hex" | "base64" | "base64url" = "hex"): string {
+    static rsaSha256(data, privateKey, encoding = "hex") {
         const sign = createSign("RSA-SHA256");
         sign.update(data);
         const signature = sign.sign(privateKey, encoding);
         return signature;
     }
-
     /**
      * HMAC-SHA256 签名
      * @param key - 密钥
@@ -94,24 +84,22 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA256 签名
      */
-    static hmacSha256(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hmacSha256(key, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha256", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * SHA-512 哈希
      * @param data - 要哈希的数据
      * @param encoding - 输出编码
      * @returns SHA-512 哈希值
      */
-    static sha512(data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static sha512(data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha512");
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * HMAC-SHA512 签名
      * @param key - 密钥
@@ -119,12 +107,11 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC-SHA512 签名
      */
-    static hmacSha512(key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hmacSha512(key, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher("sha512", key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * 通用哈希方法
      * @param algorithm - 算法名称
@@ -132,12 +119,11 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns 哈希值
      */
-    static hash(algorithm: HashAlgorithm, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hash(algorithm, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher(algorithm);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * 通用 HMAC 方法
      * @param algorithm - 算法名称
@@ -146,12 +132,11 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns HMAC 签名
      */
-    static hmac(algorithm: HashAlgorithm, key: string | Uint8Array, data: string | Uint8Array, encoding: EncodingType = "hex"): string {
+    static hmac(algorithm, key, data, encoding = "hex") {
         const hasher = new Bun.CryptoHasher(algorithm, key);
         hasher.update(data);
         return hasher.digest(encoding);
     }
-
     /**
      * 文件哈希
      * @param filePath - 文件路径
@@ -159,25 +144,24 @@ export class Cipher {
      * @param encoding - 输出编码
      * @returns 文件哈希值
      */
-    static async hashFile(filePath: string, algorithm: HashAlgorithm = "sha256", encoding: EncodingType = "hex"): Promise<string> {
+    static async hashFile(filePath, algorithm = "sha256", encoding = "hex") {
         const file = Bun.file(filePath);
         const hasher = new Bun.CryptoHasher(algorithm);
-
         const stream = file.stream();
         const reader = stream.getReader();
-
         try {
             while (true) {
                 const { done, value } = await reader.read();
-                if (done) break;
+                if (done)
+                    break;
                 hasher.update(value);
             }
             return hasher.digest(encoding);
-        } finally {
+        }
+        finally {
             reader.releaseLock();
         }
     }
-
     /**
      * 密码哈希（使用 bcrypt 算法）
      * @param password - 密码
@@ -190,14 +174,13 @@ export class Cipher {
      * // 自定义强度（可选）
      * const hash = await Cipher.hashPassword('123456', { cost: 12 });
      */
-    static async hashPassword(password: string, options: PasswordHashOptions = {}): Promise<string> {
+    static async hashPassword(password, options = {}) {
         const finalOptions = {
             algorithm: "bcrypt",
             ...options
-        } as any;
+        };
         return await Bun.password.hash(password, finalOptions);
     }
-
     /**
      * 验证密码
      * @param password - 原始密码
@@ -209,34 +192,31 @@ export class Cipher {
      *   // 密码正确
      * }
      */
-    static async verifyPassword(password: string, hash: string): Promise<boolean> {
+    static async verifyPassword(password, hash) {
         return await Bun.password.verify(password, hash);
     }
-
     /**
      * Base64 编码
      * @param data - 要编码的数据
      * @returns Base64 编码的字符串
      */
-    static base64Encode(data: string): string {
+    static base64Encode(data) {
         return Buffer.from(data, "utf8").toString("base64");
     }
-
     /**
      * Base64 解码
      * @param data - Base64 编码的字符串
      * @returns 解码后的字符串
      */
-    static base64Decode(data: string): string {
+    static base64Decode(data) {
         return Buffer.from(data, "base64").toString("utf8");
     }
-
     /**
      * 生成随机十六进制字符串
      * @param length - 字符串长度
      * @returns 随机十六进制字符串
      */
-    static randomString(length: number): string {
+    static randomString(length) {
         const bytes = Math.ceil(length / 2);
         const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
         let result = "";
@@ -245,14 +225,13 @@ export class Cipher {
         }
         return result.slice(0, length);
     }
-
     /**
      * 快速哈希 (非密码学)
      * @param data - 数据
      * @param seed - 种子值
      * @returns 64位哈希值
      */
-    static fastHash(data: string | Uint8Array, seed: number = 0): number {
+    static fastHash(data, seed = 0) {
         const result = Bun.hash(data, seed);
         return typeof result === "bigint" ? Number(result) : result;
     }

package/dist/lib/connect.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 数据库连接管理器
+ * 统一管理 SQL 和 Redis 连接
+ */
+import type { DatabaseConfig, RedisConfig } from "../types/befly.ts";
+import { SQL, RedisClient } from "bun";
+/**
+ * 数据库连接管理器
+ * 使用静态方法管理全局单例连接
+ */
+export declare class Connect {
+    private static sqlClient;
+    private static redisClient;
+    private static sqlConnectedAt;
+    private static redisConnectedAt;
+    private static sqlPoolMax;
+    /**
+     * 连接 SQL 数据库
+     * @returns SQL 客户端实例
+     */
+    static connectSql(dbConfig: DatabaseConfig): Promise<SQL>;
+    /**
+     * 断开 SQL 连接
+     */
+    static disconnectSql(): Promise<void>;
+    /**
+     * 获取 SQL 客户端实例
+     * @throws 如果未连接则抛出错误
+     */
+    static getSql(): SQL;
+    /**
+     * 连接 Redis
+     * @returns Redis 客户端实例
+     */
+    static connectRedis(redisConfig: RedisConfig): Promise<RedisClient>;
+    /**
+     * 断开 Redis 连接
+     */
+    static disconnectRedis(): Promise<void>;
+    /**
+     * 获取 Redis 客户端实例
+     * @throws 如果未连接则抛出错误
+     */
+    static getRedis(): RedisClient;
+    /**
+     * 连接所有数据库（SQL + Redis）
+     */
+    static connect(config: {
+        db: DatabaseConfig;
+        redis: RedisConfig;
+    }): Promise<void>;
+    /**
+     * 断开所有数据库连接
+     */
+    static disconnect(): Promise<void>;
+    /**
+     * 检查连接状态
+     */
+    static isConnected(): {
+        sql: boolean;
+        redis: boolean;
+    };
+    /**
+     * 获取连接状态详细信息（用于监控和调试）
+     */
+    static getStatus(): {
+        sql: {
+            connected: boolean;
+            connectedAt: number | null;
+            uptime: number | null;
+            poolMax: number;
+        };
+        redis: {
+            connected: boolean;
+            connectedAt: number | null;
+            uptime: number | null;
+        };
+    };
+    /**
+     * 设置 mock SQL 客户端（仅用于测试）
+     */
+    static __setMockSql(mockClient: SQL): void;
+    /**
+     * 设置 mock Redis 客户端（仅用于测试）
+     */
+    static __setMockRedis(mockClient: RedisClient): void;
+    /**
+     * 重置所有连接状态（仅用于测试）
+     */
+    static __reset(): void;
+}

package/{lib/connect.ts → dist/lib/connect.js}

@@ -2,37 +2,28 @@
  * 数据库连接管理器
  * 统一管理 SQL 和 Redis 连接
  */
-
-import type { DatabaseConfig, RedisConfig } from "../types/befly.js";
-
 import { SQL, RedisClient } from "bun";
-
 import { Logger } from "./logger.js";
-
 /**
  * 数据库连接管理器
  * 使用静态方法管理全局单例连接
  */
 export class Connect {
-    private static sqlClient: SQL | null = null;
-    private static redisClient: RedisClient | null = null;
-
+    static sqlClient = null;
+    static redisClient = null;
     // 连接统计信息
-    private static sqlConnectedAt: number | null = null;
-    private static redisConnectedAt: number | null = null;
-    private static sqlPoolMax: number = 1;
-
+    static sqlConnectedAt = null;
+    static redisConnectedAt = null;
+    static sqlPoolMax = 1;
     // ========================================
     // SQL 连接管理
     // ========================================
-
     /**
      * 连接 SQL 数据库
      * @returns SQL 客户端实例
      */
-    static async connectSql(dbConfig: DatabaseConfig): Promise<SQL> {
+    static async connectSql(dbConfig) {
         const config = dbConfig || {};
-
         // 构建数据库连接字符串
         const type = config.type || "mysql";
         const host = config.host || "127.0.0.1";
@@ -40,106 +31,99 @@ export class Connect {
         const user = encodeURIComponent(config.username || "root");
         const password = encodeURIComponent(config.password || "root");
         const database = encodeURIComponent(config.database || "befly_demo");
-
-        let finalUrl: string;
+        let finalUrl;
         if (type === "sqlite") {
             finalUrl = database;
-        } else {
+        }
+        else {
             if (!host || !database) {
                 throw new Error("数据库配置不完整，请检查配置参数");
             }
             finalUrl = `${type}://${user}:${password}@${host}:${port}/${database}`;
         }
-
-        let sql: SQL;
-
+        let sql;
         if (type === "sqlite") {
             sql = new SQL(finalUrl);
-        } else {
+        }
+        else {
             sql = new SQL({
                 url: finalUrl,
                 max: config.poolMax ?? 1,
                 bigint: false
             });
         }
-
         try {
             const timeout = 30000;
-
             const healthCheckPromise = (async () => {
                 let version = "";
                 if (type === "sqlite") {
-                    const v = await sql`SELECT sqlite_version() AS version`;
+                    const v = await sql `SELECT sqlite_version() AS version`;
                     version = v?.[0]?.version;
-                } else if (type === "postgresql" || type === "postgres") {
-                    const v = await sql`SELECT version() AS version`;
+                }
+                else if (type === "postgresql" || type === "postgres") {
+                    const v = await sql `SELECT version() AS version`;
                     version = v?.[0]?.version;
-                } else {
-                    const v = await sql`SELECT VERSION() AS version`;
+                }
+                else {
+                    const v = await sql `SELECT VERSION() AS version`;
                     version = v?.[0]?.version;
                 }
                 return version;
             })();
-
-            const timeoutPromise = new Promise<never>((_, reject) => {
+            const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(() => {
                     reject(new Error(`数据库连接超时 (${timeout}ms)`));
                 }, timeout);
             });
-
             await Promise.race([healthCheckPromise, timeoutPromise]);
-
             this.sqlClient = sql;
             this.sqlConnectedAt = Date.now();
             this.sqlPoolMax = config.poolMax ?? 1;
             return sql;
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "[Connect] SQL 连接失败");
             try {
                 await sql?.close();
-            } catch {}
-
+            }
+            catch { }
             throw error;
         }
     }
-
     /**
      * 断开 SQL 连接
      */
-    static async disconnectSql(): Promise<void> {
+    static async disconnectSql() {
         if (this.sqlClient) {
             try {
                 await this.sqlClient.close();
-            } catch (error: any) {
+            }
+            catch (error) {
                 Logger.error({ err: error }, "[Connect] 关闭 SQL 连接时出错");
             }
             this.sqlClient = null;
             this.sqlConnectedAt = null;
         }
     }
-
     /**
      * 获取 SQL 客户端实例
      * @throws 如果未连接则抛出错误
      */
-    static getSql(): SQL {
+    static getSql() {
         if (!this.sqlClient) {
             throw new Error("SQL 客户端未连接，请先调用 Connect.connectSql()");
         }
         return this.sqlClient;
     }
-
     // ========================================
     // Redis 连接管理
     // ========================================
-
     /**
      * 连接 Redis
      * @returns Redis 客户端实例
      */
-    static async connectRedis(redisConfig: RedisConfig): Promise<RedisClient> {
+    static async connectRedis(redisConfig) {
         const config = redisConfig || {};
-
         try {
             // 构建 Redis URL
             const host = config.host || "127.0.0.1";
@@ -147,16 +131,14 @@ export class Connect {
             const username = config.username || "";
             const password = config.password || "";
             const db = config.db || 0;
-
             let auth = "";
             if (username && password) {
                 auth = `${username}:${password}@`;
-            } else if (password) {
+            }
+            else if (password) {
                 auth = `:${password}@`;
             }
-
             const url = `redis://${auth}${host}:${port}/${db}`;
-
             const redis = new RedisClient(url, {
                 connectionTimeout: 30000,
                 idleTimeout: 0,
@@ -165,99 +147,80 @@ export class Connect {
                 enableOfflineQueue: true,
                 enableAutoPipelining: true
             });
-
             await redis.ping();
-
             this.redisClient = redis;
             this.redisConnectedAt = Date.now();
             return redis;
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "[Connect] Redis 连接失败");
             throw new Error(`Redis 连接失败: ${error.message}`);
         }
     }
-
     /**
      * 断开 Redis 连接
      */
-    static async disconnectRedis(): Promise<void> {
+    static async disconnectRedis() {
         if (this.redisClient) {
             try {
                 this.redisClient.close();
                 this.redisConnectedAt = null;
-            } catch (error: any) {
+            }
+            catch (error) {
                 Logger.error({ err: error }, "[Connect] 关闭 Redis 连接时出错");
             }
             this.redisClient = null;
         }
     }
-
     /**
      * 获取 Redis 客户端实例
      * @throws 如果未连接则抛出错误
      */
-    static getRedis(): RedisClient {
+    static getRedis() {
         if (!this.redisClient) {
             throw new Error("Redis 客户端未连接，请先调用 Connect.connectRedis()");
         }
         return this.redisClient;
     }
-
     // ========================================
     // 统一连接管理
     // ========================================
-
     /**
      * 连接所有数据库（SQL + Redis）
      */
-    static async connect(config: { db: DatabaseConfig; redis: RedisConfig }): Promise<void> {
+    static async connect(config) {
         try {
             // 连接 SQL
             await this.connectSql(config.db || {});
-
             // 连接 Redis
             await this.connectRedis(config.redis || {});
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "数据库初始化失败");
             await this.disconnect();
             throw error;
         }
     }
-
     /**
      * 断开所有数据库连接
      */
-    static async disconnect(): Promise<void> {
+    static async disconnect() {
         await this.disconnectSql();
         await this.disconnectRedis();
     }
-
     /**
      * 检查连接状态
      */
-    static isConnected(): { sql: boolean; redis: boolean } {
+    static isConnected() {
         return {
             sql: this.sqlClient !== null,
             redis: this.redisClient !== null
         };
     }
-
     /**
      * 获取连接状态详细信息（用于监控和调试）
      */
-    static getStatus(): {
-        sql: {
-            connected: boolean;
-            connectedAt: number | null;
-            uptime: number | null;
-            poolMax: number;
-        };
-        redis: {
-            connected: boolean;
-            connectedAt: number | null;
-            uptime: number | null;
-        };
-    } {
+    static getStatus() {
         const now = Date.now();
         return {
             sql: {
@@ -273,29 +236,25 @@ export class Connect {
             }
         };
     }
-
     // ========================================
     // 测试辅助方法
     // ========================================
-
     /**
      * 设置 mock SQL 客户端（仅用于测试）
      */
-    static __setMockSql(mockClient: SQL): void {
+    static __setMockSql(mockClient) {
         this.sqlClient = mockClient;
     }
-
     /**
      * 设置 mock Redis 客户端（仅用于测试）
      */
-    static __setMockRedis(mockClient: RedisClient): void {
+    static __setMockRedis(mockClient) {
         this.redisClient = mockClient;
     }
-
     /**
      * 重置所有连接状态（仅用于测试）
      */
-    static __reset(): void {
+    static __reset() {
         this.sqlClient = null;
         this.redisClient = null;
         this.sqlConnectedAt = null;