befly 3.16.9 → 3.16.11

package/dist/lib/cipher.js

@@ -1,237 +0,0 @@
-/**
- * 加密工具类 - TypeScript 版本
- * 提供各种哈希、HMAC、密码加密等功能
- */
-import { createSign } from "node:crypto";
-/**
- * 加密工具类
- */
-export class Cipher {
-    /**
-     * MD5 哈希
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns MD5 哈希值
-     */
-    static md5(data, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher("md5");
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * HMAC-MD5 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-MD5 签名
-     */
-    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, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher("sha1");
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * HMAC-SHA1 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA1 签名
-     */
-    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, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher("sha256");
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * RSA-SHA256 签名
-     * @param data - 要签名的数据
-     * @param privateKey - 私钥
-     * @param encoding - 输出编码（'hex' | 'base64' | 'base64url'）
-     * @returns RSA-SHA256 签名
-     */
-    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 - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA256 签名
-     */
-    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, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher("sha512");
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * HMAC-SHA512 签名
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC-SHA512 签名
-     */
-    static hmacSha512(key, data, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher("sha512", key);
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * 通用哈希方法
-     * @param algorithm - 算法名称
-     * @param data - 要哈希的数据
-     * @param encoding - 输出编码
-     * @returns 哈希值
-     */
-    static hash(algorithm, data, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher(algorithm);
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * 通用 HMAC 方法
-     * @param algorithm - 算法名称
-     * @param key - 密钥
-     * @param data - 要签名的数据
-     * @param encoding - 输出编码
-     * @returns HMAC 签名
-     */
-    static hmac(algorithm, key, data, encoding = "hex") {
-        const hasher = new Bun.CryptoHasher(algorithm, key);
-        hasher.update(data);
-        return hasher.digest(encoding);
-    }
-    /**
-     * 文件哈希
-     * @param filePath - 文件路径
-     * @param algorithm - 算法名称
-     * @param encoding - 输出编码
-     * @returns 文件哈希值
-     */
-    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;
-                hasher.update(value);
-            }
-            return hasher.digest(encoding);
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    /**
-     * 密码哈希（使用 bcrypt 算法）
-     * @param password - 密码
-     * @param options - 选项（可选，支持自定义 cost 参数）
-     * @returns 哈希后的密码（固定 60 字符）
-     * @example
-     * // 默认配置（推荐）
-     * const hash = await Cipher.hashPassword('123456');
-     *
-     * // 自定义强度（可选）
-     * const hash = await Cipher.hashPassword('123456', { cost: 12 });
-     */
-    static async hashPassword(password, options = {}) {
-        // Bun 的类型定义要求 bcrypt 的 algorithm 必须是字面量 "bcrypt"。
-        // 这里强制锁定 bcrypt，且不允许 options.algorithm 覆盖。
-        const finalOptions = Object.assign({}, options, { algorithm: "bcrypt" });
-        return await Bun.password.hash(password, finalOptions);
-    }
-    /**
-     * 验证密码
-     * @param password - 原始密码
-     * @param hash - 存储的哈希值（自动识别算法和提取盐值）
-     * @returns 验证结果
-     * @example
-     * const isValid = await Cipher.verifyPassword('123456', storedHash);
-     * if (isValid) {
-     *   // 密码正确
-     * }
-     */
-    static async verifyPassword(password, hash) {
-        return await Bun.password.verify(password, hash);
-    }
-    /**
-     * Base64 编码
-     * @param data - 要编码的数据
-     * @returns Base64 编码的字符串
-     */
-    static base64Encode(data) {
-        return Buffer.from(data, "utf8").toString("base64");
-    }
-    /**
-     * Base64 解码
-     * @param data - Base64 编码的字符串
-     * @returns 解码后的字符串
-     */
-    static base64Decode(data) {
-        return Buffer.from(data, "base64").toString("utf8");
-    }
-    /**
-     * 生成随机十六进制字符串
-     * @param length - 字符串长度
-     * @returns 随机十六进制字符串
-     */
-    static randomString(length) {
-        const bytes = Math.ceil(length / 2);
-        const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
-        let result = "";
-        for (let i = 0; i < randomBytes.length; i++) {
-            result += randomBytes[i].toString(16).padStart(2, "0");
-        }
-        return result.slice(0, length);
-    }
-    /**
-     * 快速哈希 (非密码学)
-     * @param data - 数据
-     * @param seed - 种子值
-     * @returns 64位哈希值
-     */
-    static fastHash(data, seed = 0) {
-        const result = Bun.hash(data, seed);
-        return typeof result === "bigint" ? Number(result) : result;
-    }
-}

package/dist/lib/connect.d.ts

@@ -1,95 +0,0 @@
-/**
- * 数据库连接管理器
- * 统一管理 SQL 和 Redis 连接
- */
-import type { DatabaseConfig, RedisConfig } from "../types/befly";
-import { SQL, RedisClient } from "bun";
-/**
- * 数据库连接管理器
- * 使用静态方法管理全局单例连接
- */
-export declare class Connect {
-    private static sqlClient;
-    private static redisClient;
-    private static sqlConnectedAt;
-    private static redisConnectedAt;
-    private static sqlPoolMax;
-    private static mysqlVersionText;
-    private static mysqlVersionMajor;
-    /**
-     * 连接 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;
-            mysqlVersionText: string | null;
-            mysqlVersionMajor: number | null;
-        };
-        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/dist/lib/connect.js

@@ -1,313 +0,0 @@
-/**
- * 数据库连接管理器
- * 统一管理 SQL 和 Redis 连接
- */
-import { SQL, RedisClient } from "bun";
-import { CoreError } from "../types/coreError";
-import { isCoreError } from "../types/coreError";
-import { Logger } from "./logger";
-/**
- * 数据库连接管理器
- * 使用静态方法管理全局单例连接
- */
-export class Connect {
-    static sqlClient = null;
-    static redisClient = null;
-    // 连接统计信息
-    static sqlConnectedAt = null;
-    static redisConnectedAt = null;
-    static sqlPoolMax = 1;
-    // MySQL 版本信息（用于启动期校验与监控）
-    static mysqlVersionText = null;
-    static mysqlVersionMajor = null;
-    // ========================================
-    // SQL 连接管理
-    // ========================================
-    /**
-     * 连接 SQL 数据库
-     * @returns SQL 客户端实例
-     */
-    static async connectSql(dbConfig) {
-        const config = dbConfig || {};
-        // 构建 MySQL 连接字符串（不做隐式默认；缺失直接报错，避免连错库/错密码）
-        const host = typeof config.host === "string" ? config.host.trim() : "";
-        const port = typeof config.port === "number" ? config.port : NaN;
-        const username = typeof config.username === "string" ? config.username.trim() : "";
-        const password = config.password === undefined ? "" : typeof config.password === "string" ? config.password : "";
-        const database = typeof config.database === "string" ? config.database.trim() : "";
-        if (!host) {
-            throw new CoreError({ message: "数据库配置不完整：db.host 缺失", kind: "validation" });
-        }
-        if (!Number.isFinite(port) || port < 1 || port > 65535) {
-            throw new CoreError({ message: `数据库配置不完整：db.port 非法（当前值：${String(config.port)}）`, kind: "validation" });
-        }
-        if (!username) {
-            throw new CoreError({ message: "数据库配置不完整：db.username 缺失", kind: "validation" });
-        }
-        if (!database) {
-            throw new CoreError({ message: "数据库配置不完整：db.database 缺失", kind: "validation" });
-        }
-        const user = encodeURIComponent(username);
-        const pass = encodeURIComponent(password);
-        const db = encodeURIComponent(database);
-        const finalUrl = `mysql://${user}:${pass}@${host}:${port}/${db}`;
-        const sql = new SQL({
-            url: finalUrl,
-            max: config.poolMax ?? 1,
-            bigint: false
-        });
-        try {
-            const timeout = 30000;
-            const healthCheckPromise = (async () => {
-                const v = await sql `SELECT VERSION() AS version`;
-                const versionText = typeof v?.[0]?.version === "string" ? v?.[0]?.version : String(v?.[0]?.version || "");
-                // 常见格式：8.0.36 / 8.0.36-xxx
-                const majorText = versionText.split(".")[0];
-                const major = Number(majorText);
-                if (!Number.isFinite(major)) {
-                    throw new CoreError({ message: `无法解析 MySQL 版本信息: ${versionText}`, kind: "runtime", meta: { subsystem: "sql", operation: "version" } });
-                }
-                if (major < 8) {
-                    throw new CoreError({ message: `仅支持 MySQL 8.0+，当前版本：${versionText}`, kind: "policy", meta: { subsystem: "sql", operation: "version" } });
-                }
-                this.mysqlVersionText = versionText;
-                this.mysqlVersionMajor = major;
-                return versionText;
-            })();
-            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) {
-            Logger.error({ err: error, msg: "[Connect] SQL 连接失败" });
-            try {
-                await sql?.close();
-            }
-            catch { }
-            if (isCoreError(error)) {
-                error.logged = true;
-                throw error;
-            }
-            const msg = `SQL 连接失败: ${error && typeof error.message === "string" ? error.message : String(error)}`;
-            throw new CoreError({
-                message: msg,
-                kind: "runtime",
-                logged: true,
-                cause: error,
-                meta: {
-                    subsystem: "sql",
-                    operation: "connect"
-                }
-            });
-        }
-    }
-    /**
-     * 断开 SQL 连接
-     */
-    static async disconnectSql() {
-        if (this.sqlClient) {
-            try {
-                await this.sqlClient.close();
-            }
-            catch (error) {
-                Logger.error({ err: error, msg: "[Connect] 关闭 SQL 连接时出错" });
-            }
-            this.sqlClient = null;
-            this.sqlConnectedAt = null;
-        }
-    }
-    /**
-     * 获取 SQL 客户端实例
-     * @throws 如果未连接则抛出错误
-     */
-    static getSql() {
-        if (!this.sqlClient) {
-            throw new Error("SQL 客户端未连接，请先调用 Connect.connectSql()");
-        }
-        return this.sqlClient;
-    }
-    // ========================================
-    // Redis 连接管理
-    // ========================================
-    /**
-     * 连接 Redis
-     * @returns Redis 客户端实例
-     */
-    static async connectRedis(redisConfig) {
-        const config = redisConfig || {};
-        try {
-            // 构建 Redis URL
-            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 = "";
-            const encodedUsername = username ? encodeURIComponent(username) : "";
-            const encodedPassword = password ? encodeURIComponent(password) : "";
-            if (encodedUsername && encodedPassword) {
-                auth = `${encodedUsername}:${encodedPassword}@`;
-            }
-            else if (encodedPassword) {
-                auth = `:${encodedPassword}@`;
-            }
-            const url = `redis://${auth}${host}:${port}/${db}`;
-            const redis = new RedisClient(url, {
-                connectionTimeout: 30000,
-                idleTimeout: 0,
-                autoReconnect: true,
-                maxRetries: 3,
-                enableOfflineQueue: true,
-                enableAutoPipelining: true
-            });
-            await redis.ping();
-            this.redisClient = redis;
-            this.redisConnectedAt = Date.now();
-            return redis;
-        }
-        catch (error) {
-            Logger.error({ err: error, msg: "[Connect] Redis 连接失败" });
-            const msg = `Redis 连接失败: ${error && typeof error.message === "string" ? error.message : String(error)}`;
-            throw new CoreError({
-                message: msg,
-                kind: "runtime",
-                logged: true,
-                cause: error,
-                meta: {
-                    subsystem: "redis",
-                    operation: "connect"
-                }
-            });
-        }
-    }
-    /**
-     * 断开 Redis 连接
-     */
-    static async disconnectRedis() {
-        if (this.redisClient) {
-            try {
-                this.redisClient.close();
-                this.redisConnectedAt = null;
-            }
-            catch (error) {
-                Logger.error({ err: error, msg: "[Connect] 关闭 Redis 连接时出错" });
-            }
-            this.redisClient = null;
-        }
-    }
-    /**
-     * 获取 Redis 客户端实例
-     * @throws 如果未连接则抛出错误
-     */
-    static getRedis() {
-        if (!this.redisClient) {
-            throw new Error("Redis 客户端未连接，请先调用 Connect.connectRedis()");
-        }
-        return this.redisClient;
-    }
-    // ========================================
-    // 统一连接管理
-    // ========================================
-    /**
-     * 连接所有数据库（SQL + Redis）
-     */
-    static async connect(config) {
-        try {
-            // 连接 SQL
-            await this.connectSql(config.db || {});
-            // 连接 Redis
-            await this.connectRedis(config.redis || {});
-        }
-        catch (error) {
-            const env = typeof process?.env?.NODE_ENV === "string" ? process.env.NODE_ENV : "";
-            Logger.error({ env: env, err: error, msg: "数据库连接初始化失败" });
-            await this.disconnect();
-            if (isCoreError(error)) {
-                error.logged = true;
-                throw error;
-            }
-            const msg = `数据库连接初始化失败: ${error && typeof error.message === "string" ? error.message : String(error)}`;
-            throw new CoreError({
-                message: msg,
-                kind: "runtime",
-                logged: true,
-                cause: error,
-                meta: {
-                    subsystem: "connect",
-                    operation: "connect"
-                }
-            });
-        }
-    }
-    /**
-     * 断开所有数据库连接
-     */
-    static async disconnect() {
-        await this.disconnectSql();
-        await this.disconnectRedis();
-    }
-    /**
-     * 检查连接状态
-     */
-    static isConnected() {
-        return {
-            sql: this.sqlClient !== null,
-            redis: this.redisClient !== null
-        };
-    }
-    /**
-     * 获取连接状态详细信息（用于监控和调试）
-     */
-    static getStatus() {
-        const now = Date.now();
-        return {
-            sql: {
-                connected: this.sqlClient !== null,
-                connectedAt: this.sqlConnectedAt,
-                uptime: this.sqlConnectedAt ? now - this.sqlConnectedAt : null,
-                poolMax: this.sqlPoolMax,
-                mysqlVersionText: this.mysqlVersionText,
-                mysqlVersionMajor: this.mysqlVersionMajor
-            },
-            redis: {
-                connected: this.redisClient !== null,
-                connectedAt: this.redisConnectedAt,
-                uptime: this.redisConnectedAt ? now - this.redisConnectedAt : null
-            }
-        };
-    }
-    // ========================================
-    // 测试辅助方法
-    // ========================================
-    /**
-     * 设置 mock SQL 客户端（仅用于测试）
-     */
-    static __setMockSql(mockClient) {
-        this.sqlClient = mockClient;
-    }
-    /**
-     * 设置 mock Redis 客户端（仅用于测试）
-     */
-    static __setMockRedis(mockClient) {
-        this.redisClient = mockClient;
-    }
-    /**
-     * 重置所有连接状态（仅用于测试）
-     */
-    static __reset() {
-        this.sqlClient = null;
-        this.redisClient = null;
-        this.sqlConnectedAt = null;
-        this.redisConnectedAt = null;
-        this.sqlPoolMax = 1;
-        this.mysqlVersionText = null;
-        this.mysqlVersionMajor = null;
-    }
-}