@fuzionx/framework 0.1.66 → 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.66",
+    "@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/index.js

@@ -65,4 +65,4 @@ export { default as OpenAPI } from './lib/view/OpenAPI.js';
 export { PaginationUtil, StrUtil, NumUtil, DateUtil, ArrUtil, FunctionUtil, ObjectUtil } from './lib/utilities/index.js';
 
 // ── Built-in Middleware ──
-export { bodyParser, cors, auth, apiAuth, csrf, session, theme, loadUser, roleGuard } from './lib/middleware/index.js';
+export { bodyParser, cors, auth, apiAuth, csrf, session, loadUser } from './lib/middleware/index.js';

package/lib/core/Application.js

@@ -103,6 +103,7 @@ export default class Application {
             fallback: this.config.get('app.i18n.fallback', 'en'),
             dir: this.config.get('app.i18n.dir', './locales'),
             bridge: this._bridge,
+            autoComplete: this.config.get('app.i18n.auto_complete', false),
         });
         this.storage = null;
         this._scheduler = null;
@@ -290,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,
         });
 
@@ -366,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');
@@ -401,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;
     }
 
     /**
@@ -752,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/helpers/I18nHelper.js

@@ -4,12 +4,18 @@
  * Bridge의 i18NTranslate(locale, key) 직접 호출.
  * Bridge 없으면 JS 파일 기반 폴백.
  *
+ * auto_complete 활성 시 fs.watch로 locale 파일 변경을 감지하여
+ * 디바운스 후 자동 동기화한다. (매 요청마다 파일 I/O 없음)
+ *
  * @see docs/framework/18-i18n.md
  * @see packages/fuzionx/lib/i18n.js (Core 래퍼 참조)
  */
-import { promises as fs } from 'node:fs';
+import { promises as fs, readFileSync, watch as fsWatch, existsSync } from 'node:fs';
 import path from 'node:path';
 
+/** 디바운스 기본 대기 시간 (ms) */
+const RELOAD_DEBOUNCE_MS = 500;
+
 export default class I18nHelper {
     /**
      * @param {object} [opts]
@@ -17,18 +23,24 @@ export default class I18nHelper {
      * @param {string} [opts.fallback='en']
      * @param {string} [opts.dir='./locales']
      * @param {object} [opts.bridge] - Bridge N-API 인스턴스
+     * @param {boolean} [opts.autoComplete=false] - auto_complete 활성 시 파일 감시
      */
     constructor(opts = {}) {
         this.defaultLocale = opts.defaultLocale || 'ko';
         this.fallback = opts.fallback || 'en';
         this.dir = opts.dir || './locales';
         this._bridge = opts.bridge || null;
-        this._messages = new Map(); // locale → { flat key: value }
+        this._autoComplete = !!opts.autoComplete;
+        this._messages = new Map();     // locale → { flat key: value }
         this._loaded = false;
+        this._watcher = null;           // fs.watch 인스턴스
+        this._reloadTimer = null;       // 디바운스 타이머
+        this._dirtyLocales = new Set(); // 변경된 locale 큐
     }
 
     /**
-     * 번역 파일 로드 (JS 폴백용)
+     * 번역 파일 로드 (JS 폴백용).
+     * auto_complete가 활성이면 locale 디렉토리 감시 시작.
      */
     async load() {
         if (this._loaded) return;
@@ -45,6 +57,11 @@ export default class I18nHelper {
             }
         } catch {} // locales/ 없으면 무시
         this._loaded = true;
+
+        // auto_complete 활성 시 파일 감시 시작
+        if (this._autoComplete) {
+            this._startWatcher();
+        }
     }
 
     /**
@@ -86,12 +103,30 @@ export default class I18nHelper {
     }
 
     /**
-     * 전체 locale 데이터 반환 (뷰 주입용)
+     * 전체 locale 데이터 반환 (뷰 주입용).
+     *
+     * Bridge가 있으면 i18NGetTranslations N-API로 최신 데이터를 직접 반환.
+     * Bridge 없으면 JS _messages 폴백.
+     *
      * @param {string} locale
-     * @returns {object}
+     * @returns {object} flat dot-notation 번역 데이터
      */
     all(locale) {
-        const messages = this._messages.get(locale) || this._messages.get(this.defaultLocale);
+        const target = locale || this.defaultLocale;
+
+        /** Bridge 우선 — 메모리에서 직접 최신 데이터 반환 */
+        if (this._bridge && typeof this._bridge.i18NGetTranslations === 'function') {
+            try {
+                const json = this._bridge.i18NGetTranslations(target);
+                if (json) {
+                    const data = JSON.parse(json);
+                    return this._flatten(data); // nested → flat dot-notation
+                }
+            } catch {} // Bridge 실패 시 JS 폴백
+        }
+
+        /** JS 폴백 — _messages 캐시 사용 */
+        const messages = this._messages.get(target) || this._messages.get(this.defaultLocale);
         if (!messages) return {};
         return { ...messages };
     }
