@fuzionx/framework 0.1.45 → 0.1.47

package/cli/templates/make/app-ssr/public/js/fx-client.js

@@ -0,0 +1,107 @@
+/**
+ * FuzionX SSR Client — WASM ASP HTTP + WebSocket 통합 클라이언트
+ *
+ * create-fuzionx tester 레이아웃 패턴 기반.
+ * WASM 로드 → FuzionXClient, FuzionXSocket, aspFetch 글로벌 노출.
+ *
+ * 사용법 (인증 유저):
+ *   FxClient.init(clientSecret, encSecret, headerSignal)
+ *
+ * 사용법 (공개 페이지):
+ *   FxClient.initPublic(masterSecret, headerSignal)
+ */
+(function () {
+  'use strict';
+
+  /**
+   * 인증 유저용 — 암호화된 masterSecret 복호화 후 ASP 클라이언트 생성
+   */
+  function init(clientSecret, encSecret, headerSignal) {
+    if (!clientSecret || !encSecret) return;
+
+    window.aspEnabled = true;
+    window._aspReady = (async () => {
+      try {
+        const _v = Date.now();
+        const mod = await import(`/wasm/fuzionx_client_wasm.js?v=${_v}`);
+        await mod.default({ module_or_path: `/wasm/fuzionx_client_wasm_bg.wasm?v=${_v}` });
+        const { FuzionXClient, FuzionXSocket } = mod;
+        window.FuzionXSocket = FuzionXSocket;
+
+        // 임시 클라이언트로 masterSecret 복호화
+        const tmp = new FuzionXClient('_init_');
+        const masterSecret = tmp.decrypt_custom(clientSecret, encSecret);
+        window._aspMasterSecret = masterSecret;
+
+        // ASP 활성 클라이언트 생성
+        window._aspClient = FuzionXClient.new_with_options(
+          masterSecret,
+          headerSignal || 'Ruxy-Enc-Mode',
+        );
+        console.log('[FxClient] WASM ASP client ready');
+      } catch (e) {
+        console.warn('[FxClient] WASM init failed:', e);
+      }
+    })();
+  }
+
+  /**
+   * 공개 페이지용 — masterSecret 직접 사용
+   */
+  function initPublic(masterSecret, headerSignal) {
+    window.aspEnabled = !!masterSecret;
+    if (masterSecret) window._aspMasterSecret = masterSecret;
+
+    window._aspReady = (async () => {
+      try {
+        const _v = Date.now();
+        const mod = await import(`/wasm/fuzionx_client_wasm.js?v=${_v}`);
+        await mod.default({ module_or_path: `/wasm/fuzionx_client_wasm_bg.wasm?v=${_v}` });
+        const { FuzionXClient, FuzionXSocket } = mod;
+        window.FuzionXSocket = FuzionXSocket;
+
+        if (masterSecret) {
+          window._aspClient = FuzionXClient.new_with_options(
+            masterSecret,
+            headerSignal || 'Ruxy-Enc-Mode',
+          );
+        }
+        console.log('[FxClient] WASM client ready (public)');
+      } catch (e) {
+        console.warn('[FxClient] WASM init failed:', e);
+      }
+    })();
+  }
+
+  /**
+   * ASP 암호화 fetch — create-fuzionx tester aspFetch 동일 패턴
+   */
+  window.aspFetch = async function (url, opts = {}) {
+    if (window._aspReady) await window._aspReady;
+    const method = (opts.method || 'GET').toUpperCase();
+    if (!url.startsWith('/api') || !window._aspClient) return fetch(url, opts);
+
+    if (opts.body instanceof FormData) {
+      return window._aspClient.upload(url, opts.body);
+    }
+
+    let bodyObj = undefined;
+    if (opts.body) {
+      bodyObj = typeof opts.body === 'string' ? JSON.parse(opts.body) : opts.body;
+    }
+
+    switch (method) {
+      case 'GET':    return window._aspClient.get(url, window.__FX__ENC_ENABLED);
+      case 'POST':   return window._aspClient.post(url, bodyObj, window.__FX__ENC_ENABLED);
+      case 'PUT':    return window._aspClient.put(url, bodyObj, window.__FX__ENC_ENABLED);
+      case 'PATCH':  return window._aspClient.patch(url, bodyObj, window.__FX__ENC_ENABLED);
+      case 'DELETE': return window._aspClient.delete(url, window.__FX__ENC_ENABLED);
+      default:       return window._aspClient.get(url, window.__FX__ENC_ENABLED);
+    }
+  };
+
+  // 글로벌 노출
+  window.FxClient = { init, initPublic };
+  window.aspEnabled = window.__FX__ENC_ENABLED;
+  window._aspReady = Promise.resolve();
+})();

