create-fuzionx 0.1.31 → 0.1.32

package/index.js

@@ -25,51 +25,37 @@ async function loadTemplate(relPath, vars) {
     return render(raw, vars);
 }
 
-/** 디렉토리 재귀 복사 */
-async function copyDirRecursive(src, dst) {
+/** 디렉토리 재귀 복사 — .tpl 파일은 변수 치환 */
+async function copyDirRecursive(src, dst, vars = {}) {
     await fs.mkdir(dst, { recursive: true });
     const entries = await fs.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
         const srcPath = path.join(src, entry.name);
         const dstPath = path.join(dst, entry.name);
         if (entry.isDirectory()) {
-            await copyDirRecursive(srcPath, dstPath);
+            await copyDirRecursive(srcPath, dstPath, vars);
+        } else if (entry.name === 'meta.json') {
+            // meta.json은 스캐폴딩에 포함하지 않음
+            continue;
+        } else if (entry.name.endsWith('.tpl')) {
+            // .tpl 파일은 변수 치환 후 확장자 제거
+            const content = await fs.readFile(srcPath, 'utf-8');
+            const rendered = render(content, vars);
+            const destName = entry.name.replace(/\.tpl$/, '');
+            await fs.writeFile(path.join(dst, destName), rendered);
         } else {
             await fs.copyFile(srcPath, dstPath);
         }
     }
 }
 
-// ── 스캐폴딩 파일 목록 (fuzionx + tester 2-app 구조) ──
+// ── 빈 디렉토리 (.gitkeep 포함) ──
 
