create-fuzionx 0.1.30 → 0.1.32

package/fx.js

@@ -48,22 +48,26 @@ if (existsSync(localBin) || existsSync(localCli)) {
     fx new <name>                  새 프로젝트 스캐폴딩
 
   프로젝트 내 명령어 (@fuzionx/framework 필요):
-    fx make:app <name>             새 앱 디렉토리 생성
-    fx make:controller <Name>      컨트롤러 생성
-    fx make:model <Name>           모델 생성
-    fx make:service <Name>         서비스 생성
-    fx make:middleware <Name>      미들웨어 생성
-    fx make:job <Name>             Job 생성
-    fx make:task <Name>            Task 생성
-    fx make:ws <Name>              WsHandler 생성
-    fx make:event <Name>           이벤트 핸들러 생성
-    fx dev                         개발 서버 (--watch)
-    fx stop                        서버 종료 (graceful)
-    fx restart                     서버 재시작 (graceful)
-    fx test                        테스트 실행
-    fx routes                      라우트 테이블
-    fx config                      설정 출력
-    fx db:sync                     모델 ↔ DB 동기화
+    fx make:app --type=ssr|spa       Create app (fixed name: app/ssr or app/spa)
+    fx make:controller <Name> --app=  Create controller (app-specific)
+    fx make:service <Name> --app=     Create service (app-specific)
+    fx make:model <Name>              Create model (database/models)
+    fx make:middleware <Name> --app=   Create middleware (app-specific)
+    fx make:job <Name>                Create job (shared/jobs)
+    fx make:task <Name>               Create task (shared/jobs)
+    fx make:ws <Name> --app=          Create WsHandler (app-specific)
+    fx make:event <Name>              Create event handler (shared/events)
+    fx make:worker <Name>             Create worker (shared/workers)
+    fx make:test <Name>               Create test
+    fx dev                            Start dev server (--watch)
+    fx dev:spa                        Start dev server + Vite HMR
+    fx build:spa                      Build SPA for production
+    fx stop                            Stop server (graceful)
+    fx restart                         Restart server (graceful)
+    fx test                           Run tests
+    fx routes                         Print route table
+    fx config                         Print fuzionx.yaml
+    fx db:sync                        Sync models → DB (--apply)
 `);
 } else {
     console.error(`❌ @fuzionx/framework가 설치되지 않았습니다.`);

package/index.js

@@ -4,7 +4,8 @@
  *
  * Usage:
  *   npx create-fuzionx my-app
- *   npx create-fuzionx my-app /path/to/dir
+ *   npx create-fuzionx my-app --type=spa
+ *   npx create-fuzionx my-app --type=ssr
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
@@ -24,65 +25,62 @@ 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',
 ];
 
 // ── createApp ──
 
-async function createApp(name, targetDir) {
+async function createApp(name, targetDir, type = 'spa') {
     const dir = targetDir || path.resolve(name);
+    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(() => []);
@@ -91,86 +89,105 @@ async function createApp(name, targetDir) {
         }
     }
 
-    // 루트 템플릿 파일 생성 (.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'), '');
+        }
     }
 
-    // fuzionx 앱 — .tpl 파일 (치환 필요)
-    for (const { tpl, dest } of FUZIONX_TPL_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);
+    // 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);
+        }
     }
 
-    // fuzionx 앱 — 직접 복사 (controllers, views)
-    const fuzionxSrc = path.join(TPL_DIR, 'fuzionx');
-    await copyDirRecursive(
-        path.join(fuzionxSrc, 'controllers'),
-        path.join(dir, 'app/fuzionx/controllers'),
-    );
-    await copyDirRecursive(
-        path.join(fuzionxSrc, 'views'),
-        path.join(dir, 'app/fuzionx/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'),
-    );
+    // 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,
+        );
+    }
+
+    // 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,
+        );
+    }
+
+    // 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;
 }
 
 // ── CLI 엔트리 ──
 
-const name = process.argv[2];
-const targetDir = process.argv[3];
+const allArgs = process.argv.slice(2);
+const name = allArgs.find(a => !a.startsWith('--'));
+const typeFlag = allArgs.find(a => a.startsWith('--type='));
+const type = typeFlag?.split('=')[1] || 'spa';
 
 if (!name) {
     console.error(`
-  Usage: npx create-fuzionx <app-name> [target-dir]
+  Usage: npx create-fuzionx <app-name> [--type=ssr|spa]
 
   Examples:
-    npx create-fuzionx my-app
-    npx create-fuzionx my-app /path/to/dir
+    npx create-fuzionx my-app              # default: spa
+    npx create-fuzionx my-app --type=ssr   # MPA (SSR)
+    npx create-fuzionx my-app --type=spa   # SPA (Vue.js 3 + SSR)
 `);
     process.exit(1);
 }
 
+const validTypes = ['ssr', 'spa'];
+if (!validTypes.includes(type)) {
+    console.error(`❌ Unknown type: ${type}. Available: ${validTypes.join(', ')}`);
+    process.exit(1);
+}
+
 try {
-    const dir = await createApp(name, targetDir);
+    const dir = await createApp(name, null, type);
+    const nextCmd = type === 'spa' ? 'npx fx dev:spa' : 'npx fx dev';
     console.log(`
-  ✅ Created ${name} at ${dir}
+  ✅ Created ${name} at ${dir} (type: ${type})
 
   Next steps:
 
     cd ${name}
     npm install
-    npx fx dev
+    ${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.30",
+  "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}

@@ -4,13 +4,17 @@
   "type": "module",
   "scripts": {
     "dev": "fx dev",
+    "dev:spa": "fx dev:spa",
+    "build:spa": "fx build:spa",
     "test": "vitest run"
   },
   "dependencies": {
-    "@fuzionx/framework": "^0.1.30",
+    "@fuzionx/framework": "^0.1.32",
+    "@fuzionx/client": "^0.1.32",
     "joi": "^18.1.1"
   },
   "devDependencies": {
+    "concurrently": "^9.0.0",
     "vitest": "^3.0.0"
   }
 }

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,
+    });
+  }
+}