@fuzionx/core 0.1.38 → 0.1.41

package/lib/context.js

@@ -1,225 +1,229 @@
-/**
- * Context — Fusion raw req 객체를 Express 스타일 req/res로 변환.
- *
- * 최적화:
- *   - 프로토타입 기반 + 재사용 가능한 응답 객체
- *   - Object.defineProperty 제거 → 함수 기반 lazy JSON
- *   - 요청당 클로저 최소화
- *   - _toFusionResponse()에서 할당 0
- */
-
-// ── req.session 프로토타입 ──
-const SessionProto = {
-    get(key) {
-        if (key) return this._data[key] || null;
-        return { ...this._data };
-    },
-    set(key, value) {
-        this._data[key] = String(value);
-        if (this._id) {
-            this._bridge.sessionSet(this._id, { ...this._data });
-        }
-    },
-    destroy() {
-        if (this._id) {
-            this._bridge.sessionDestroy(this._id);
-            this._data = {};
-        }
-    },
-    renew() {
-        if (this._id) {
-            return this._bridge.sessionRenew(this._id);
-        }
-        return null;
-    },
-};
-
-// ── req 프로토타입 ──
-const ReqProto = {
-    /** lazy JSON 파싱 — body가 이미 object면 그대로 반환 */
-    get json() {
-        if (this._json === undefined) {
-            if (typeof this.body === 'object' && this.body !== null) {
-                this._json = this.body;
-            } else {
-                try {
-                    this._json = this.body ? JSON.parse(this.body) : null;
-                } catch (_) {
-                    this._json = null;
-                }
-            }
-        }
-        return this._json;
-    },
-    /** i18n 번역 */
-    t(key, defaultValue) {
-        const app = this._app;
-        if (!app.i18n) return key;
-        const locale = this.headers?.['accept-language']?.split(',')[0]?.split('-')[0] || 'en';
-        const result = app.i18n.translate(locale, key);
-        if (result == null && defaultValue != null) {
-            app.i18n.updateMissing(key, defaultValue);
-            return defaultValue;
-        }
-        return result || defaultValue || key;
-    },
-};
-
-// ── 사전 할당된 session 인스턴스 (재사용) ──
-const _sharedSession = Object.create(SessionProto);
-_sharedSession._id = null;
-_sharedSession._data = {};
-_sharedSession._bridge = null;
-
-// ── 사전 할당된 req/res 인스턴스 (단일 스레드 재사용) ──
-const _sharedReq = Object.create(ReqProto);
-_sharedReq.method = '';
-_sharedReq.url = '';
-_sharedReq.path = '';
-_sharedReq.query = null;
-_sharedReq.params = null;
-_sharedReq.headers = null;
-_sharedReq.ip = '';
-_sharedReq.body = '';
-_sharedReq.handlerId = 0;
-_sharedReq.requestId = 0;
-_sharedReq.sessionId = null;
-_sharedReq.files = null;
-_sharedReq._app = null;
-_sharedReq._json = undefined;
-_sharedReq.session = _sharedSession;
-
-/**
- * Request 래퍼 생성 — 프로토타입 기반 + 재사용
- * @param {object} rawReq - Fusion 콜백의 raw 요청 객체
- * @param {object} app - FuzionXApp 인스턴스
- * @param {boolean} [reusable=true] - true면 공유 인스턴스 재사용 (sync용), false면 새로 생성 (async용)
- */
-export function createReq(rawReq, app, reusable = true) {
-    let req;
-    if (reusable) {
-        // sync 핸들러: 공유 인스턴스 재사용 (할당 0)
-        req = _sharedReq;
-    } else {
-        // async 핸들러: 새 인스턴스 (응답 전까지 유지 필요)
-        req = Object.create(ReqProto);
-    }
-
-    req.method = rawReq.method;
-    req.url = rawReq.url;
-    req.path = rawReq.path;
-    req.query = rawReq.query || null;
-    req.params = rawReq.params || null;
-    req.headers = rawReq.headers || null;
-    req.ip = rawReq.remoteIp || '';
-    req.body = rawReq.body || '';
-    req.handlerId = rawReq.handlerId;
-    req.requestId = rawReq.requestId;
-    req.sessionId = rawReq.sessionId || null;
-    req._app = app;
-    req._json = undefined;
-    req.files = rawReq.files || null;
-    req.formFields = rawReq.formFields || null;
-
-    // session 업데이트 (재사용)
-    if (reusable) {
-        _sharedSession._id = rawReq.sessionId || null;
-        _sharedSession._data = rawReq.session || {};
-        _sharedSession._bridge = app._bridge;
-    } else {
-        const session = Object.create(SessionProto);
-        session._id = rawReq.sessionId || null;
-        session._data = rawReq.session || {};
-        session._bridge = app._bridge;
-        req.session = session;
-    }
-
-    return req;
-}
-
-// ── Response 프로토타입 ──
-const ResProto = {
-    status(code) {
-        this._statusCode = code;
-        return this;
-    },
-    json(data) {
-        this._body = JSON.stringify(data);
-        this._headers['Content-Type'] = 'application/json';
-        this._sent = true;
-        return this;
-    },
-    send(text) {
-        this._body = String(text);
-        this._sent = true;
-        return this;
-    },
-    html(content) {
-        this._body = String(content);
-        this._headers['Content-Type'] = 'text/html; charset=utf-8';
-        this._sent = true;
-        return this;
-    },
-    redirect(url, code = 302) {
-        this._statusCode = code;
-        this._headers['Location'] = url;
-        this._body = '';
-        this._sent = true;
-        return this;
-    },
-    end() {
-        this._body = '';
-        this._sent = true;
-        return this;
-    },
-    header(key, value) {
-        this._headers[key] = value;
-        return this;
-    },
-    /** Fusion 응답 포맷으로 변환 — 공유 응답 객체 재사용 */
-    _toFusionResponse() {
-        _sharedResponse.status = this._statusCode;
-        _sharedResponse.body = this._body;
-        _sharedResponse.headers = this._headers;
-        return _sharedResponse;
-    },
-};
-
-// ── 사전 할당된 응답 객체 (재사용) ──
-const _sharedResponse = { status: 200, body: '', headers: null };
-const _sharedHeaders = {};
-
-// ── 사전 할당된 res 인스턴스 ──
-const _sharedRes = Object.create(ResProto);
-_sharedRes._statusCode = 200;
-_sharedRes._body = '';
-_sharedRes._headers = _sharedHeaders;
-_sharedRes._sent = false;
-
-/**
- * Response 래퍼 생성 — 프로토타입 기반 + 재사용
- * @param {boolean} [reusable=true] - true면 공유 인스턴스 재사용, false면 새로 생성
- */
-export function createRes(reusable = true) {
-    if (reusable) {
-        // sync: 공유 인스턴스 리셋 후 재사용 (할당 0)
-        _sharedRes._statusCode = 200;
-        _sharedRes._body = '';
-        // headers 객체 재사용 — 이전 키 제거
-        const keys = Object.keys(_sharedHeaders);
-        for (let i = 0; i < keys.length; i++) {
-            delete _sharedHeaders[keys[i]];
-        }
-        _sharedRes._headers = _sharedHeaders;
-        _sharedRes._sent = false;
-        return _sharedRes;
-    }
-
-    // async: 새 인스턴스
-    const res = Object.create(ResProto);
-    res._statusCode = 200;
-    res._body = '';
-    res._headers = {};
-    res._sent = false;
-    return res;
-}
+/**
+ * Context — Fusion raw req 객체를 Express 스타일 req/res로 변환.
+ *
+ * 최적화:
+ *   - 프로토타입 기반 + 재사용 가능한 응답 객체
+ *   - Object.defineProperty 제거 → 함수 기반 lazy JSON
+ *   - 요청당 클로저 최소화
+ *   - _toFusionResponse()에서 할당 0
+ */
+
+// ── req.session 프로토타입 ──
+const SessionProto = {
+    get(key) {
+        if (key) return this._data[key] || null;
+        return { ...this._data };
+    },
+    set(key, value) {
+        this._data[key] = String(value);
+        if (this._id) {
+            this._bridge.sessionSet(this._id, { ...this._data });
+        }
+    },
+    destroy() {
+        if (this._id) {
+            this._bridge.sessionDestroy(this._id);
+            this._data = {};
+        }
+    },
+    renew() {
+        if (this._id) {
+            return this._bridge.sessionRenew(this._id);
+        }
+        return null;
+    },
+};
+
+// ── req 프로토타입 ──
+const ReqProto = {
+    /** lazy JSON 파싱 — body가 이미 object면 그대로 반환 */
+    get json() {
+        if (this._json === undefined) {
+            if (typeof this.body === 'object' && this.body !== null) {
+                this._json = this.body;
+            } else {
+                try {
+                    this._json = this.body ? JSON.parse(this.body) : null;
+                } catch (_) {
+                    this._json = null;
+                }
+            }
+        }
+        return this._json;
+    },
+    /** i18n 번역 */
+    t(key, defaultValue) {
+        const app = this._app;
+        if (!app.i18n) return key;
+        const locale = this.headers?.['accept-language']?.split(',')[0]?.split('-')[0] || 'en';
+        const result = app.i18n.translate(locale, key);
+        if (result == null && defaultValue != null) {
+            app.i18n.updateMissing(key, defaultValue);
+            return defaultValue;
+        }
+        return result || defaultValue || key;
+    },
+};
+
+// ── 사전 할당된 session 인스턴스 (재사용) ──
+const _sharedSession = Object.create(SessionProto);
+_sharedSession._id = null;
+_sharedSession._data = {};
+_sharedSession._bridge = null;
+
+// ── 사전 할당된 req/res 인스턴스 (단일 스레드 재사용) ──
+const _sharedReq = Object.create(ReqProto);
+_sharedReq.method = '';
+_sharedReq.url = '';
+_sharedReq.path = '';
+_sharedReq.query = null;
+_sharedReq.params = null;
+_sharedReq.headers = null;
+_sharedReq.ip = '';
+_sharedReq.body = '';
+_sharedReq.handlerId = 0;
+_sharedReq.requestId = 0;
+_sharedReq.sessionId = null;
+_sharedReq.files = null;
+_sharedReq._app = null;
+_sharedReq._json = undefined;
+_sharedReq.session = _sharedSession;
+
+/**
+ * Request 래퍼 생성 — 프로토타입 기반 + 재사용
+ * @param {object} rawReq - Fusion 콜백의 raw 요청 객체
+ * @param {object} app - FuzionXApp 인스턴스
+ * @param {boolean} [reusable=true] - true면 공유 인스턴스 재사용 (sync용), false면 새로 생성 (async용)
+ */
+export function createReq(rawReq, app, reusable = true) {
+    let req;
+    if (reusable) {
+        // sync 핸들러: 공유 인스턴스 재사용 (할당 0)
+        req = _sharedReq;
+    } else {
+        // async 핸들러: 새 인스턴스 (응답 전까지 유지 필요)
+        req = Object.create(ReqProto);
+    }
+
+    req.method = rawReq.method;
+    req.url = rawReq.url;
+    req.path = rawReq.path;
+    req.query = rawReq.query || null;
+    req.params = rawReq.params || null;
+    req.headers = rawReq.headers || null;
+    req.ip = rawReq.remoteIp || '';
+    req.body = rawReq.body || '';
+    req.handlerId = rawReq.handlerId;
+    req.requestId = rawReq.requestId;
+    req.sessionId = rawReq.sessionId || null;
+    req._app = app;
+    req._json = undefined;
+    req.files = rawReq.files || null;
+    req.formFields = rawReq.formFields || null;
+
+    // session 업데이트 (재사용)
+    if (reusable) {
+        _sharedSession._id = rawReq.sessionId || null;
+        _sharedSession._data = rawReq.session || {};
+        _sharedSession._bridge = app._bridge;
+    } else {
+        const session = Object.create(SessionProto);
+        session._id = rawReq.sessionId || null;
+        session._data = rawReq.session || {};
+        session._bridge = app._bridge;
+        req.session = session;
+    }
+
+    return req;
+}
+
+// ── Response 프로토타입 ──
+const ResProto = {
+    status(code) {
+        this._statusCode = code;
+        return this;
+    },
+    json(data) {
+        this._body = JSON.stringify(data);
+        this._headers['Content-Type'] = 'application/json';
+        this._sent = true;
+        return this;
+    },
+    send(text) {
+        this._body = String(text);
+        this._sent = true;
+        return this;
+    },
+    html(content) {
+        this._body = String(content);
+        this._headers['Content-Type'] = 'text/html; charset=utf-8';
+        this._sent = true;
+        return this;
+    },
+    redirect(url, code = 302) {
+        this._statusCode = code;
+        this._headers['Location'] = url;
+        this._body = '';
+        this._sent = true;
+        return this;
+    },
+    end() {
+        this._body = '';
+        this._sent = true;
+        return this;
+    },
+    header(key, value) {
+        this._headers[key] = value;
+        return this;
+    },
+    /** Fusion 응답 포맷으로 변환 — sync: 공유 객체, async: 새 객체 */
+    _toFusionResponse() {
+        // async (비공유) 인스턴스면 새 객체 반환 → race condition 방지
+        if (this !== _sharedRes) {
+            return { status: this._statusCode, body: this._body, headers: this._headers };
+        }
+        _sharedResponse.status = this._statusCode;
+        _sharedResponse.body = this._body;
+        _sharedResponse.headers = this._headers;
+        return _sharedResponse;
+    },
+};
+
+// ── 사전 할당된 응답 객체 (재사용) ──
+const _sharedResponse = { status: 200, body: '', headers: null };
+const _sharedHeaders = {};
+
+// ── 사전 할당된 res 인스턴스 ──
+const _sharedRes = Object.create(ResProto);
+_sharedRes._statusCode = 200;
+_sharedRes._body = '';
+_sharedRes._headers = _sharedHeaders;
+_sharedRes._sent = false;
+
+/**
+ * Response 래퍼 생성 — 프로토타입 기반 + 재사용
+ * @param {boolean} [reusable=true] - true면 공유 인스턴스 재사용, false면 새로 생성
+ */
+export function createRes(reusable = true) {
+    if (reusable) {
+        // sync: 공유 인스턴스 리셋 후 재사용 (할당 0)
+        _sharedRes._statusCode = 200;
+        _sharedRes._body = '';
+        // headers 객체 재사용 — 이전 키 제거
+        const keys = Object.keys(_sharedHeaders);
+        for (let i = 0; i < keys.length; i++) {
+            delete _sharedHeaders[keys[i]];
+        }
+        _sharedRes._headers = _sharedHeaders;
+        _sharedRes._sent = false;
+        return _sharedRes;
+    }
+
+    // async: 새 인스턴스
+    const res = Object.create(ResProto);
+    res._statusCode = 200;
+    res._body = '';
+    res._headers = {};
+    res._sent = false;
+    return res;
+}