-const APP_FILES = [
-    { tpl: 'package.json.tpl', dest: 'package.json' },
-    { tpl: 'fuzionx.yaml.tpl', dest: 'fuzionx.yaml' },
-    { tpl: 'app.js.tpl', dest: 'app.js' },
-    { tpl: '.env.example.tpl', dest: '.env.example' },
-    { tpl: '.env.example.tpl', dest: '.env' },
-    { tpl: '.gitignore.tpl', dest: '.gitignore' },
-];
-
-/** fuzionx 앱 — .tpl 파일 (치환 필요) */
-const FUZIONX_TPL_FILES = [
-    { tpl: 'fuzionx/routes/web.js.tpl', dest: 'app/fuzionx/routes/web.js' },
-    { tpl: 'fuzionx/routes/api.js.tpl', dest: 'app/fuzionx/routes/api.js' },
-];
-
-/** 빈 디렉토리 (.gitkeep 포함) */
-const APP_DIRS = [
-    // fuzionx 앱
-    'app/fuzionx/services',
-    'app/fuzionx/middleware',
-    'app/fuzionx/ws',
-    // 인프라
+const EMPTY_DIRS = [
     'database/migrations',
     'database/seeds',
     'storage/logs',
     'storage/uploads',
-    'public/css',
-    'public/js',
     'tests',
 ];
 
@@ -77,14 +63,24 @@ const APP_DIRS = [
 
 async function createApp(name, targetDir, type = 'spa') {
     const dir = targetDir || path.resolve(name);
-    const appName = type;  // 앱 이름은 타입에 따라 고정
+    const appName = type;  // 앱 디렉토리명은 타입과 동일
     const vars = {
         name,
         dbName: name.replace(/-/g, '_'),
     };
 
-    // 빈 디렉토리 생성 (.gitkeep 포함)
-    for (const d of APP_DIRS) {
+    const commonDir = path.join(TPL_DIR, 'common');
+    const typeDir = path.join(TPL_DIR, type);
+
+    // meta.json 로드
+    let meta = {};
+    try {
+        const metaRaw = await fs.readFile(path.join(typeDir, 'meta.json'), 'utf-8');
+        meta = JSON.parse(metaRaw);
+    } catch { /* meta.json 없어도 진행 */ }
+
+    // 1. 빈 디렉토리 생성
+    for (const d of EMPTY_DIRS) {
         const fullDir = path.join(dir, d);
         await fs.mkdir(fullDir, { recursive: true });
         const files = await fs.readdir(fullDir).catch(() => []);
@@ -93,57 +89,64 @@ async function createApp(name, targetDir, type = 'spa') {
         }
     }
 
-    // 루트 템플릿 파일 생성 (.tpl 치환)
-    for (const { tpl, dest } of APP_FILES) {
-        const content = await loadTemplate(tpl, vars);
-        const fullPath = path.join(dir, dest);
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, content);
+    // 앱 전용 빈 디렉토리
+    for (const d of ['services', 'middleware', 'ws']) {
+        const fullDir = path.join(dir, `app/${appName}`, d);
+        await fs.mkdir(fullDir, { recursive: true });
+        const files = await fs.readdir(fullDir).catch(() => []);
+        if (files.length === 0) {
+            await fs.writeFile(path.join(fullDir, '.gitkeep'), '');
+        }
+    }
+
+    // 2. common/ 루트 .tpl 파일 → 프로젝트 루트
+    const commonEntries = await fs.readdir(commonDir, { withFileTypes: true });
+    for (const entry of commonEntries) {
+        if (entry.isFile() && entry.name.endsWith('.tpl')) {
+            const content = await fs.readFile(path.join(commonDir, entry.name), 'utf-8');
+            const rendered = render(content, vars);
+            const destName = entry.name.replace(/\.tpl$/, '');
+            await fs.writeFile(path.join(dir, destName), rendered);
+        }
+    }
+
+    // 3. common/ 하위 디렉토리 복사 (database, locales, shared)
+    for (const entry of commonEntries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === 'tester') continue;  // tester는 별도 처리
+        await copyDirRecursive(
+            path.join(commonDir, entry.name),
+            path.join(dir, entry.name),
+            vars,
+        );
     }
 
-    // fuzionx 앱 — .tpl 파일 (치환 필요)
-    for (const { tpl, dest } of FUZIONX_TPL_FILES) {
-        const content = await loadTemplate(tpl, vars);
-        const actualDest = dest.replace('app/fuzionx/', `app/${appName}/`);
-        const fullPath = path.join(dir, actualDest);
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, content);
+    // 4. tester 앱 복사 (common/tester/ → app/tester/)
+    const testerSrc = path.join(commonDir, 'tester');
+    try {
+        await fs.access(testerSrc);
+        await copyDirRecursive(testerSrc, path.join(dir, 'app/tester'), vars);
+    } catch { /* tester 없으면 스킵 */ }
+
+    // 5. 타입별 템플릿 복사 → app/{type}/
+    //    controllers, services, middleware, routes, ws, views
+    const typeEntries = await fs.readdir(typeDir, { withFileTypes: true });
+    for (const entry of typeEntries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === 'public') continue;  // public은 프로젝트 루트로 복사
+        await copyDirRecursive(
+            path.join(typeDir, entry.name),
+            path.join(dir, `app/${appName}`, entry.name),
+            vars,
+        );
     }
 
-    // fuzionx 앱 — 직접 복사 (controllers, views)
-    const fuzionxSrc = path.join(TPL_DIR, 'fuzionx');
-    await copyDirRecursive(
-        path.join(fuzionxSrc, 'controllers'),
-        path.join(dir, `app/${appName}/controllers`),
-    );
-    await copyDirRecursive(
-        path.join(fuzionxSrc, 'views'),
-        path.join(dir, `app/${appName}/views`),
-    );
-
-    // tester 앱 — 전체 복사
-    await copyDirRecursive(
-        path.join(TPL_DIR, 'tester'),
-        path.join(dir, 'app/tester'),
-    );
-
-    // shared — 전체 복사
-    await copyDirRecursive(
-        path.join(TPL_DIR, 'shared'),
-        path.join(dir, 'shared'),
-    );
-
-    // database/models — 복사
-    await copyDirRecursive(
-        path.join(TPL_DIR, 'database'),
-        path.join(dir, 'database'),
-    );
-
-    // locales — 복사
-    await copyDirRecursive(
-        path.join(TPL_DIR, 'locales'),
-        path.join(dir, 'locales'),
-    );
+    // 6. public/ 디렉토리 복사 (SSR의 경우 CSS/JS assets)
+    const publicSrc = path.join(typeDir, 'public');
+    try {
+        await fs.access(publicSrc);
+        await copyDirRecursive(publicSrc, path.join(dir, 'public'), vars);
+    } catch { /* public 없으면 스킵 */ }
 
     return dir;
 }
@@ -175,6 +178,7 @@ if (!validTypes.includes(type)) {
 
 try {
     const dir = await createApp(name, null, type);
+    const nextCmd = type === 'spa' ? 'npx fx dev:spa' : 'npx fx dev';
     console.log(`
   ✅ Created ${name} at ${dir} (type: ${type})
 
@@ -182,7 +186,8 @@ try {
 
     cd ${name}
     npm install
-    npx fx dev${type === 'spa' ? ':spa' : ''}
+    ${type === 'spa' ? `cd app/spa/views/default/spa && npm install && cd ../../../../..
+    ` : ''}${nextCmd}
 `);
 } catch (err) {
     console.error(`❌ Failed to create app: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fuzionx",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "description": "Create a new FuzionX application — npx create-fuzionx my-app",
   "type": "module",
   "bin": {

package/templates/{fuzionx.yaml.tpl → common/fuzionx.yaml.tpl}

@@ -87,6 +87,8 @@ bridge:
   static:
     - url: /public
       path: ./public
+    - url: /wasm
+      path: ./node_modules/@fuzionx/client
 
   # ── 로깅 ──
   logging:
@@ -125,7 +127,7 @@ bridge:
 
   # ── ASP 암호화 ──
   asp:
-    enabled: false
+    enabled: true
     master_secret: "${ASP_SECRET:change-me-in-production}"
     header_signal: Ruxy-Enc-Mode
 

package/templates/{package.json.tpl → common/package.json.tpl}

@@ -9,8 +9,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@fuzionx/framework": "^0.1.31",
-    "@fuzionx/client": "^0.1.30",
+    "@fuzionx/framework": "^0.1.32",
+    "@fuzionx/client": "^0.1.32",
     "joi": "^18.1.1"
   },
   "devDependencies": {

package/templates/spa/controllers/AuthController.js

@@ -0,0 +1,114 @@
+import { Controller } from '@fuzionx/framework';
+
+/**
+ * SPA AuthController — JSON API 전용 인증
+ *
+ * 모든 페이지는 Vue에서 렌더링. 서버는 API만 제공.
+ * 세션 기반 인증. JSON 요청/응답.
+ */
+export default class AuthController extends Controller {
+  /** @type {import('@fuzionx/framework').RouteHandler} 로그인 API */
+  static login;
+  /** @type {import('@fuzionx/framework').RouteHandler} 회원가입 API */
+  static register;
+  /** @type {import('@fuzionx/framework').RouteHandler} 로그아웃 API */
+  static logout;
+  /** @type {import('@fuzionx/framework').RouteHandler} 인증 상태 확인 API */
+  static check;
+  /** @type {import('@fuzionx/framework').RouteHandler} 하트비트 (세션 연장) */
+  static heartbeat;
+
+  /**
+   * POST /api/auth/login — 로그인
+   *
+   * email/password 검증 후 세션에 userId 저장.
+   * 성공 → { user }, 실패 → 401 { error }.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async login(ctx) {
+    const { email, password } = ctx.body;
+    const user = await this.service('AuthService').login({ email, password });
+
+    if (!user) {
+      return ctx.status(401).json({ error: ctx.t('auth.login_failed') });
+    }
+
+    ctx.session.set('userId', user.id);
+    ctx.json({ user: { id: user.id, name: user.name, email: user.email, role: user.role } });
+  }
+
+  /**
+   * POST /api/auth/register — 회원가입
+   *
+   * name/email/password/password_confirm 검증.
+   * 성공 → 201 { user }, 실패 → 400 { error }.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async register(ctx) {
+    const { name, email, password, password_confirm } = ctx.body;
+
+    if (password !== password_confirm) {
+      return ctx.status(400).json({ error: ctx.t('auth.password_mismatch') });
+    }
+
+    try {
+      const user = await this.service('AuthService').register({ name, email, password });
+      ctx.session.set('userId', user.id);
+      ctx.status(201).json({ user: { id: user.id, name: user.name, email: user.email } });
+    } catch (e) {
+      ctx.status(e.status || 400).json({ error: ctx.t(e.message) || e.message });
+    }
+  }
+
+  /**
+   * POST /api/auth/logout — 로그아웃
+   *
+   * 세션 파기 후 { success: true } 반환.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async logout(ctx) {
+    ctx.session.destroy();
+    ctx.json({ success: true });
+  }
+
+  /**
+   * GET /api/auth/check — 인증 상태 확인
+   *
+   * 세션에 userId 존재 → DB 조회 → { authenticated, user }.
+   * 미인증 시 { authenticated: false, user: null }.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async check(ctx) {
+    const userId = ctx.session.get('userId');
+    if (!userId) return ctx.json({ authenticated: false, user: null });
+
+    try {
+      const user = await this.db.User.find(userId);
+      if (!user) return ctx.json({ authenticated: false, user: null });
+      ctx.json({ authenticated: true, user: user.toJSON() });
+    } catch {
+      ctx.json({ authenticated: false, user: null });
+    }
+  }
+
+  /**
+   * GET /api/heartbeat — 세션 연장 (하트비트)
+   *
+   * 인증된 사용자의 세션 유지. { alive, user }.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async heartbeat(ctx) {
+    if (!ctx.user) return ctx.status(401).json({ alive: false });
+    ctx.json({ alive: true, user: { id: ctx.user.id } });
+  }
+}

package/templates/spa/controllers/HomeController.js

@@ -0,0 +1,68 @@
+import { Controller } from '@fuzionx/framework';
+
+/**
+ * SPA HomeController — Vue 셸 렌더링
+ *
+ * 모든 프론트엔드 라우트에 대해 Vue 앱 셸을 서빙.
+ * 인증 여부와 관계없이 셸을 렌더링하며,
+ * 유저 데이터를 ASP 암호화하여 Vue에 전달.
+ * Vue가 user=null이면 로그인 화면, 아니면 대시보드를 표시.
+ *
+ * bridge.cryptoEncryptCustom(key, plaintext) → WASM decrypt_custom(key, ciphertext)
+ */
+export default class HomeController extends Controller {
+  /** @type {import('@fuzionx/framework').RouteHandler} SPA 셸 렌더링 */
+  static index;
+
+  /**
+   * GET / | /* — Vue SPA 셸 렌더링
+   *
+   * 세션에서 유저 조회 후 ASP 암호화된 payload와 함께 렌더링.
+   * payload: { user, locale, isDev, asp, app }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async index(ctx) {
+    const clientSecret = this.config.get('app.client_secret');
+    const bridge = this.app._bridge;
+
+    // ASP config에서 masterSecret 가져오기
+    const aspConfig = JSON.parse(bridge.getAspConfig());
+    const masterSecret = aspConfig.masterSecret || '';
+
+    // 세션에서 유저 조회 (인증 안 되어 있으면 null)
+    let user = null;
+    const userId = ctx.session?.get('userId');
+    if (userId && this.db?.User) {
+      try {
+        const u = await this.db.User.find(userId);
+        if (u) user = { id: u.id, name: u.name, email: u.email, role: u.role };
+      } catch {}
+    }
+
+    const isDev = this.config.get('app.environment') === 'development';
+
+    // SPA에 전달할 payload
+    const payload = {
+      user,
+      locale: ctx.locale,
+      locales: this.app?.i18n?.locales?.() || [],
+      translations: ctx.t.all(),
+      isDev,
+      asp: { headerSignal: aspConfig.headerSignal || 'Ruxy-Enc-Mode' },
+      app: { name: this.config.get('app.name'), theme: this.config.get('app.themes.default') },
+    };
+
+    // 암호화 (bridge crypto_encrypt_custom — WASM decrypt_custom과 호환)
+    const encryptedPayload = bridge.cryptoEncryptCustom(clientSecret, JSON.stringify(payload));
+    const encryptedSecret = bridge.cryptoEncryptCustom(clientSecret, masterSecret);
+
+    ctx.render('home', {
+      __fx__: encryptedPayload,
+      __fx_secret__: encryptedSecret,
+      client_secret: clientSecret,
+      isDev,
+    });
+  }
+}

package/templates/spa/controllers/PostController.js

@@ -0,0 +1,191 @@
+import { Controller, DateUtil } from '@fuzionx/framework';
+
+/**
+ * SPA PostController — 게시판 REST API
+ *
+ * RESTful CRUD. JSON 요청/응답.
+ * r.resource('posts', PostController) 로 자동 라우트 등록.
+ */
+export default class PostController extends Controller {
+  /** @type {import('@fuzionx/framework').RouteHandler} 게시글 목록 조회 */
+  static index;
+  /** @type {import('@fuzionx/framework').RouteHandler} 게시글 상세 조회 */
+  static show;
+  /** @type {import('@fuzionx/framework').RouteHandler} 게시글 작성 */
+  static store;
+  /** @type {import('@fuzionx/framework').RouteHandler} 게시글 수정 */
+  static update;
+  /** @type {import('@fuzionx/framework').RouteHandler} 게시글 삭제 */
+  static destroy;
+
+  /**
+   * GET /api/posts — 게시글 목록 (페이지네이션)
+   *
+   * query.page로 페이지 결정. 10건씩 조회.
+   * 응답: { data, page, lastPage, hasMore, total, perPage }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async index(ctx) {
+    const page = parseInt(ctx.query.page || '1');
+    const result = await this.service('PostService').list(page, 10);
+
+    // 게시글 목록의 대표 썸네일 한 번에 조회 (N+1 방지)
+    const postIds = result.data.map(p => p.id);
+    const thumbMap = await this.service('PostService').getPostThumbnails(postIds);
+
+    // 작성자 이름 batch 조회 (N+1 방지)
+    const userIds = [...new Set(result.data.map(p => p.user_id).filter(Boolean))];
+    const userMap = new Map();
+    if (userIds.length) {
+      const users = await this.db.User.query().whereIn('id', userIds).get();
+      for (const u of users) userMap.set(u.id, u.name);
+    }
+
+    // 각 게시글에 thumbUrl, user_name, 포맷된 날짜 추가
+    const posts = result.data.map(p => ({
+      ...p,
+      thumbUrl: thumbMap.get(p.id) || null,
+      user_name: userMap.get(p.user_id) || '-',
+      created_at: DateUtil.format(p.created_at, 'YYYY-MM-DD HH:mm'),
+    }));
+
+    ctx.json({
+      data: posts,
+      page: result.page,
+      lastPage: result.lastPage,
+      hasMore: result.hasMore,
+      total: result.total,
+    });
+  }
+
+  /**
+   * GET /api/posts/:id — 게시글 상세 조회
+   *
+   * 게시글 + 작성자 정보 반환. 미존재 시 404.
+   * 응답: { post, author }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async show(ctx) {
+    const postService = this.service('PostService');
+    const post = await postService.find(ctx.params.id);
+    if (!post) return ctx.status(404).json({ error: ctx.t('post.not_found') });
+
+    const author = await this.db.User.find(post.user_id);
+    const files = await postService.getAttachmentsWithThumbs(post.id);
+
+    ctx.json({
+      post: { ...post, created_at: DateUtil.format(post.created_at, 'YYYY-MM-DD HH:mm') },
+      author: author ? { id: author.id, name: author.name } : null,
+      files,
+    });
+  }
+
+  /**
+   * POST /api/posts — 게시글 작성
+   *
+   * JSON body에서 title/content 추출. 현재 사용자의 user_id 자동 설정.
+   * 응답: 201 { post }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async store(ctx) {
+    // 업로드 오류 처리 (파일 타입/크기 제한 등)
+    if (ctx.uploadError) {
+      return ctx.status(400).json({ error: ctx.uploadError });
+    }
+    const { title, content } = ctx.body;
+    const uploadedFiles = ctx.files || [];
+    const post = await this.service('PostService').create(
+      { title, content, user_id: ctx.user.id },
+      uploadedFiles,
+    );
+    ctx.status(201).json({ post });
+  }
+
+  /**
+   * PUT /api/posts/:id — 게시글 수정
+   *
+   * 작성자 본인만 수정 가능. 권한 없으면 403.
+   * 응답: { post }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async update(ctx) {
+    // 업로드 오류 처리
+    if (ctx.uploadError) {
+      return ctx.status(400).json({ error: ctx.uploadError });
+    }
+    const post = await this.service('PostService').find(ctx.params.id);
+    if (!post || post.user_id !== ctx.user.id) {
+      return ctx.status(403).json({ error: ctx.t('common.forbidden') });
+    }
+    const { title, content } = ctx.body;
+    const uploadedFiles = ctx.files || [];
+    await this.service('PostService').update(ctx.params.id, { title, content }, uploadedFiles);
+    const updated = await this.service('PostService').find(ctx.params.id);
+    ctx.json({ post: updated });
+  }
+
+  /**
+   * DELETE /api/posts/:id — 게시글 삭제
+   *
+   * 작성자 본인만 삭제 가능. 권한 없으면 403.
+   * 응답: { deleted: true }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async destroy(ctx) {
+    const post = await this.service('PostService').find(ctx.params.id);
+    if (!post || post.user_id !== ctx.user.id) return ctx.status(403).json({ error: ctx.t('common.forbidden') });
+    await this.service('PostService').remove(ctx.params.id);
+    ctx.json({ deleted: true });
+  }
+
+  /**
+   * GET /api/posts/status?ids=1,2,3 — 게시글 상태 JSON 반환
+   *
+   * processing 상태 폴링용. SSR PostController.status와 동일.
+   * 응답: { statuses: { 1: 'published', 2: 'processing' } }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   */
+  async status(ctx) {
+    const raw = ctx.query.ids || '';
+    const ids = raw.split(',').map(Number).filter(Boolean);
+    if (!ids.length) return ctx.json({ statuses: {} });
+
+    const posts = await this.db.Post.query().whereIn('id', ids).get();
+    const statuses = {};
+    for (const p of posts) {
+      statuses[p.id] = p.status || 'published';
+    }
+    ctx.json({ statuses });
+  }
+
+  /**
+   * DELETE /api/posts/attachment/:id — 개별 첨부파일 삭제
+   *
+   * 수정 화면에서 기존 첨부파일 개별 삭제.
+   * 작성자 본인만 삭제 가능.
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   */
+  async deleteAttachment(ctx) {
+    const att = await this.db.Attachment.find(ctx.params.id);
+    if (!att) return ctx.status(404).json({ error: 'Not found' });
+
+    const post = await this.db.Post.find(att.post_id);
+    if (!post || post.user_id !== ctx.user.id) return ctx.status(403).json({ error: 'Forbidden' });
+
+    await this.service('PostService').removeAttachment(att.id);
+    ctx.json({ deleted: true });
+  }
+
+}

package/templates/spa/controllers/UserController.js

@@ -0,0 +1,43 @@
+import { Controller } from '@fuzionx/framework';
+
+/**
+ * SPA UserController — 사용자 프로필 REST API
+ *
+ * 프로필 조회/수정. JSON 요청/응답.
+ */
+export default class UserController extends Controller {
+  /** @type {import('@fuzionx/framework').RouteHandler} 프로필 조회 */
+  static profile;
+  /** @type {import('@fuzionx/framework').RouteHandler} 프로필 수정 */
+  static updateProfile;
+
+  /**
+   * GET /api/user/profile — 프로필 조회
+   *
+   * 인증된 사용자의 기본 정보 반환.
+   * 응답: { user: { id, name, email, role } }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async profile(ctx) {
+    const { id, name, email, role } = ctx.user;
+    ctx.json({ user: { id, name, email, role } });
+  }
+
+  /**
+   * PUT /api/user/profile — 프로필 수정
+   *
+   * JSON body에서 name/email/password 추출.
+   * UserService.update() 호출 후 갱신된 사용자 정보 반환.
+   * 응답: { user: { id, name, email, role } }
+   *
+   * @param {import('@fuzionx/framework').Context} ctx - 요청 컨텍스트
+   * @returns {void}
+   */
+  async updateProfile(ctx) {
+    const { name, email, password } = ctx.body;
+    const user = await this.service('UserService').update(ctx.user.id, { name, email, password });
+    ctx.json({ user: { id: user.id, name: user.name, email: user.email, role: user.role } });
+  }
+}