@@ -121,6 +156,75 @@ export default class I18nHelper {
         }
     }
 
+    // ──────────────────────────────────────────
+    //  파일 감시 & 디바운스 동기화
+    // ──────────────────────────────────────────
+
+    /**
+     * locale 디렉토리를 fs.watch로 감시 시작.
+     * JSON 파일 변경 감지 시 해당 locale을 dirty 큐에 넣고
+     * 디바운스 타이머 후 일괄 동기화.
+     * @private
+     */
+    _startWatcher() {
+        if (!existsSync(this.dir)) return;
+        try {
+            this._watcher = fsWatch(this.dir, (eventType, filename) => {
+                // .json 파일 변경만 감시
+                if (!filename || !filename.endsWith('.json')) return;
+                const locale = path.basename(filename, '.json');
+                this._dirtyLocales.add(locale); // 큐에 추가
+
+                // 디바운스: 기존 타이머 취소 → 새로 시작
+                clearTimeout(this._reloadTimer);
+                this._reloadTimer = setTimeout(() => {
+                    this._flushDirty();
+                }, RELOAD_DEBOUNCE_MS);
+            });
+        } catch {} // 감시 실패 시 무시 (기존 동작 유지)
+    }
+
+    /**
+     * dirty 큐에 쌓인 locale 파일들을 일괄 동기 재로드.
+     * @private
+     */
+    _flushDirty() {
+        if (this._dirtyLocales.size === 0) return;
+        for (const locale of this._dirtyLocales) {
+            this._syncReload(locale);
+        }
+        this._dirtyLocales.clear();
+    }
+
+    /**
+     * 단일 locale 파일을 동기적으로 재로드.
+     * @param {string} locale - 로드할 locale (예: 'ko', 'en')
+     * @private
+     */
+    _syncReload(locale) {
+        try {
+            const jsonPath = path.join(this.dir, `${locale}.json`);
+            const content = readFileSync(jsonPath, 'utf-8');
+            const data = JSON.parse(content);
+            this._messages.set(locale, this._flatten(data));
+        } catch {} // 파일 없으면 무시
+    }
+
+    /**
+     * 감시자 정리 (graceful shutdown 용)
+     */
+    destroy() {
+        if (this._watcher) {
+            this._watcher.close();
+            this._watcher = null;
+        }
+        clearTimeout(this._reloadTimer);
+    }
+
+    // ──────────────────────────────────────────
+    //  파서 유틸리티
+    // ──────────────────────────────────────────
+
     /** {field} → value 치환 */
     _substitute(template, vars) {
         if (!vars || typeof template !== 'string') return template;

package/lib/middleware/index.js

@@ -1,5 +1,8 @@
 /**
- * 내장 미들웨어 — 배럴 re-export
+ * 내장 미들웨어 — 배럴 re-export (공용)
+ *
+ * 앱 전용 미들웨어(theme, roleGuard 등)는
+ * 각 앱의 middleware/ 폴더에서 직접 구현합니다.
  *
  * @see docs/framework/12-middleware.md
  * @see docs/framework/14-authentication.md
@@ -10,6 +13,4 @@ export { auth } from './auth.js';
 export { apiAuth } from './apiAuth.js';
 export { csrf } from './csrf.js';
 export { session } from './session.js';
-export { theme } from './theme.js';
 export { loadUser } from './loadUser.js';
-export { roleGuard } from './roleGuard.js';

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.66",
+  "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.66",
+    "@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",