package/cli/templates/make/app-ssr/public/js/fx-ui.js

@@ -0,0 +1,124 @@
+/**
+ * FuzionX SSR Toast & Alert Utilities
+ * 
+ * SSR 템플릿에서 사용하는 바닐라 JS toast / alert.
+ * main.html 레이아웃에 include하면 전역 사용 가능.
+ * 
+ * @example
+ * fxToast.success('저장되었습니다!');
+ * fxToast.error('오류가 발생했습니다.');
+ * fxAlert.confirm('삭제', '정말 삭제하시겠습니까?').then(ok => { ... });
+ */
+(function() {
+  'use strict';
+
+  // ── Toast ──────────────────────
+  var container = null;
+  var _id = 0;
+  var icons = { success: '✓', error: '✕', warning: '⚠', info: 'ℹ' };
+
+  function getContainer() {
+    if (!container) {
+      container = document.createElement('div');
+      container.className = 'fx-toast-container';
+      document.body.appendChild(container);
+    }
+    return container;
+  }
+
+  function showToast(opts) {
+    var config = typeof opts === 'string' ? { message: opts } : opts;
+    var type = config.type || 'info';
+    var duration = config.duration !== undefined ? config.duration : 3000;
+    var id = ++_id;
+
+    var el = document.createElement('div');
+    el.className = 'fx-toast fx-toast-' + type;
+    el.setAttribute('data-toast-id', id);
+    el.innerHTML =
+      '<span class="fx-toast-icon">' + (icons[type] || icons.info) + '</span>' +
+      '<span class="fx-toast-msg">' + (config.message || '') + '</span>' +
+      '<button class="fx-toast-close">&times;</button>';
+    el.style.animation = 'toastIn 0.3s ease-out';
+
+    el.querySelector('.fx-toast-close').onclick = function(e) {
+      e.stopPropagation();
+      dismissToast(el);
+    };
+    el.onclick = function() { dismissToast(el); };
+
+    getContainer().appendChild(el);
+
+    if (duration > 0) {
+      setTimeout(function() { dismissToast(el); }, duration);
+    }
+    return id;
+  }
+
+  function dismissToast(el) {
+    if (!el || !el.parentNode) return;
+    el.style.animation = 'toastOut 0.25s ease-in forwards';
+    setTimeout(function() { if (el.parentNode) el.parentNode.removeChild(el); }, 250);
+  }
+
+  window.fxToast = {
+    show: showToast,
+    success: function(msg, dur) { return showToast({ message: msg, type: 'success', duration: dur }); },
+    error: function(msg, dur) { return showToast({ message: msg, type: 'error', duration: dur }); },
+    info: function(msg, dur) { return showToast({ message: msg, type: 'info', duration: dur }); },
+    warning: function(msg, dur) { return showToast({ message: msg, type: 'warning', duration: dur }); },
+  };
+
+  // ── Alert ──────────────────────
+  function showAlert(title, message, opts) {
+    opts = opts || {};
+    return new Promise(function(resolve) {
+      var showCancel = opts.showCancel || false;
+      var type = opts.type || 'info';
+      var okText = opts.ok || '확인';
+      var cancelText = opts.cancel || '취소';
+
+      var backdrop = document.createElement('div');
+      backdrop.className = 'fx-alert-backdrop';
+      backdrop.style.animation = 'alertIn 0.25s ease-out';
+
+      var iconHtml = icons[type] || icons.info;
+
+      backdrop.innerHTML =
+        '<div class="fx-alert-dialog fx-alert-' + type + '">' +
+          (title ? '<div class="fx-alert-header"><span class="fx-alert-icon">' + iconHtml + '</span><h3 class="fx-alert-title">' + title + '</h3></div>' : '') +
+          (message ? '<p class="fx-alert-message">' + message + '</p>' : '') +
+          '<div class="fx-alert-actions">' +
+            (showCancel ? '<button class="fx-alert-btn fx-alert-cancel">' + cancelText + '</button>' : '') +
+            '<button class="fx-alert-btn fx-alert-ok">' + okText + '</button>' +
+          '</div>' +
+        '</div>';
+
+      function close(result) {
+        backdrop.style.animation = 'alertOut 0.2s ease-in forwards';
+        setTimeout(function() { if (backdrop.parentNode) backdrop.parentNode.removeChild(backdrop); }, 200);
+        resolve(result);
+      }
+
+      backdrop.querySelector('.fx-alert-ok').onclick = function() { close(true); };
+      if (showCancel) {
+        backdrop.querySelector('.fx-alert-cancel').onclick = function() { close(false); };
+      }
+      backdrop.onclick = function(e) {
+        if (e.target === backdrop && showCancel) close(false);
+      };
+
+      document.body.appendChild(backdrop);
+      backdrop.querySelector('.fx-alert-ok').focus();
+    });
+  }
+
+  window.fxAlert = {
+    show: function(title, message, opts) {
+      return showAlert(title, message, Object.assign({ showCancel: false }, opts));
+    },
+    confirm: function(title, message, opts) {
+      return showAlert(title, message, Object.assign({ showCancel: true, type: 'confirm' }, opts));
+    },
+  };
+})();

