befly 3.4.12 → 3.4.14

package/lib/database.ts

@@ -92,6 +92,7 @@ export class Database {
             this.sqlClient = sql;
             return sql;
         } catch (error: any) {
+            console.log(finalUrl);
             Logger.error('数据库连接测试失败', error);
 
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.4.12",
+    "version": "3.4.14",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -81,5 +81,5 @@
         "ora": "^9.0.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "7d2c21a0b69867c650cbec930e041821a1914ffb"
+    "gitHead": "8ced9f183b280460e8136eb00985c0fb83e63bc1"
 }

package/lifecycle/cluster-worker.ts

@@ -1,49 +0,0 @@
-/**
- * Cluster Worker 入口
- * 由 ClusterManager 启动的子进程入口文件
- */
-
-import { Befly } from '../main.js';
-import { Logger } from '../lib/logger.js';
-
-// 启动 Befly 实例
-const app = new Befly();
-const server = await app.listen();
-
-// Bun 原生信号处理：当收到 SIGTERM/SIGINT 时优雅关闭
-const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
-
-signals.forEach((signal) => {
-    process.on(signal, async () => {
-        const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-        Logger.info(`Worker ${workerId} 收到 ${signal} 信号，正在关闭...`);
-
-        try {
-            // Bun Server 的 stop() 方法：关闭服务器
-            // 参数 true 表示强制关闭（不等待现有连接）
-            server.stop(true);
-            Logger.info(`Worker ${workerId} HTTP 服务器已关闭`);
-
-            // 给予短暂时间让资源清理完成
-            await Bun.sleep(100);
-
-            process.exit(0);
-        } catch (error) {
-            Logger.error(`Worker ${workerId} 关闭失败:`, error);
-            process.exit(1);
-        }
-    });
-});
-
-// 处理未捕获的异常，防止进程意外退出
-process.on('uncaughtException', (error) => {
-    const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-    Logger.error(`Worker ${workerId} 发生未捕获异常:`, error);
-    // 不退出进程，让 ClusterManager 决定是否重启
-});
-
-process.on('unhandledRejection', (reason) => {
-    const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-    Logger.error(`Worker ${workerId} 发生未处理的 Promise 拒绝:`, reason);
-    // 不退出进程，让 ClusterManager 决定是否重启
-});

package/lifecycle/cluster.ts