package/lib/crypto.js

@@ -1,23 +1,23 @@
-/**
- * Crypto — fuzionx-bridge ASP crypto N-API를 래핑하는 헬퍼.
- * app.crypto로 접근.
- */
-
-export function createCrypto(bridge) {
-    return {
-        /** UUID v4 생성 */
-        uuid: () => bridge.cryptoUuid(),
-
-        /** MD5 해시 */
-        md5: (input) => bridge.cryptoMd5(input),
-
-        /** SHA-256 해시 */
-        sha256: (input) => bridge.cryptoSha256(input),
-
-        /** AES-256-GCM 암호화 */
-        encrypt: (key, plaintext) => bridge.cryptoEncryptAes(key, plaintext),
-
-        /** AES-256-GCM 복호화 */
-        decrypt: (key, ciphertext) => bridge.cryptoDecryptAes(key, ciphertext),
-    };
-}
+/**
+ * Crypto — fuzionx-bridge ASP crypto N-API를 래핑하는 헬퍼.
+ * app.crypto로 접근.
+ */
+
+export function createCrypto(bridge) {
+    return {
+        /** UUID v4 생성 */
+        uuid: () => bridge.cryptoUuid(),
+
+        /** MD5 해시 */
+        md5: (input) => bridge.cryptoMd5(input),
+
+        /** SHA-256 해시 */
+        sha256: (input) => bridge.cryptoSha256(input),
+
+        /** AES-256-GCM 암호화 */
+        encrypt: (key, plaintext) => bridge.cryptoEncryptAes(key, plaintext),
+
+        /** AES-256-GCM 복호화 */
+        decrypt: (key, ciphertext) => bridge.cryptoDecryptAes(key, ciphertext),
+    };
+}