package/cli/templates/make/app-ssr/routes/web.js

@@ -0,0 +1,46 @@
+import { auth } from '@fuzionx/framework';
+import HomeController from '../controllers/HomeController.js';
+import FeaturesController from '../controllers/FeaturesController.js';
+import ChatController from '../controllers/ChatController.js';
+import AuthController from '../controllers/AuthController.js';
+import UserController from '../controllers/UserController.js';
+import PostController from '../controllers/PostController.js';
+
+export default (r) => {
+  // ── 공개 페이지 (인증 불필요) ──
+  r.get('/', HomeController.index);
+  r.get('/features', FeaturesController.index);
+
+  // ── 인증 ──
+  r.get('/login', AuthController.loginPage);
+  r.post('/login', AuthController.login);
+  r.get('/register', AuthController.registerPage);
+  r.post('/register', AuthController.register);
+  r.post('/logout', AuthController.logout);
+
+  // ── 하트비트 (세션 연장) ──
+  r.get('/api/heartbeat', AuthController.heartbeat);
+
+  // ── 인증 필요 (built-in auth 미들웨어) ──
+  r.group('', { middleware: [auth({ redirectTo: '/login' })] }, (r) => {
+    // 채팅
+    r.get('/chat', ChatController.index);
+
+    // 프로필
+    r.get('/profile', UserController.profile);
+    r.post('/profile', UserController.updateProfile);
+
+    // 게시판
+    r.get('/board', PostController.index);
+    r.get('/board/new', PostController.create);
+    r.post('/board', PostController.store);
+    r.get('/board/:id', PostController.show);
+    r.get('/board/:id/edit', PostController.edit);
+    r.post('/board/:id', PostController.update);
+    r.post('/board/:id/delete', PostController.destroy);
+    r.post('/board/attachment/:id/delete', PostController.deleteAttachment);
+
+    // 게시글 상태 API (REST 폴링용)
+    r.get('/api/board/status', PostController.status);
+  });
+};