@@ -1,254 +0,0 @@
-/**
- * Cluster Manager - 集群管理器
- * 负责多进程启动、自动重启、优雅关闭
- */
-
-import { join } from 'pathe';
-import type { Subprocess } from 'bun';
-import { Logger } from '../lib/logger.js';
-import { Befly } from '../main.js';
-
-export interface ClusterOptions {
-    /** 实例数量（数字或 'max'） */
-    instances: number | 'max';
-    /** 起始端口 */
-    startPort: number;
-    /** 主机地址 */
-    host: string;
-    /** 项目根目录 */
-    projectRoot: string;
-    /** 环境变量 */
-    env?: Record<string, string>;
-}
-
-interface WorkerInfo {
-    id: number;
-    port: number;
-    process: Subprocess;
-    restartCount: number;
-    lastRestartTime: number;
-}
-
-export class ClusterManager {
-    private workers: Map<number, WorkerInfo> = new Map();
-    private isShuttingDown = false;
-    private readonly MAX_RESTARTS = 10; // 最大重启次数
-    private readonly RESTART_DELAY = 1000; // 重启延迟（毫秒）
-    private readonly RESTART_WINDOW = 60000; // 重启计数窗口（1分钟）
-
-    constructor(private options: ClusterOptions) {}
-
-    /**
-     * 启动集群
-     */
-    async start(): Promise<void> {
-        const instances = this.getInstanceCount();
-        const { startPort, host } = this.options;
-
-        Logger.info(`启动集群模式: ${instances} 个实例\n`);
-        Logger.info(`端口范围: ${startPort} - ${startPort + instances - 1}`);
-        Logger.info(`主机地址: ${host}`);
-        Logger.info(`环境: production\n`);
-
-        // 启动所有 Worker
-        for (let i = 0; i < instances; i++) {
-            const port = startPort + i;
-            this.spawnWorker(i, port);
-        }
-
-        // 监听进程信号
-        this.setupSignalHandlers();
-
-        Logger.info(`集群启动成功！\n`);
-        this.printWorkerStatus();
-    }
-
-    /**
-     * 获取实例数量
-     */
-    private getInstanceCount(): number {
-        const { instances } = this.options;
-
-        if (instances === 'max') {
-            return navigator.hardwareConcurrency || 4;
-        }
-
-        const count = typeof instances === 'string' ? parseInt(instances) : instances;
-
-        if (isNaN(count) || count < 1) {
-            Logger.warn(`无效的实例数量 "${instances}"，使用默认值 4`);
-            return 4;
-        }
-
-        return count;
-    }
-
-    /**
-     * 启动单个 Worker
-     */
-    private spawnWorker(id: number, port: number): void {
-        const { projectRoot, host, env = {} } = this.options;
-
-        Logger.info(`启动 Worker ${id} (端口 ${port})...`);
-
-        // 使用内置的 worker 入口文件
-        const workerFile = join(import.meta.dir, 'cluster-worker.ts');
-
-        const proc = Bun.spawn(['bun', 'run', '--env-file=.env.production', workerFile], {
-            cwd: projectRoot,
-            stdout: 'inherit',
-            stderr: 'inherit',
-            stdin: 'inherit',
-            env: {
-                ...process.env,
-                ...env,
-                NODE_ENV: 'production',
-                APP_PORT: port.toString(),
-                APP_HOST: host,
-                CLUSTER_MODE: '1',
-                CLUSTER_WORKER_ID: id.toString(),
-                CLUSTER_INSTANCES: this.getInstanceCount().toString(),
-                FORCE_COLOR: '1'
-            }
-        });
-
-        // 保存 Worker 信息
-        this.workers.set(id, {
-            id,
-            port,
-            process: proc,
-            restartCount: 0,
-            lastRestartTime: 0
-        });
-
-        // 监听进程退出
-        this.watchWorker(id, port);
-    }
-
-    /**
-     * 监听 Worker 退出并自动重启
-     */
-    private async watchWorker(id: number, port: number): Promise<void> {
-        const worker = this.workers.get(id);
-        if (!worker) return;
-
-        const exitCode = await worker.process.exited;
-
-        // 如果正在关闭，不重启
-        if (this.isShuttingDown) {
-            Logger.info(`Worker ${id} (端口 ${port}) 已退出`);
-            return;
-        }
-
-        Logger.warn(`Worker ${id} (端口 ${port}) 异常退出，退出码: ${exitCode}`);
-
-        // 检查重启次数
-        if (!this.canRestart(worker)) {
-            Logger.error(`Worker ${id} 重启次数过多，停止重启`);
-            return;
-        }
-
-        // 延迟重启
-        Logger.info(`${this.RESTART_DELAY / 1000} 秒后重启 Worker ${id}...`);
-        await Bun.sleep(this.RESTART_DELAY);
-
-        // 更新重启计数
-        this.updateRestartCount(worker);
-
-        // 重新启动
-        this.spawnWorker(id, port);
-    }
-
-    /**
-     * 检查是否可以重启
-     */
-    private canRestart(worker: WorkerInfo): boolean {
-        const now = Date.now();
-        const timeSinceLastRestart = now - worker.lastRestartTime;
-
-        // 如果距离上次重启超过窗口期，重置计数
-        if (timeSinceLastRestart > this.RESTART_WINDOW) {
-            worker.restartCount = 0;
-        }
-
-        return worker.restartCount < this.MAX_RESTARTS;
-    }
-
-    /**
-     * 更新重启计数
-     */
-    private updateRestartCount(worker: WorkerInfo): void {
-        worker.restartCount++;
-        worker.lastRestartTime = Date.now();
-    }
-
-    /**
-     * 设置信号处理器
-     */
-    private setupSignalHandlers(): void {
-        const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGHUP'];
-
-        signals.forEach((signal) => {
-            process.on(signal, () => {
-                this.gracefulShutdown(signal);
-            });
-        });
-    }
-
-    /**
-     * 优雅关闭
-     */
-    private async gracefulShutdown(signal: NodeJS.Signals): Promise<void> {
-        if (this.isShuttingDown) return;
-        this.isShuttingDown = true;
-
-        Logger.info(`\n收到 ${signal} 信号，正在关闭集群...`);
-
-        // 向所有 Worker 发送 SIGTERM
-        for (const [id, worker] of this.workers.entries()) {
-            Logger.info(`关闭 Worker ${id} (端口 ${worker.port})...`);
-            try {
-                worker.process.kill('SIGTERM');
-            } catch (error) {
-                Logger.warn(`无法向 Worker ${id} 发送 SIGTERM:`, error);
-            }
-        }
-
-        // 等待所有进程退出，最多 3 秒（Bun 的 server.stop() 很快）
-        const timeout = setTimeout(() => {
-            Logger.warn('等待超时（3秒），强制关闭所有 Worker');
-            for (const worker of this.workers.values()) {
-                try {
-                    worker.process.kill('SIGKILL');
-                } catch (error) {
-                    // 忽略 SIGKILL 失败（进程可能已退出）
-                }
-            }
-            // 强制退出主进程
-            setTimeout(() => process.exit(1), 500);
-        }, 3000);
-
-        try {
-            // 等待所有进程退出
-            await Promise.all(Array.from(this.workers.values()).map((w) => w.process.exited));
-            clearTimeout(timeout);
-            Logger.info('集群已安全关闭');
-            process.exit(0);
-        } catch (error) {
-            clearTimeout(timeout);
-            Logger.error('等待 Worker 退出时发生错误:', error);
-            process.exit(1);
-        }
-    }
-
-    /**
-     * 打印 Worker 状态
-     */
-    private printWorkerStatus(): void {
-        Logger.info('Worker 列表:');
-        for (const worker of this.workers.values()) {
-            Logger.info(`  - Worker ${worker.id}: http://${this.options.host}:${worker.port}`);
-        }
-        Logger.info('');
-    }
-}