@fuzionx/framework 0.1.67 → 0.1.69

package/cli/templates/make/app-spa/views/default/spa/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@fuzionx/player": "^0.1.67",
+    "@fuzionx/player": "^0.1.69",
     "pinia": "^3.0.4",
     "vue": "^3.5.0",
     "vue-router": "^4.5.0"

package/cli/templates/make/app-spa/views/default/spa/vite.config.js

@@ -11,6 +11,8 @@ export default defineConfig({
   },
   server: {
     port: 5173,
+    /** 리버스 프록시 경유 시 cross-origin 요청 허용 */
+    cors: true,
     proxy: {
       "/api": "http://127.0.0.1:49080",
       "/wasm": "http://127.0.0.1:49080",

package/lib/core/Application.js

@@ -291,6 +291,7 @@ export default class Application {
         this.storage = new Storage({
             driver: this.config.get('storage.driver', 'local'),
             basePath: path.resolve(this.baseDir, this.config.get('storage.path', './storage')),
+            s3: this.config.get('storage.s3') || null,
             fileHelper: this.file,
         });
 
@@ -367,10 +368,16 @@ export default class Application {
         this._booted = true;
 
         // hostname → appName 매핑 사전 계산 (매 요청 O(1) 조회)
+        // host:port 키와 hostname-only 키 모두 저장 (포트 제거 조회 호환)
         this._hostAppMap = new Map();
         const appsConfig = this.config.get('apps') || {};
-        for (const [hostname, appName] of Object.entries(appsConfig)) {
-            this._hostAppMap.set(hostname, appName);
+        for (const [hostKey, appName] of Object.entries(appsConfig)) {
+            this._hostAppMap.set(hostKey, appName);
+            /** 포트 제거한 hostname도 등록 (중복 시 마지막 우선) */
+            const hostnameOnly = hostKey.split(':')[0];
+            if (hostnameOnly !== hostKey) {
+                this._hostAppMap.set(hostnameOnly, appName);
+            }
         }
 
         await this.emit('booted');
@@ -402,23 +409,28 @@ export default class Application {
     /**
      * 호스트 → 앱 이름 결정
      * reverse proxy 경유 시 X-Forwarded-Host 우선 사용.
+     * 매핑되지 않은 도메인은 null 반환 (접근 차단).
      * @param {string} host - 요청 Host 헤더 (port 포함 가능)
      * @param {object} [headers] - 전체 요청 헤더 (proxy 지원)
-     * @returns {string} 앱 이름
+     * @returns {string|null} 앱 이름 또는 null (미등록 도메인)
      */
     _resolveApp(host, headers) {
         // reverse proxy: X-Forwarded-Host > X-Original-Host > Host
         const forwardedHost = headers?.['x-forwarded-host'] || headers?.['X-Forwarded-Host']
             || headers?.['x-original-host'] || headers?.['X-Original-Host'];
         const rawHost = forwardedHost || host || '';
-        const hostname = rawHost.split(':')[0]; // 포트 제거
 
-        // 사전 계산된 Map O(1) 조회
-        const mapped = this._hostAppMap?.get(hostname);
-        if (mapped) return mapped;
+        // 1차: host:port 포함 전체 키로 조회
+        const fullMatch = this._hostAppMap?.get(rawHost);
+        if (fullMatch) return fullMatch;
+
+        // 2차: 포트 제거 hostname-only 조회
+        const hostname = rawHost.split(':')[0];
+        const hostMatch = this._hostAppMap?.get(hostname);
+        if (hostMatch) return hostMatch;
 
-        // 매칭 없으면 기본 앱
-        return this._getDefaultAppName();
+        // 매칭 없음 → null (미등록 도메인 접근 차단)
+        return null;
     }
 
     /**
@@ -753,17 +765,35 @@ export default class Application {
             return { status: 404, body: '{"error":"Not Found"}', headers: { 'Content-Type': 'application/json' } };
         }
 
+        // ── 도메인 검증 (모든 요청에 대해 수행) ──
+        const host = rawReq.headers?.host || '';
+        const resolvedAppName = this._resolveApp(host, rawReq.headers);
+
+        // 미등록 도메인 → 403 차단
+        if (!resolvedAppName) {
+            const reqHost = rawReq.headers?.host || 'unknown';
+            return {
+                status: 403,
+                body: JSON.stringify({ error: 'Forbidden', message: `도메인 '${reqHost}'은(는) 등록되지 않았습니다.` }),
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            };
+        }
+
         // ── 앱 결정 (단일 앱: O(0), 멀티앱: Host 기반) ──
         let appName, entry;
         if (dispatch.isSingleApp) {
             appName = dispatch.singleAppName;
             entry = dispatch.singleEntry;
         } else {
-            const host = rawReq.headers?.host || '';
-            appName = this._resolveApp(host, rawReq.headers);
+            appName = resolvedAppName;
             entry = dispatch.appMap.get(appName);
-            if (!entry) entry = dispatch.appMap.get(this._getDefaultAppName());
-            if (!entry) entry = dispatch.appMap.values().next().value;
+            if (!entry) {
+                return {
+                    status: 403,
+                    body: JSON.stringify({ error: 'Forbidden', message: `앱 '${appName}'을(를) 찾을 수 없습니다.` }),
+                    headers: { 'Content-Type': 'application/json; charset=utf-8' },
+                };
+            }
         }
 
         const { middlewareFns, resolvedHandler } = entry;

package/lib/core/AutoLoader.js

@@ -87,7 +87,7 @@ export default class AutoLoader {
             const mod = await import(pathToFileURL(file).href);
             const ModelClass = mod.default;
             if (!ModelClass) continue;
-            const name = extractName(file);
+            const name = extractName(file, 'Model');
             if (this.app.db) {
                 this.app.db.register(name, ModelClass);
             }

package/lib/database/Model.js

@@ -104,7 +104,7 @@ export default class Model {
     }
 
     /**
-     * JSON 직렬화 — hidden 필드 제외
+     * JSON 직렬화 — hidden 필드 제외 + 로드된 관계 + 동적 필드 포함
      * @returns {object}
      */
     toJSON() {
@@ -113,9 +113,43 @@ export default class Model {
         for (const key of hidden) {
             delete obj[key];
         }
+
+        // with()로 로드된 관계 데이터 포함
+        const relations = this.constructor.relations || {};
+        for (const relName of Object.keys(relations)) {
+            if (this[relName] !== undefined) {
+                const val = this[relName];
+                if (Array.isArray(val)) {
+                    // hasMany: 배열 내 각 모델 인스턴스를 직렬화
+                    obj[relName] = val.map(v => v?.toJSON ? v.toJSON() : v);
+                } else if (val?.toJSON) {
+                    // hasOne/belongsTo: 단일 모델 인스턴스 직렬화
+                    obj[relName] = val.toJSON();
+                } else {
+                    obj[relName] = val;
+                }
+            }
+        }
+
+        // 동적으로 추가된 필드 포함 (e.g. sub_reseller_count, sub_member_count)
+        if (this._extras) {
+            Object.assign(obj, this._extras);
+        }
+
         return obj;
     }
 
+    /**
+     * 동적 필드 추가 — toJSON() 직렬화에 포함됨
+     *
+     * @param {string} key - 필드명
+     * @param {*} value - 값
+     */
+    setExtra(key, value) {
+        if (!this._extras) this._extras = {};
+        this._extras[key] = value;
+    }
+
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     //  관계 (스텁 — 서브클래스에서 오버라이드)
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/lib/database/SqlQueryBuilder.js

@@ -350,21 +350,23 @@ export default class SqlQueryBuilder extends QueryBuilder {
      */
     async _loadRelations(results) {
         const modelRelations = this._model.relations || {};
-
+        
         for (const relName of this._withs) {
             const rel = modelRelations[relName];
-            if (!rel) continue; // 정의되지 않은 관계는 무시
+            if (!rel) {                
+                continue;
+            }
 
             // 관계 대상 모델 클래스 resolve (문자열 → ModelRegistry에서 찾기)
             let RelatedModel = rel.model;
             if (typeof RelatedModel === 'string') {
                 // SqlModel._modelRegistry를 통해 모델 클래스 resolve
                 const registry = this._model._modelRegistry || this._model.constructor._modelRegistry;
-                if (registry) {
-                    RelatedModel = registry.get(rel.model);
+                                if (registry) {
+                    RelatedModel = registry.get(rel.model);                    
                 }
-                if (!RelatedModel || typeof RelatedModel === 'string') {
-                    continue; // resolve 실패 시 스킵
+                if (!RelatedModel || typeof RelatedModel === 'string') {                    
+                    continue;
                 }
             }
 

package/lib/services/Storage.js

@@ -1,29 +1,70 @@
 /**
- * Storage — 파일 저장 추상화 (Local / S3)
+ * Storage — 파일 저장 추상화 (Local / S3 / R2)
  *
  * put(path, tempPath) — 임시파일 → 최종 위치 이동.
  * Local: file.move(tempPath, fullPath)
- * S3: Node.js 스트리밍 업로드 (큐 Task 권장)
+ * S3/R2: Node.js 스트리밍 업로드
+ *
+ * S3 호환 스토리지 지원:
+ * - AWS S3
+ * - Cloudflare R2 (egress 무료, endpoint 지정 필요)
+ * - MinIO, DigitalOcean Spaces 등
  *
  * @see docs/framework/15-file-upload.md
  * @see docs/framework/class-design.mm.md (Storage)
  */
-import { promises as fs } from 'node:fs';
+import { promises as fs, createReadStream } from 'node:fs';
 import path from 'node:path';
 
+/**
+ * @aws-sdk/client-s3 — Optional Dependency
+ * S3 호환 스토리지(AWS S3, Cloudflare R2, MinIO 등) 사용 시에만 필요.
+ * 로컬 드라이버만 사용하면 설치할 필요 없음.
+ */
+import {
+    S3Client,
+    PutObjectCommand,
+    GetObjectCommand,
+    DeleteObjectCommand,
+    HeadObjectCommand,
+} from '@aws-sdk/client-s3';
+
 export default class Storage {
     /**
      * @param {object} opts
      * @param {string} [opts.driver='local'] - 'local' | 's3'
      * @param {string} [opts.basePath='./storage'] - 로컬 저장 경로
-     * @param {object} [opts.s3] - S3 설정 { bucket, region, credentials }
+     * @param {object} [opts.s3] - S3/R2 설정
+     * @param {string} opts.s3.bucket - 버킷명
+     * @param {string} [opts.s3.region='auto'] - 리전 (R2는 'auto')
+     * @param {string} [opts.s3.endpoint] - 커스텀 엔드포인트 (R2: https://<ACCOUNT_ID>.r2.cloudflarestorage.com)
+     * @param {string} [opts.s3.publicUrl] - 퍼블릭 액세스 URL (R2 커스텀 도메인 등)
+     * @param {object} [opts.s3.credentials] - { accessKeyId, secretAccessKey }
      * @param {import('./FileHelper.js').default} [opts.fileHelper] - FileHelper 인스턴스
      */
     constructor(opts = {}) {
         this.driver = opts.driver || 'local';
         this.basePath = opts.basePath || './storage';
-        this._s3 = opts.s3 || null;
         this._file = opts.fileHelper || null;
+
+        // YAML snake_case → JS camelCase 정규화
+        const s3Raw = opts.s3 || null;
+        if (s3Raw) {
+            const creds = s3Raw.credentials || null;
+            this._s3 = {
+                bucket:         s3Raw.bucket,
+                region:         s3Raw.region || 'auto',
+                endpoint:       s3Raw.endpoint || null,
+                publicUrl:      s3Raw.public_url || s3Raw.publicUrl || null,
+                forcePathStyle: s3Raw.force_path_style ?? s3Raw.forcePathStyle ?? false,
+                credentials:    creds ? {
+                    accessKeyId:     creds.access_key_id || creds.accessKeyId,
+                    secretAccessKey: creds.secret_access_key || creds.secretAccessKey,
+                } : null,
+            };
+        } else {
+            this._s3 = null;
+        }
     }
 
     /**
@@ -99,14 +140,136 @@ export default class Storage {
      */
     url(filePath) {
         if (this.driver === 's3' && this._s3) {
-            return `https://${this._s3.bucket}.s3.${this._s3.region}.amazonaws.com/${filePath}`;
+            // 커스텀 퍼블릭 URL (R2 커스텀 도메인, CDN 등)
+            if (this._s3.publicUrl) {
+                return `${this._s3.publicUrl.replace(/\/$/, '')}/${filePath}`;
+            }
+            // AWS S3 기본 URL
+            return `https://${this._s3.bucket}.s3.${this._s3.region || 'us-east-1'}.amazonaws.com/${filePath}`;
         }
         return `/storage/${filePath}`;
     }
 
-    // ── S3 스텁 (Phase 5+ 구현) ──
-    async _s3Put(filePath, tempPath) { throw new Error('S3 driver not implemented'); }
-    async _s3Get(filePath) { throw new Error('S3 driver not implemented'); }
-    async _s3Delete(filePath) { throw new Error('S3 driver not implemented'); }
-    async _s3Exists(filePath) { throw new Error('S3 driver not implemented'); }
+    // ── S3 호환 스토리지 구현 (@aws-sdk/client-s3) ──
+    // AWS S3, Cloudflare R2, MinIO, DigitalOcean Spaces 등 지원
+
+    /**
+     * S3Client 지연 초기화.
+     * 최초 호출 시 Client 생성, 이후 캐싱.
+     *
+     * 지원 스토리지:
+     * - AWS S3: region만 지정
+     * - Cloudflare R2: endpoint + region='auto'
+     * - MinIO/Spaces: endpoint + forcePathStyle=true
+     *
+     * @returns {S3Client}
+     * @private
+     */
+    _getClient() {
+        if (this._s3Client) return this._s3Client;
+        if (!this._s3) throw new Error('S3 설정이 없습니다. opts.s3 = { bucket, region, credentials }');
+
+        /** @type {import('@aws-sdk/client-s3').S3ClientConfig} 클라이언트 설정 */
+        const config = {
+            region: this._s3.region || 'auto', // R2는 'auto', AWS는 'ap-northeast-2' 등
+            credentials: this._s3.credentials || undefined, // IAM Role이면 생략
+        };
+
+        // 커스텀 엔드포인트 (R2, MinIO, DigitalOcean Spaces 등)
+        if (this._s3.endpoint) {
+            config.endpoint = this._s3.endpoint;
+            config.forcePathStyle = this._s3.forcePathStyle ?? false; // R2=false, MinIO=true
+        }
+
+        this._s3Client = new S3Client(config);
+        return this._s3Client;
+    }
+
+    /**
+     * 파일 업로드 (임시파일 → Object Storage).
+     *
+     * @param {string} filePath - Object Key (e.g. 'uploads/avatar.jpg')
+     * @param {string} tempPath - 로컬 임시 파일 경로
+     * @returns {Promise<string>} - 저장된 URL
+     * @private
+     */
+    async _s3Put(filePath, tempPath) {
+        const client = this._getClient();
+
+        const stream = createReadStream(tempPath); // 파일 스트림으로 업로드 (메모리 절약)
+        await client.send(new PutObjectCommand({
+            Bucket: this._s3.bucket,
+            Key: filePath,
+            Body: stream,
+        }));
+
+        // 업로드 완료 후 임시파일 삭제
+        await fs.unlink(tempPath).catch(() => {});
+
+        return this.url(filePath);
+    }
+
+    /**
+     * 파일 읽기 (Object Storage → Buffer).
+     *
+     * @param {string} filePath - Object Key
+     * @returns {Promise<Buffer>}
+     * @private
+     */
+    async _s3Get(filePath) {
+        const client = this._getClient();
+
+        const res = await client.send(new GetObjectCommand({
+            Bucket: this._s3.bucket,
+            Key: filePath,
+        }));
+
+        // Body는 ReadableStream — Buffer로 변환
+        const chunks = [];
+        for await (const chunk of res.Body) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+
+    /**
+     * 파일 삭제.
+     *
+     * @param {string} filePath - Object Key
+     * @returns {Promise<void>}
+     * @private
+     */
+    async _s3Delete(filePath) {
+        const client = this._getClient();
+
+        await client.send(new DeleteObjectCommand({
+            Bucket: this._s3.bucket,
+            Key: filePath,
+        }));
+    }
+
+    /**
+     * 파일 존재 여부 확인 (HeadObject).
+     *
+     * @param {string} filePath - Object Key
+     * @returns {Promise<boolean>}
+     * @private
+     */
+    async _s3Exists(filePath) {
+        const client = this._getClient();
+
+        try {
+            await client.send(new HeadObjectCommand({
+                Bucket: this._s3.bucket,
+                Key: filePath,
+            }));
+            return true;
+        } catch (err) {
+            if (err.name === 'NotFound' || err.$metadata?.httpStatusCode === 404) {
+                return false;
+            }
+            throw err; // 권한 오류 등은 그대로 throw
+        }
+    }
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzionx/framework",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "type": "module",
   "description": "Full-stack MVC framework built on @fuzionx/core — Controller, Service, Model, Middleware, DI, EventBus",
   "main": "index.js",
@@ -34,7 +34,8 @@
     "url": "https://github.com/saytohenry/fuzionx"
   },
   "dependencies": {
-    "@fuzionx/core": "^0.1.67",
+    "@aws-sdk/client-s3": "^3.1028.0",
+    "@fuzionx/core": "^0.1.69",
     "better-sqlite3": "^12.8.0",
     "knex": "^3.2.5",
     "mongoose": "^9.3.2",