package/cli/templates/make/app-ssr/services/AuthService.js

@@ -0,0 +1,48 @@
+import { Service } from '@fuzionx/framework';
+
+/**
+ * AuthService — SSR 인증 서비스
+ *
+ * 회원가입/로그인 비즈니스 로직 처리.
+ * bcrypt 해시를 사용한 비밀번호 암호화 및 검증.
+ *
+ * @extends Service
+ */
+export default class AuthService extends Service {
+  /**
+   * 회원가입 — 신규 사용자 생성
+   *
+   * 이메일 중복 검사 후 bcrypt 해시 비밀번호로 사용자 생성.
+   *
+   * @param {Object} data - 가입 정보
+   * @param {string} data.name     - 사용자 이름
+   * @param {string} data.email    - 이메일 주소
+   * @param {string} data.password - 비밀번호 (평문 → bcrypt 해시 변환)
+   * @returns {Promise<import('../../database/models/User.js').default>} 생성된 사용자
+   * @throws {AppError} 409 — 이메일 중복 시
+   */
+  async register({ name, email, password }) {
+    const existing = await this.db.User.where('email', email).first();
+    if (existing) throw this.error('auth.email_exists', 409);
+
+    const hash = this.app.hash.bcrypt(password);
+    return this.db.User.create({ name, email, password: hash, role: 'user' });
+  }
+
+  /**
+   * 로그인 — 이메일/비밀번호 검증
+   *
+   * 이메일로 사용자 조회 후 bcrypt 비밀번호 대조.
+   *
+   * @param {Object} credentials - 로그인 정보
+   * @param {string} credentials.email    - 이메일 주소
+   * @param {string} credentials.password - 비밀번호 (평문)
+   * @returns {Promise<import('../../database/models/User.js').default|null>} 인증된 사용자 또는 null
+   */
+  async login({ email, password }) {
+    const user = await this.db.User.where('email', email).first();
+    if (!user) return null;
+    if (!this.app.hash.bcryptVerify(password, user.password)) return null;
+    return user;
+  }
+}

package/cli/templates/make/app-ssr/services/PostService.js

