@alloy-framework/core 0.4.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-framework/core",
-  "version": "0.4.0",
+  "version": "0.15.0",
   "type": "module",
   "description": "Alloy Framework — High-performance Node.js framework built on Rust N-API native engine",
   "main": "src/index.js",
@@ -22,8 +22,8 @@
     "wasm/"
   ],
   "dependencies": {
-    "@alloy-framework/rust": "0.4.0",
-    "@alloy-framework/client-wasm": "0.4.0",
+    "@alloy-framework/rust": "0.15.0",
+    "@alloy-framework/client-wasm": "0.15.0",
     "glob": "^13.0.0",
     "joi": "^18.0.2"
   },

package/src/app/AlloyApp.js

@@ -1,610 +0,0 @@
-import native from '@alloy-framework/rust';
-import { dirname, join, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { existsSync } from 'fs';
-import { glob } from 'glob';
-import { isMainThread, Worker, workerData } from 'worker_threads';
-
-import { AlloyWebSocket } from '../ws/AlloyWebSocket.js';
-import { AlloyConfig } from '../config/AlloyConfig.js';
-import { AlloyRouter } from '../http/AlloyRouter.js';
-import { AlloyController } from '../http/AlloyController.js';
-import { AlloyError } from '../util/AlloyError.js';
-
-/**
- * 🚀 Alloy 앱 부트스트래퍼
- * Rust 네이티브 서버를 부팅하고, WS 라이프사이클/라우터/워커/플러그인을 오케스트레이션합니다.
- *
- * 마스터 스레드: bootSystem → WS 등록 → Worker N개 spawn → startServer
- * 워커 스레드: discoverRoutes → registerWorker(id, callback)
- *
- * @example
- * import { AlloyApp } from '@alloy-framework/core';
- *
- * class MyApp extends AlloyApp {
- *     constructor() {
- *         super(import.meta.url);
- *         this.ws({
- *             onConnect(socket) { console.log('Connected:', socket.id); },
- *             onMessage(socket, msg) { socket.broadcast(msg); },
- *             onDisconnect(socket) { console.log('Disconnected:', socket.id); },
- *         });
- *     }
- * }
- *
- * const app = new MyApp();
- * await app.boot();
- * await app.start();
- */
-export class AlloyApp {
-    /**
-     * @param {string} importMetaUrl - import.meta.url (앱 진입점 위치 해석용)
-     */
-    constructor(importMetaUrl) {
-        /** @type {object} Rust N-API 네이티브 모듈 */
-        this.native = native;
-        /** @type {string} import.meta.url 원본 (Worker spawn 시 사용) */
-        this._importMetaUrl = importMetaUrl;
-        /** @type {string} 앱 파일 절대경로 (Worker spawn 대상) */
-        this.filename = fileURLToPath(importMetaUrl);
-        /** @type {string} 앱 루트 디렉토리 */
-        this.appDir = dirname(this.filename);
-        /** @type {Map<string, AlloyWebSocket>} 로컬 WS 클라이언트 맵 */
-        this.clients = new Map();
-        /** @type {Array<object>} 등록된 플러그인 목록 */
-        this._plugins = [];
-        /** @type {object|null} WS 라이프사이클 핸들러 */
-        this._wsHandlers = null;
-        /** @type {AlloyRouter|null} 라우터 인스턴스 */
-        this.router = null;
-        /** @type {Map<number, Worker>} 워커 인스턴스 맵 (마스터 전용) */
-        this.workers = new Map();
-        /** @type {Map<number, number[]>} 워커별 재시작 타임스탬프 */
-        this._workerRestartTimestamps = new Map();
-        /** @type {object} 라이프사이클 훅 */
-        this.hooks = {
-            onBeforeBoot: async () => {},
-            onAfterBoot: async () => {},
-        };
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔌 플러그인 시스템
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 플러그인 등록
-     * @param {object} plugin - { name, onRequest?, onResponse?, onBoot?, ... }
-     * @returns {this}
-     */
-    use(plugin) {
-        if (!plugin || !plugin.name) {
-            throw new AlloyError('PLUGIN_INVALID', '플러그인은 name 속성이 필수입니다', 500);
-        }
-        this._plugins.push(plugin);
-        return this;
-    }
-
-    /**
-     * 등록된 플러그인 조회
-     * @param {string} name
-     * @returns {object|undefined}
-     */
-    getPlugin(name) {
-        return this._plugins.find(p => p.name === name);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔌 WebSocket 핸들러
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * WebSocket 라이프사이클 핸들러 등록
-     * @param {object} handlers - { onConnect, onMessage, onDisconnect }
-     * @returns {this}
-     */
-    ws(handlers) {
-        this._wsHandlers = handlers;
-        return this;
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🚀 부트
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 앱 부트 — 마스터/워커 분기
-     * 마스터: bootSystem + WS + 스키마 + 플러그인
-     * 워커: 라우트 디스커버리만
-     */
-    async boot() {
-        if (isMainThread) {
-            await this._bootMaster();
-        } else {
-            await this._bootWorker();
-        }
-    }
-
-    /**
-     * 서버 시작 — 마스터/워커 분기
-     * 마스터: 워커 N개 spawn + Rust 서버 시작
-     * 워커: registerWorker(id, callback)
-     */
-    async start() {
-        if (isMainThread) {
-            await this._startMaster();
-        } else {
-            this._startWorker();
-        }
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔑 마스터 스레드
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 마스터 부트 — 네이티브 시스템 + WS + 스키마 + 플러그인
-     * @private
-     */
-    async _bootMaster() {
-        // 1. 라이프사이클 훅
-        await this.hooks.onBeforeBoot();
-
-        // 2. console을 네이티브 로거로 리다이렉트
-        this._redirectConsole();
-
-        // 3. alloy.conf 경로 탐색 + 네이티브 시스템 부트
-        const configPath = join(this.appDir, 'alloy.conf');
-        this.native.bootSystem(existsSync(configPath) ? configPath : undefined);
-
-        // 4. 플러그인 onBoot 훅 실행
-        for (const plugin of this._plugins) {
-            if (typeof plugin.onBoot === 'function') {
-                await plugin.onBoot(this);
-            }
-        }
-
-        // 5. 라우터 초기화 + 글로벌 미들웨어 + 라우트 Auto-Discovery
-        this.router = new AlloyRouter(this);
-        if (typeof this.middleware === 'function') {
-            this.middleware(this.router);
-        }
-        await this._discoverRoutes();
-
-        // 6. 스키마 동기화 (models/ 존재 시)
-        await this._syncSchemas();
-
-        // 7. WS 라이프사이클 등록 (마스터 전용)
-        if (this._wsHandlers) {
-            this._registerWsLifecycle();
-        }
-
-        // 8. 라이프사이클 훅
-        await this.hooks.onAfterBoot();
-
-        console.info('✅ AlloyApp Booted Successfully');
-    }
-
-    /**
-     * 마스터 서버 시작 — 워커 spawn + Rust 서버 시작
-     * @private
-     */
-    async _startMaster() {
-        // 1. AlloyConfig에서 워커 수 조회
-        const workerCount = AlloyConfig.get('server.workers', 4);
-
-        // 2. 워커 스레드 N개 생성
-        const MAX_RESTARTS_PER_MINUTE = 5;
-        console.debug(`🔧 Spawning ${workerCount} Worker(s)...`);
-
-        for (let i = 1; i <= workerCount; i++) {
-            this._spawnWorker(i, workerCount, MAX_RESTARTS_PER_MINUTE);
-        }
-
-        // 3. Rust 서버 시작 (비동기, 별도 스레드)
-        this.native.startServer();
-
-        // 4. Graceful Shutdown 핸들링
-        this._registerShutdown();
-
-        // 5. 메인 스레드 유지 (워커 관리 + SIGINT 핸들러가 동작하려면 이벤트 루프 필요)
-        setInterval(() => {}, 1000 * 60 * 60);
-    }
-
-    /**
-     * 워커 스레드 생성 (비정상 종료 시 자동 재시작)
-     * @param {number} id - 워커 ID (1-based)
-     * @param {number} totalWorkers - 총 워커 수
-     * @param {number} maxRestartsPerMinute - 분당 최대 재시작 횟수
-     * @private
-     */
-    _spawnWorker(id, totalWorkers, maxRestartsPerMinute = 5) {
-        const worker = new Worker(this.filename, {
-            workerData: { id, totalWorkers },
-            stdout: 'inherit',
-            stderr: 'inherit',
-        });
-
-        this.workers.set(id, worker);
-
-        worker.on('online', () => {
-            console.debug(`✅ Worker #${id} online`);
-        });
-
-        worker.on('error', (err) => {
-            console.error(`❌ Worker #${id} error:`, err.message);
-        });
-
-        worker.on('exit', (code) => {
-            this.workers.delete(id);
-
-            // shutdown 중이면 terminate().then()에서 이미 로깅하므로 스킵
-            if (this._shuttingDown) return;
-
-            if (code !== 0) {
-                console.warn(`⚠️ Worker #${id} exited with code ${code}`);
-
-                // 과도한 재시작 방지 (분당 최대 횟수 체크)
-                const now = Date.now();
-                const timestamps = this._workerRestartTimestamps.get(id) || [];
-                const recentTimestamps = timestamps.filter(t => now - t < 60000);
-
-                if (recentTimestamps.length >= maxRestartsPerMinute) {
-                    console.error(`🚨 Worker #${id}: ${maxRestartsPerMinute}회/분 재시작 한도 초과. 재시작 중단.`);
-                    this._workerRestartTimestamps.set(id, recentTimestamps);
-                    return;
-                }
-
-                recentTimestamps.push(now);
-                this._workerRestartTimestamps.set(id, recentTimestamps);
-
-                // 1초 후 재시작
-                setTimeout(() => {
-                    console.warn(`🔄 Restarting Worker #${id}...`);
-                    this._spawnWorker(id, totalWorkers, maxRestartsPerMinute);
-                }, 1000);
-            } else {
-                console.warn(`✅ Worker #${id} exited normally`);
-            }
-        });
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // � 워커 스레드
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 워커 부트 — console 리다이렉트 + 라우트 디스커버리
-     * @private
-     */
-    async _bootWorker() {
-        this._redirectConsole();
-
-        // 워커에서도 라우트를 디스커버 (핸들러 맵 구축용)
-        this.router = new AlloyRouter(this);
-        if (typeof this.middleware === 'function') {
-            this.middleware(this.router);
-        }
-        await this._discoverRoutes();
-
-        // unhandled rejection 방어 (워커 크래시 방지)
-        process.on('unhandledRejection', (reason) => {
-            console.error(`❌ Worker #${workerData.id} Unhandled Rejection:`, reason);
-        });
-    }
-
-    /**
-     * 워커 서버 시작 — Rust에 registerWorker 등록
-     * @private
-     */
-    _startWorker() {
-        const { id } = workerData;
-        const app = this;
-
-        this.native.registerWorker(id, async (req, completer) => {
-            try {
-                if (req.handlerId) {
-                    const routeData = app.router.getHandler(req.handlerId);
-                    if (routeData) {
-                        await app._dispatch(routeData, req, completer);
-                    } else {
-                        console.error(`[Worker #${id}] Handler ID ${req.handlerId} not found`);
-                        completer.done({ status: 500, headers: {}, body: 'Handler Not Found' });
-                    }
-                } else {
-                    completer.done({ status: 404, headers: {}, body: 'No Handler ID' });
-                }
-            } catch (err) {
-                console.error(`❌ [Worker #${id}] Error:`, err.message, err);
-                try {
-                    const accept = (req.headers?.accept || '').toLowerCase();
-                    const statusCode = err.statusCode || 500;
-
-                    if (accept.includes('text/html')) {
-                        // 브라우저 요청 → Rust Tera 템플릿 렌더링 위임
-                        const template = statusCode === 404 ? '404.html' : 'error.html';
-                        completer.done({
-                            status: statusCode,
-                            headers: {},
-                            body: '',
-                            template,
-                            context: JSON.stringify({
-                                status: statusCode,
-                                code: err.code || 'INTERNAL_ERROR',
-                                message: err.message || 'Internal Server Error',
-                                timestamp: Date.now(),
-                            }),
-                        });
-                    } else {
-                        // API/JSON 요청 → JSON 에러 응답
-                        completer.done({
-                            status: statusCode,
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({
-                                status: statusCode,
-                                code: err.code || 'INTERNAL_ERROR',
-                                message: err.message || 'Internal Server Error',
-                                timestamp: Date.now(),
-                            }),
-                        });
-                    }
-                } catch { /* completer 이미 소비됨 */ }
-            }
-        });
-
-        console.debug(`👷 Worker #${id} registered`);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // �🔒 내부 메서드
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * console을 네이티브 로거로 리다이렉트
-     * @private
-     */
-    _redirectConsole() {
-        if (!this.native.logInfo) return;
-
-        const fmt = (args) => args.map(a => {
-            if (a instanceof Error) return `${a.message}${a.stack ? '\n' + a.stack : ''}`;
-            if (typeof a === 'object') { try { return JSON.stringify(a); } catch { return String(a); } }
-            return String(a);
-        }).join(' ');
-
-        console.log = (...args) => this.native.logInfo(fmt(args));
-        console.info = (...args) => this.native.logInfo(fmt(args));
-        console.warn = (...args) => this.native.logWarn(fmt(args));
-        console.error = (...args) => this.native.logError(fmt(args));
-        console.debug = (...args) => this.native.logDebug(fmt(args));
-    }
-
-    /**
-     * 라우트 파일 자동 디스커버리 (controllers/*Route.js)
-     * @private
-     */
-    async _discoverRoutes() {
-        const controllersDir = resolve(this.appDir, 'controllers');
-        if (!existsSync(controllersDir)) return;
-
-        // *Route.js 패턴 스캔
-        const routeFiles = await glob('**/*Route.js', { cwd: controllersDir });
-        routeFiles.sort(); // ID 결정적 생성을 위해 정렬
-
-        for (const file of routeFiles) {
-            const filePath = join(controllersDir, file);
-            try {
-                const fileUrl = `file://${filePath}`; // ESM은 file:// URL 필수
-                const routeModule = await import(fileUrl);
-                // default export = function(router) 패턴
-                if (typeof routeModule.default === 'function') {
-                    routeModule.default(this.router);
-                }
-            } catch (e) {
-                console.warn(`⚠️ 라우트 로드 실패: ${file}`, e.message);
-            }
-        }
-    }
-
-    /**
-     * 모델 스키마 자동 동기화
-     * @private
-     */
-    async _syncSchemas() {
-        const modelsDir = join(this.appDir, 'models');
-        if (!existsSync(modelsDir)) return;
-
-        const files = await glob(join(modelsDir, '**/*.js'));
-        for (const file of files) {
-            try {
-                const mod = await import(`file://${file}`);
-                const ModelClass = mod.default || Object.values(mod)[0];
-                // alloySchema 또는 schema (AlloyGoose 형식: name + fields) 둘 다 인식
-                const gooseSchema = ModelClass?.alloySchema
-                    || (ModelClass?.schema?.name && ModelClass?.schema?.fields ? ModelClass.schema : null);
-                if (gooseSchema) {
-                    this.native.addSchema(JSON.stringify(gooseSchema));
-                }
-            } catch (e) {
-                console.warn(`⚠️ 모델 로드 실패: ${file}`, e.message);
-            }
-        }
-
-        if (this.native.syncSchema) {
-            try { await this.native.syncSchema('{}'); } catch (e) { console.warn('⚠️ 스키마 동기화 실패:', e.message); }
-        }
-    }
-
-    /**
-     * WS 라이프사이클 콜백 등록 (마스터에서만 실행)
-     * @private
-     */
-    _registerWsLifecycle() {
-        if (!this.native.registerWsLifecycle) return;
-
-        const handlers = this._wsHandlers;
-        const app = this;
-
-        this.native.registerWsLifecycle(async (jsonStr) => {
-            try {
-                const event = JSON.parse(jsonStr);
-                const { type, id, data } = event;
-
-                if (type === 'CONNECT') {
-                    const connectionData = data ? JSON.parse(data) : {};
-                    const socket = new AlloyWebSocket(id, app.native, connectionData);
-                    app.clients.set(id, socket);
-                    if (handlers.onConnect) await handlers.onConnect.call(app, socket);
-                } else if (type === 'MESSAGE') {
-                    const socket = app.clients.get(id) || new AlloyWebSocket(id, app.native);
-                    if (handlers.onMessage) await handlers.onMessage.call(app, socket, data);
-                } else if (type === 'DISCONNECT') {
-                    const connectionData = data ? JSON.parse(data) : {};
-                    const socket = app.clients.get(id) || new AlloyWebSocket(id, app.native, connectionData);
-                    if (handlers.onDisconnect) await handlers.onDisconnect.call(app, socket);
-                    app.clients.delete(id);
-                }
-            } catch (e) {
-                console.error('❌ WS Event 처리 오류:', e.message);
-            }
-        });
-    }
-
-    /**
-     * 요청 디스패치 — 미들웨어 체인 + 핸들러 실행
-     * @private
-     */
-    async _dispatch(routeData, req, completer) {
-        const res = new AlloyController(req, completer);
-        res.app = this;
-
-        const { handler, middlewares: routeMiddlewares, validator } = routeData;
-
-        // Joi 검증
-        if (validator) {
-            if (validator.body && typeof req.body === 'string' && req.body.trim()) {
-                try { req.parsedBody = JSON.parse(req.body); } catch {
-                    const params = new URLSearchParams(req.body);
-                    req.parsedBody = Object.fromEntries(params.entries());
-                }
-            }
-            if (validator.body) {
-                const { error, value } = validator.body.validate(req.parsedBody || {}, { abortEarly: false, stripUnknown: true });
-                if (error) return res.error(error.details.map(d => d.message).join(', '), 'VALIDATION_ERROR', 400);
-                req.parsedBody = value;
-            }
-        }
-
-        // 미들웨어 체인
-        const globalMiddlewares = this.router.middlewares || [];
-        const allMiddlewares = [...globalMiddlewares, ...(routeMiddlewares || [])];
-
-        let index = -1;
-        const next = async () => {
-            index++;
-            if (index < allMiddlewares.length) {
-                const mw = allMiddlewares[index];
-                if (typeof mw.handle === 'function') await mw.handle(req, res, next);
-                else if (typeof mw === 'function') await mw(req, res, next);
-                else await next();
-            } else {
-                // 최종 핸들러 실행
-                await this._executeHandler(handler, req, completer, res);
-            }
-        };
-
-        if (allMiddlewares.length > 0) {
-            await next();
-        } else {
-            await this._executeHandler(handler, req, completer, res);
-        }
-    }
-
-    /**
-     * 핸들러 실행 — 클래스/함수/디스크립터 패턴 지원
-     * @private
-     */
-    async _executeHandler(handler, req, completer, existingRes = null) {
-        // 1. { controller, method } 디스크립터 패턴
-        if (handler && typeof handler === 'object' && handler.controller) {
-            const controller = new handler.controller(req, completer);
-            controller.app = this;
-            // 미들웨어 헤더 전달
-            if (existingRes?._headers) {
-                for (const [k, v] of Object.entries(existingRes._headers)) {
-                    if (!controller._headers[k]) controller._headers[k] = v;
-                }
-            }
-            const methodName = handler.method || 'index';
-            if (typeof controller[methodName] === 'function') {
-                await controller[methodName]();
-            } else {
-                completer.done({ status: 500, headers: {}, body: `Method '${methodName}' not found` });
-            }
-            return;
-        }
-
-        // 2. 클래스 또는 함수
-        if (typeof handler === 'function') {
-            if (handler.prototype && handler.prototype.index) {
-                // 컨트롤러 클래스 → index() 호출
-                const controller = new handler(req, completer);
-                controller.app = this;
-                await controller.index();
-            } else {
-                // 인라인 핸들러 함수
-                if (existingRes) {
-                    await handler(req, existingRes);
-                } else {
-                    const controller = new AlloyController(req, completer);
-                    controller.app = this;
-                    await handler(req, controller);
-                }
-            }
-        }
-    }
-
-    /**
-     * Graceful Shutdown 핸들링
-     * @private
-     */
-    _registerShutdown() {
-        /** @type {boolean} shutdown 진행 중 플래그 — 워커 exit 핸들러 중복 방지 */
-        this._shuttingDown = false;
-
-        const shutdown = async (signal) => {
-            // 중복 호출 방지 (SIGINT + SIGTERM 동시 수신 시)
-            if (this._shuttingDown) return;
-            this._shuttingDown = true;
-
-            console.warn(`🛑 ${signal} received. Shutting down...`);
-
-            // 1. Rust 서버 종료 시그널 (NATS leave 발행 포함)
-            try {
-                if (this.native.shutdown) this.native.shutdown();
-            } catch (err) {
-                console.error('❌ Shutdown signal failed:', err.message);
-            }
-
-            // 2. 모든 워커 종료 (최대 5초 대기)
-            const terminatePromises = [];
-            for (const [id, worker] of this.workers) {
-                terminatePromises.push(
-                    worker.terminate().then(() => {
-                        console.warn(`✅ Worker #${id} terminated`);
-                    }).catch(err => {
-                        console.error(`❌ Worker #${id} terminate failed:`, err.message);
-                    })
-                );
-            }
-            await Promise.allSettled(terminatePromises);
-
-            // 3. 프로세스 종료
-            console.warn('👋 Goodbye!');
-            process.exit(0);
-        };
-
-        process.on('SIGINT', () => shutdown('SIGINT'));
-        process.on('SIGTERM', () => shutdown('SIGTERM'));
-    }
-}