package/lib/file.js

@@ -1,34 +1,34 @@
-/**
- * FileHelper — fuzionx-bridge 파일 유틸리티 N-API 래핑.
- * app.file로 접근.
- *
- * 최적화: 모든 호출은 Rust N-API 직통, JS 오버헤드 없음.
- */
-
-export function createFile(bridge) {
-    return {
-        /** 파일 이동 (cross-device 자동 대응) */
-        move: (src, dst) => bridge.fileMoveFile(src, dst),
-
-        /** 파일 복사 — 복사된 바이트 수 반환 */
-        copy: (src, dst) => bridge.fileCopyFile(src, dst),
-
-        /** 디렉토리 재귀 생성 */
-        ensureDir: (dirPath) => bridge.fileEnsureDir(dirPath),
-
-        /** 파일 크기 (bytes) */
-        size: (filePath) => bridge.fileSize(filePath),
-
-        /** 파일 존재 여부 */
-        exists: (filePath) => bridge.fileExists(filePath),
-
-        /** 파일 삭제 */
-        remove: (filePath) => bridge.fileRemove(filePath),
-
-        /** 임시 파일 경로 생성 (UUID 기반) */
-        tempPath: (prefix) => bridge.fileTempPath(prefix || 'fuzionx'),
-
-        /** 확장자 추출 (소문자, dot 제외) — null 가능 */
-        extension: (filePath) => bridge.fileExtension(filePath),
-    };
-}
+/**
+ * FileHelper — fuzionx-bridge 파일 유틸리티 N-API 래핑.
+ * app.file로 접근.
+ *
+ * 최적화: 모든 호출은 Rust N-API 직통, JS 오버헤드 없음.
+ */
+
+export function createFile(bridge) {
+    return {
+        /** 파일 이동 (cross-device 자동 대응) */
+        move: (src, dst) => bridge.fileMoveFile(src, dst),
+
+        /** 파일 복사 — 복사된 바이트 수 반환 */
+        copy: (src, dst) => bridge.fileCopyFile(src, dst),
+
+        /** 디렉토리 재귀 생성 */
+        ensureDir: (dirPath) => bridge.fileEnsureDir(dirPath),
+
+        /** 파일 크기 (bytes) */
+        size: (filePath) => bridge.fileSize(filePath),
+
+        /** 파일 존재 여부 */
+        exists: (filePath) => bridge.fileExists(filePath),
+
+        /** 파일 삭제 */
+        remove: (filePath) => bridge.fileRemove(filePath),
+
+        /** 임시 파일 경로 생성 (UUID 기반) */
+        tempPath: (prefix) => bridge.fileTempPath(prefix || 'fuzionx'),
+
+        /** 확장자 추출 (소문자, dot 제외) — null 가능 */
+        extension: (filePath) => bridge.fileExtension(filePath),
+    };
+}

