@alloy-framework/core 0.4.0 → 0.14.0

package/src/http/AlloyController.js

@@ -1,322 +0,0 @@
-import { performance } from 'perf_hooks';
-
-/**
- * 🎛️ Alloy HTTP 컨트롤러 기반 클래스
- * Rust Axum 서버의 HTTP 요청을 처리합니다.
- * 요청(req)과 완료자(completer)를 받아 JSON/HTML/Redirect 등 다양한 응답을 생성합니다.
- *
- * @example
- * export const HomeController = createController(class HomeController extends AlloyController {
- *     async index() {
- *         this.render('index.html', { title: 'Home' });
- *     }
- *
- *     async api() {
- *         this.success({ version: '1.0' });
- *     }
- * });
- */
-export class AlloyController {
-    /**
-     * @param {object} req - Rust AlloyRequest 네이티브 객체
-     * @param {object} completer - Rust AlloyCompleter 네이티브 핸들
-     */
-    constructor(req, completer) {
-        /** @type {object} 네이티브 요청 객체 */
-        this.req = req;
-        /** @type {object} 네이티브 응답 완료자 */
-        this.completer = completer;
-        /** @type {object|null} AlloyApp 참조 (dispatch 시 주입) */
-        this.app = null;
-
-        /** @type {number} HTTP 응답 상태 코드 */
-        this._status = 200;
-        /** @type {object} 응답 헤더 */
-        this._headers = {};
-        /** @type {number} 요청 시작 시간 (성능 추적) */
-        this._start = performance.now();
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📥 요청 접근자
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /** @returns {string} 요청 URL */
-    get url() { return this.req.url; }
-
-    /** @returns {string} HTTP 메서드 */
-    get method() { return this.req.method; }
-
-    /** @returns {string} 클라이언트 IP */
-    get ip() { return this.req.ip; }
-
-    /** @returns {object} URL 경로 파라미터 (:id 등) */
-    get params() { return this.req.params || {}; }
-
-    /** @returns {object} 쿼리 파라미터 */
-    get queries() { return this.req.query || {}; }
-
-    /**
-     * 요청 본문 (자동 JSON / URL-encoded 파싱)
-     * @returns {object|string}
-     */
-    get body() {
-        if (this._parsedBody !== undefined) return this._parsedBody;
-
-        // dispatch에서 validator 처리 시 이미 파싱된 결과 재사용 (이중 파싱 방지)
-        if (this.req.parsedBody !== undefined) {
-            this._parsedBody = this.req.parsedBody;
-            return this._parsedBody;
-        }
-
-        const raw = this.req.body;
-        if (!raw || typeof raw !== 'string') {
-            this._parsedBody = raw || {};
-            return this._parsedBody;
-        }
-
-        const trimmed = raw.trim();
-
-        // JSON 감지
-        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-            try { this._parsedBody = JSON.parse(trimmed); return this._parsedBody; } catch { /* fallthrough */ }
-        }
-
-        // URL-encoded 감지
-        if (trimmed.includes('=')) {
-            try {
-                const params = new URLSearchParams(trimmed);
-                this._parsedBody = Object.fromEntries(params.entries());
-                return this._parsedBody;
-            } catch { /* fallthrough */ }
-        }
-
-        this._parsedBody = raw;
-        return this._parsedBody;
-    }
-
-    /**
-     * 헤더 값 조회 (대소문자 무관)
-     * @param {string} key
-     * @returns {string|undefined}
-     */
-    header(key) {
-        return this.req.headers?.[key.toLowerCase()] || this.req.headers?.[key];
-    }
-
-    /**
-     * 쿼리 파라미터 단일 조회
-     * @param {string} key
-     * @returns {string|null}
-     */
-    query(key) {
-        return this.req.query ? this.req.query[key] : null;
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔒 세션 헬퍼
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 세션 값 설정
-     * @param {string} key
-     * @param {any} value - 객체는 자동 JSON 직렬화
-     */
-    setSession(key, value) {
-        this.req.session = this.req.session || {};
-        this.req.session[key] = typeof value === 'object' ? JSON.stringify(value) : value;
-        this._sessionDirty = true; // 세션 변경 시 write-back 플래그
-    }
-
-    /**
-     * 세션 값 조회 (자동 역직렬화)
-     * @param {string} key
-     * @returns {any}
-     */
-    getSession(key) {
-        if (!this.req.session) return null;
-        const val = this.req.session[key];
-        if (val == null) return null;
-        if (typeof val === 'string') {
-            try { return JSON.parse(val); } catch { return val; }
-        }
-        return val;
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📤 응답 헬퍼
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * HTTP 상태 코드 설정 (체이닝)
-     * @param {number} code
-     * @returns {this}
-     */
-    status(code) {
-        this._status = code;
-        return this;
-    }
-
-    /**
-     * 응답 헤더 설정 (체이닝)
-     * @param {string} key
-     * @param {string} value
-     * @returns {this}
-     */
-    setHeader(key, value) {
-        this._headers[key] = value;
-        return this;
-    }
-
-    /**
-     * JSON 응답 전송
-     * @param {object} data
-     */
-    json(data) {
-        this.setHeader('Content-Type', 'application/json');
-        this.send(JSON.stringify(data));
-    }
-
-    /**
-     * Raw Body 응답 전송
-     * @param {string} body
-     */
-    send(body) {
-        this._finalize();
-        this.completer.done({
-            status: this._status,
-            headers: this._headers,
-            body: typeof body === 'string' ? body : String(body),
-            session: this._sessionDirty ? this.req.session : undefined,
-        });
-    }
-
-    /**
-     * HTML 응답 전송
-     * @param {string} html - HTML 문자열
-     */
-    html(html) {
-        this.setHeader('Content-Type', 'text/html; charset=utf-8');
-        this.send(html);
-    }
-
-    /**
-     * Tera 템플릿 렌더링 (Rust 엔진 활용)
-     * @param {string} view - 템플릿 이름 (예: 'index.html')
-     * @param {object} [data={}] - 컨텍스트 데이터
-     */
-    render(view, data = {}) {
-        // 테마 미들웨어 지원
-        if (this.req.theme && !view.startsWith('/') && !view.startsWith(this.req.theme)) {
-            view = `${this.req.theme}/${view}`;
-        }
-
-        this._finalize();
-        this.completer.done({
-            status: this._status,
-            headers: this._headers,
-            body: '',
-            template: view,
-            context: JSON.stringify(data),
-            session: this._sessionDirty ? this.req.session : undefined,
-        });
-    }
-
-    /**
-     * 리다이렉트
-     * @param {string} url
-     * @param {number} [statusCode=302]
-     */
-    redirect(url, statusCode = 302) {
-        this.status(statusCode);
-        this.setHeader('Location', url);
-        this.send('');
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📊 표준 응답 포맷
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 성공 응답
-     * @param {any} data
-     * @param {string} [message='Ok']
-     * @param {string} [code='SUCCESS']
-     */
-    success(data, message = 'Ok', code = 'SUCCESS') {
-        this.json({
-            status: this._status,
-            code,
-            message,
-            timestamp: Date.now(),
-            data,
-        });
-    }
-
-    /**
-     * 에러 응답
-     * @param {string} message
-     * @param {string} [code='ERR_GENERIC']
-     * @param {number} [statusCode=400]
-     * @param {any} [data=null]
-     */
-    error(message, code = 'ERR_GENERIC', statusCode = 400, data = null) {
-        this.status(statusCode);
-        this.json({
-            status: this._status,
-            code,
-            message,
-            timestamp: Date.now(),
-            data,
-        });
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔧 내부 메서드
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 응답 직전 처리 (성능 헤더 추가 등)
-     * @private
-     */
-    _finalize() {
-        const duration = performance.now() - this._start;
-        this.setHeader('X-Alloy-Time', `${duration.toFixed(2)}ms`);
-    }
-}
-
-/**
- * 🏭 컨트롤러 Proxy 팩토리
- * `Controller.methodName` → `{ controller, method }` 라우트 디스크립터 자동 변환
- *
- * @example
- * export const Home = createController(class extends AlloyController {
- *     async index() { this.html('<h1>Hello</h1>'); }
- *     async about() { this.html('<h1>About</h1>'); }
- * });
- *
- * // 라우트 등록
- * router.get('/', Home);           // → index() 호출
- * router.get('/about', Home.about); // → about() 호출
- *
- * @param {typeof AlloyController} ControllerClass
- * @returns {Proxy}
- */
-export function createController(ControllerClass) {
-    return new Proxy(ControllerClass, {
-        get(target, prop, receiver) {
-            // prototype 메서드 → 라우트 디스크립터 반환
-            if (
-                typeof prop === 'string' &&
-                prop !== 'prototype' &&
-                prop !== 'name' &&
-                prop !== 'length' &&
-                prop !== 'constructor' &&
-                typeof target.prototype[prop] === 'function'
-            ) {
-                return { controller: target, method: prop };
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-    });
-}

package/src/http/AlloyRouter.js

@@ -1,130 +0,0 @@
-import { isMainThread } from 'worker_threads';
-
-/**
- * URL 경로 결합 (path.join은 OS 파일 경로용이므로 URL에 부적합)
- * @param {...string} segments - 결합할 경로 세그먼트
- * @returns {string} 정규화된 URL 경로
- * @private
- */
-function joinUrl(...segments) {
-    return ('/' + segments.join('/')).replace(/\/+/g, '/');
-}
-
-/**
- * 🗺️ Alloy 라우터
- * HTTP/HTTPS 라우트를 등록하고 Rust 네이티브 라우터에 전달합니다.
- * `controllers/` 디렉토리의 Route 파일에서 사용합니다.
- *
- * @example
- * // controllers/HomeRoute.js
- * import { HomeController } from './HomeController.js';
- *
- * export default (router) => {
- *     router.get('/', HomeController);
- *     router.get('/about', HomeController.about);
- *     router.get('/api/status', HomeController.status);
- * };
- */
-export class AlloyRouter {
-    /**
-     * @param {object} app - AlloyApp 인스턴스
-     */
-    constructor(app) {
-        /** @type {object} AlloyApp 참조 */
-        this.app = app;
-        /** @type {string} 현재 URL 프리픽스 (group 내부에서 사용) */
-        this.prefix = '';
-        /** @type {Map<number, object>} 핸들러 ID → { handler, middlewares, validator } */
-        this.handlers = new Map();
-        /** @type {Array} 글로벌 미들웨어 스택 */
-        this.middlewares = [];
-        /** @type {number} 핸들러 ID 카운터 */
-        this.handlerIdCounter = 1000;
-    }
-
-    /**
-     * 글로벌 미들웨어 등록
-     * @param {object|Function} middleware
-     */
-    use(middleware) {
-        this.middlewares.push(middleware);
-    }
-
-    /**
-     * 라우트 그룹 (공통 프리픽스)
-     * @param {string} prefix - URL 프리픽스
-     * @param {Function} callback - (router) => { ... }
-     */
-    group(prefix, callback) {
-        const parentPrefix = this.prefix;
-        this.prefix = joinUrl(parentPrefix, prefix);
-        callback(this);
-        this.prefix = parentPrefix;
-    }
-
-    /** GET 라우트 */
-    get(path, ...handlers) { this.register('GET', path, ...handlers); }
-    /** POST 라우트 */
-    post(path, ...handlers) { this.register('POST', path, ...handlers); }
-    /** PUT 라우트 */
-    put(path, ...handlers) { this.register('PUT', path, ...handlers); }
-    /** DELETE 라우트 */
-    delete(path, ...handlers) { this.register('DELETE', path, ...handlers); }
-
-    /**
-     * 라우트 등록 (네이티브 Rust 라우터에 전달)
-     *
-     * @param {string} method - HTTP 메서드
-     * @param {string} path - URL 경로
-     * @param {...any} args - [미들웨어 배열?, 옵션?, 핸들러]
-     */
-    register(method, path, ...args) {
-        // 경로 정규화
-        let fullPath = joinUrl(this.prefix, path);
-        if (!fullPath.startsWith('/')) fullPath = '/' + fullPath;
-        // trailing slash 제거 (루트 '/' 제외) — path.join이 URL 경로에 슬래시를 추가하는 문제 방지
-        if (fullPath.length > 1 && fullPath.endsWith('/')) fullPath = fullPath.slice(0, -1);
-
-        // 마지막 인자 = 핸들러
-        let handler = args.pop();
-
-        // 하위호환: (Controller, 'methodName') 패턴
-        if (typeof handler === 'string') {
-            const methodName = handler;
-            const controllerClass = args.pop();
-            handler = { controller: controllerClass, method: methodName };
-        }
-
-        // 미들웨어 + validator 분리
-        let validator = null;
-        const middlewares = [];
-
-        for (const arg of args) {
-            if (Array.isArray(arg)) {
-                middlewares.push(...arg);
-            } else if (arg && typeof arg === 'object' && !Array.isArray(arg) && (arg.validator || arg.validate)) {
-                validator = arg.validator || arg.validate;
-            } else if (arg) {
-                middlewares.push(arg);
-            }
-        }
-
-        // 핸들러 ID 부여 + 맵 저장
-        const id = this.handlerIdCounter++;
-        this.handlers.set(id, { handler, middlewares, validator });
-
-        // Rust 네이티브 라우터에 등록 (메인 스레드에서만)
-        if (isMainThread) {
-            this.app.native.registerRoute(method, fullPath, id);
-        }
-    }
-
-    /**
-     * 핸들러 ID로 핸들러 데이터 조회
-     * @param {number} id
-     * @returns {object|undefined}
-     */
-    getHandler(id) {
-        return this.handlers.get(id);
-    }
-}

package/src/http/Validator.js

@@ -1,52 +0,0 @@
-import Joi from 'joi';
-
-/**
- * ✅ Alloy 요청 검증기
- * Joi 스키마를 활용한 데이터 검증 유틸리티입니다.
- *
- * @example
- * class Users extends AlloyModel {
- *     static schema = Joi.object({
- *         username: Joi.string().required(),
- *         email: Joi.string().email().required(),
- *     });
- * }
- */
-export class Validator {
-    /**
-     * Joi 스키마로 데이터 검증 + 정제
-     * @param {import('joi').ObjectSchema} schema - Joi 스키마
-     * @param {object} data - 검증할 데이터
-     * @param {boolean} [isPartial=false] - true면 누락 필드 허용 (UPDATE용)
-     * @returns {object} 검증 + 정제된 데이터
-     * @throws {Error} 검증 실패 시
-     */
-    static validate(schema, data, isPartial = false) {
-        const options = {
-            abortEarly: false,       // 모든 에러 수집
-            stripUnknown: true,      // 스키마에 없는 필드 제거
-            allowUnknown: false,
-        };
-
-        // UPDATE 시 partial 검증 — 누락 필드 허용
-        const target = isPartial ? schema.fork(
-            Object.keys(schema.describe().keys),
-            (s) => s.optional(),
-        ) : schema;
-
-        const { error, value } = target.validate(data, options);
-
-        if (error) {
-            const details = error.details.map(d => d.message).join(', ');
-            const err = new Error(`Validation Error: ${details}`);
-            err.statusCode = 400; // Bad Request
-            err.code = 'VALIDATION_ERROR';
-            throw err;
-        }
-
-        return value;
-    }
-}
-
-// Joi를 re-export하여 SDK 사용자가 별도 설치 없이 사용 가능
-export { Joi };

package/src/http/index.js

@@ -1,6 +0,0 @@
-/**
- * 🌐 HTTP 계층 통합 export
- */
-export { AlloyController, createController } from './AlloyController.js';
-export { AlloyRouter } from './AlloyRouter.js';
-export { Validator, Joi } from './Validator.js';