@@ -0,0 +1,372 @@
+import { Service } from '@fuzionx/framework';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * PostService — SSR 게시글 + 첨부파일 + 썸네일 서비스
+ *
+ * ## 주요 기능
+ * - 게시글 CRUD (list, find, create, update, remove)
+ * - 첨부파일 저장/삭제 (Storage API)
+ * - 썸네일 자동 생성 (이미지: resize, 비디오: frame 추출)
+ *
+ * ## 썸네일 생성 전략
+ * - **이미지 파일**: `app.media.resize()` → 400x300 webp 썸네일
+ * - **비디오 파일**: `app.media.videoThumbnail()` → 3초 지점 프레임 추출 → jpeg
+ * - 썸네일은 `storage/uploads/thumbs/{attachmentId}.webp` 에 저장
+ * - Thumbnail 모델에 메타데이터(경로, 크기, 포맷, source_type) 기록
+ *
+ * ## 사용 예시
+ * ```js
+ * // 컨트롤러에서
+ * const post = await this.service('PostService').create(
+ *   { title: '제목', content: '내용', user_id: ctx.user.id },
+ *   ctx.files,   // Bridge 업로드 파일 배열
+ * );
+ *
+ * // 첨부파일 + 썸네일 조회
+ * const files = await this.service('PostService').getAttachmentsWithThumbs(post.id);
+ * // → [{ ...attachment, thumbUrl, isImage, isVideo }]
+ * ```
+ *
+ * @extends Service
+ */
+export default class PostService extends Service {
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  //  게시글 CRUD
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * 게시글 목록 조회 (페이지네이션)
+   *
+   * @param {number} [page=1]     - 현재 페이지 번호
+   * @param {number} [perPage=10] - 페이지당 게시글 수
+   * @returns {Promise<{ data: Post[], page, lastPage, hasMore, total }>}
+   */
+  async list(page = 1, perPage = 10) {
+    return this.db.Post.query()
+      .orderBy('created_at', 'desc')
+      .paginate(page, perPage);
+  }
+
+  /**
+   * 게시글 단건 조회
+   *
+   * @param {number} id - 게시글 ID
+   * @returns {Promise<Post|null>}
+   */
+  async find(id) {
+    return this.db.Post.find(id);
+  }
+
+  /**
+   * 게시글 생성 + 첨부파일 + 썸네일
+   *
+   * @param {Object} data        - { title, content, user_id }
+   * @param {Array}  [files=[]]  - Bridge 업로드 파일 배열 [{fieldName, originalName, mimeType, size, tempPath}]
+   * @returns {Promise<Post>}
+   *
+   * @example
+   * const post = await postService.create(
+   *   { title: 'Hello', content: 'World', user_id: 1 },
+   *   ctx.files,
+   * );
+   */
+  async create(data, files = []) {
+    // 비디오 포함 여부에 따라 초기 status 결정
+    const hasVideo = files?.some(f => f.mimeType?.startsWith('video/'));
+    data.status = hasVideo ? 'processing' : 'published';
+    const post = await this.db.Post.create(data);
+    if (files?.length) {
+      await this._processFiles(post.id, files);
+    }
+    return post;
+  }
+
+  /**
+   * 게시글 수정 + 새 첨부파일 추가
+   *
+   * @param {number} id         - 게시글 ID
+   * @param {Object} data       - { title, content }
+   * @param {Array}  [files=[]] - 새로 추가할 파일
+   * @returns {Promise<Post>}
+   */
+  async update(id, data, files = []) {
+    const post = await this.db.Post.find(id);
+    if (!post) throw this.error('Post not found', 404);
+    await post.update(data);
+    if (files?.length) {
+      const hasVideo = files.some(f => f.mimeType?.startsWith('video/'));
+      if (hasVideo) await post.update({ status: 'processing' });
+      await this._processFiles(post.id, files);
+    }
+    return post;
+  }
+
+  /**
+   * 게시글 삭제 + 모든 첨부파일/썸네일 삭제
+   *
+   * 삭제 순서: 썸네일 → 첨부파일(Storage + DB) → 게시글
+   *
+   * @param {number} id - 게시글 ID
+   * @returns {Promise<void>}
+   */
+  async remove(id) {
+    const post = await this.db.Post.find(id);
+    if (!post) throw this.error('Post not found', 404);
+    await this._deleteAllFiles(id);
+    await post.delete();
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  //  첨부파일 + 썸네일 조회
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * 게시글의 첨부파일 목록 + 썸네일 URL 포함
+   *
+   * 반환 객체에 추가되는 필드:
+   * - `url`      : 원본 파일 공개 URL
+   * - `thumbUrl` : 썸네일 URL (없으면 null)
+   * - `isImage`  : MIME이 image/* 인지 여부
+   * - `isVideo`  : MIME이 video/* 인지 여부
+   *
+   * @param {number} postId - 게시글 ID
+   * @returns {Promise<Array<Object>>}
+   *
+   * @example
+   * const files = await postService.getAttachmentsWithThumbs(postId);
+   * // → [{ id, original_name, url, thumbUrl, isImage, isVideo, size, mime_type }]
+   */
+  async getAttachmentsWithThumbs(postId) {
+    const attachments = await this.db.Attachment.where('post_id', postId).get();
+    if (!attachments.length) return [];
+
+    // 모든 썸네일을 한 번에 조회 (N+1 방지)
+    const attIds = attachments.map(a => a.id);
+    const thumbnails = await this.db.Thumbnail.query()
+      .whereIn('attachment_id', attIds)
+      .get();
+
+    // attachment_id → thumbnail 매핑
+    const thumbMap = new Map();
+    for (const t of thumbnails) {
+      thumbMap.set(t.attachment_id, t);
+    }
+
+    return attachments.map(att => {
+      const thumb = thumbMap.get(att.id);
+      return {
+        ...att,
+        url: this.app.storage.url(att.file_path),
+        thumbUrl: thumb ? this.app.storage.url(thumb.file_path) : null,
+        isImage: att.mime_type?.startsWith('image/'),
+        isVideo: att.mime_type?.startsWith('video/'),
+      };
+    });
+  }
+
+  /**
+   * 게시글 목록용 — 각 게시글의 대표 썸네일 1개 조회
+   *
+   * 첫 번째 첨부파일의 썸네일을 대표 이미지로 사용.
+   * 게시글 목록 페이지에서 미리보기 이미지 제공용.
+   *
+   * @param {number[]} postIds - 게시글 ID 배열
+   * @returns {Promise<Map<number, string|null>>} postId → thumbUrl
+   *
+   * @example
+   * const thumbMap = await postService.getPostThumbnails([1, 2, 3]);
+   * // → Map { 1 => '/storage/uploads/thumbs/5.webp', 2 => null, 3 => '...' }
+   */
+  async getPostThumbnails(postIds) {
+    if (!postIds.length) return new Map();
+
+    // 각 게시글의 첫 첨부파일 조회
+    const attachments = await this.db.Attachment.query()
+      .whereIn('post_id', postIds)
+      .orderBy('id', 'asc')
+      .get();
+
+    // postId → 첫 attachment 매핑
+    const firstAttMap = new Map();
+    for (const att of attachments) {
+      if (!firstAttMap.has(att.post_id)) {
+        firstAttMap.set(att.post_id, att);
+      }
+    }
+
+    // 첫 첨부파일들의 썸네일 조회
+    const attIds = [...firstAttMap.values()].map(a => a.id);
+    if (!attIds.length) return new Map();
+
+    const thumbnails = await this.db.Thumbnail.query()
+      .whereIn('attachment_id', attIds)
+      .get();
+
+    const thumbByAtt = new Map();
+    for (const t of thumbnails) {
+      thumbByAtt.set(t.attachment_id, t);
+    }
+
+    // postId → thumbUrl 매핑
+    const result = new Map();
+    for (const pid of postIds) {
+      const att = firstAttMap.get(pid);
+      if (att) {
+        const thumb = thumbByAtt.get(att.id);
+        result.set(pid, thumb ? this.app.storage.url(thumb.file_path) : null);
+      } else {
+        result.set(pid, null);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 특정 첨부파일 삭제 (썸네일 포함)
+   *
+   * @param {number} attachmentId - 첨부파일 ID
+   * @returns {Promise<void>}
+   */
+  async removeAttachment(attachmentId) {
+    const att = await this.db.Attachment.find(attachmentId);
+    if (!att) return;
+
+    // 썸네일 삭제
+    await this._deleteThumbnail(attachmentId);
+
+    // 원본 파일 삭제
+    try { await this.app.storage.delete(att.file_path); } catch {}
+    await att.delete();
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  //  Private — 파일 처리 + 썸네일 생성
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * 파일 저장 + 썸네일 생성 (이미지/비디오 자동 감지)
+   *
+   * 처리 흐름:
+   * 1. 임시파일 → Storage 영구 저장 (`uploads/posts/{postId}/xxx.ext`)
+   * 2. Attachment DB 레코드 생성
+   * 3. 이미지인 경우 → `app.media.resize()` 로 썸네일 생성
+   * 4. 비디오인 경우 → `app.media.videoThumbnail()` 로 프레임 추출
+   * 5. Thumbnail DB 레코드 생성
+   *
+   * @private
+   * @param {number} postId - 게시글 ID
+   * @param {Array}  files  - [{fieldName, originalName, mimeType, size, tempPath}]
+   */
+  async _processFiles(postId, files) {
+    for (const f of files) {
+      // 1. 원본 파일 저장
+      const ext = f.originalName.split('.').pop() || 'bin';
+      const uid = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const storagePath = `uploads/posts/${postId}/${uid}.${ext}`;
+      await this.app.storage.put(storagePath, f.tempPath);
+
+      // 2. Attachment 레코드
+      const att = await this.db.Attachment.create({
+        post_id: postId,
+        original_name: f.originalName,
+        file_path: storagePath,
+        mime_type: f.mimeType,
+        size: f.size,
+      });
+
+      // 3. 썸네일 생성 (이미지 or 비디오)
+      const isImage = f.mimeType?.startsWith('image/');
+      const isVideo = f.mimeType?.startsWith('video/');
+
+      if (isImage) {
+        await this._generateImageThumbnail(att, storagePath);
+      } else if (isVideo) {
+        // 비디오 썸네일은 백그라운드 Task로 위임
+        this.app.dispatch('ProcessVideoThumbnailTask', {
+          postId,
+          attachmentId: att.id,
+          storagePath,
+        });
+      }
+    }
+  }
+
+  /**
+   * 이미지 썸네일 생성
+   *
+   * `app.media.resize()` 호출:
+   * - 입력: Storage 원본 이미지
+   * - 출력: 400px 가로 webp (비율 유지, 높이 자동)
+   * - 품질: 80
+   *
+   * @private
+   * @param {Object} att         - Attachment 레코드
+   * @param {string} storagePath - 원본 Storage 경로
+   */
+  async _generateImageThumbnail(att, storagePath) {
+    try {
+      const fullPath = path.join(this.app.storage.basePath, storagePath);
+      const thumbName = `${att.id}.webp`;
+      const thumbStoragePath = `uploads/thumbs/${thumbName}`;
+      const thumbFullPath = path.join(this.app.storage.basePath, thumbStoragePath);
+
+      // 썸네일 디렉토리 생성
+      await fs.mkdir(path.dirname(thumbFullPath), { recursive: true });
+
+      // Bridge 이미지 리사이즈 (Rust native — width:400, height:0 = 비율 유지)
+      this.app.media.resize(fullPath, thumbFullPath, 400, 0, 'webp', 80);
+
+      // 썸네일 파일 정보
+      const stat = await fs.stat(thumbFullPath);
+      let info = { width: 400, height: 0 };
+      try { info = this.app.media.imageInfo(thumbFullPath); } catch {}
+
+      // Thumbnail DB 레코드
+      await this.db.Thumbnail.create({
+        attachment_id: att.id,
+        file_path: thumbStoragePath,
+        width: info.width || 400,
+        height: info.height || 0,
+        format: 'webp',
+        size: stat.size,
+        source_type: 'image',
+      });
+    } catch (err) {
+      console.warn(`[PostService] 이미지 썸네일 생성 실패 (att:${att.id}):`, err.message);
+    }
+  }
+
+  /**
+   * 특정 첨부파일의 썸네일 삭제 (Storage + DB)
+   *
+   * @private
+   * @param {number} attachmentId
+   */
+  async _deleteThumbnail(attachmentId) {
+    const thumbs = await this.db.Thumbnail.where('attachment_id', attachmentId).get();
+    for (const t of thumbs) {
+      try { await this.app.storage.delete(t.file_path); } catch {}
+      await t.delete();
+    }
+  }
+
+  /**
+   * 게시글의 모든 첨부파일 + 썸네일 삭제
+   *
+   * @private
+   * @param {number} postId
+   */
+  async _deleteAllFiles(postId) {
+    const attachments = await this.db.Attachment.where('post_id', postId).get();
+    for (const att of attachments) {
+      // 썸네일 먼저 삭제
+      await this._deleteThumbnail(att.id);
+      // 원본 파일 삭제
+      try { await this.app.storage.delete(att.file_path); } catch {}
+      await att.delete();
+    }
+  }
+}