package/lib/hash.js

@@ -1,22 +1,22 @@
-/**
- * HashHelper — fuzionx-bridge 해싱 유틸리티 N-API 래핑.
- * app.hash로 접근.
- *
- * 최적화: Rust bcrypt/argon2 직통 호출, JS crypto 미사용.
- */
-
-export function createHash(bridge) {
-    return {
-        /** bcrypt 해시 생성 (cost 기본 12) */
-        bcrypt: (password, cost) => bridge.hashBcrypt(password, cost),
-
-        /** bcrypt 해시 검증 */
-        bcryptVerify: (password, hash) => bridge.hashBcryptVerify(password, hash),
-
-        /** argon2id 해시 생성 (랜덤 salt) */
-        argon2: (password) => bridge.hashArgon2(password),
-
-        /** argon2 해시 검증 */
-        argon2Verify: (password, hash) => bridge.hashArgon2Verify(password, hash),
-    };
-}
+/**
+ * HashHelper — fuzionx-bridge 해싱 유틸리티 N-API 래핑.
+ * app.hash로 접근.
+ *
+ * 최적화: Rust bcrypt/argon2 직통 호출, JS crypto 미사용.
+ */
+
+export function createHash(bridge) {
+    return {
+        /** bcrypt 해시 생성 (cost 기본 12) */
+        bcrypt: (password, cost) => bridge.hashBcrypt(password, cost),
+
+        /** bcrypt 해시 검증 */
+        bcryptVerify: (password, hash) => bridge.hashBcryptVerify(password, hash),
+
+        /** argon2id 해시 생성 (랜덤 salt) */
+        argon2: (password) => bridge.hashArgon2(password),
+
+        /** argon2 해시 검증 */
+        argon2Verify: (password, hash) => bridge.hashArgon2Verify(password, hash),
+    };
+}