@gaonjs/cli 0.1.3 → 0.1.5

package/dist/generate.d.ts

@@ -0,0 +1,30 @@
+export interface AuthScaffoldOptions {
+    /** 대상 앱(apps/<app>). 기본 'web'. */
+    readonly app?: string;
+}
+/** 생성할 파일 하나 — 경로는 프로젝트 루트 기준. */
+export interface ScaffoldFile {
+    readonly path: string;
+    readonly contents: string;
+}
+export interface ScaffoldResult {
+    readonly created: string[];
+    readonly skipped: string[];
+    readonly patched: string[];
+}
+/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다. */
+export declare function authScaffoldFiles(opts?: AuthScaffoldOptions): ScaffoldFile[];
+/**
+ * 기존 routes.ts 에 세션·회원가입 리소스를 끼워 넣는다. 이미 있으면 null.
+ * `routes((r) => {` 콜백 여는 지점 뒤에 두 줄을 삽입한다.
+ */
+export declare function patchRoutes(existing: string): string | null;
+/** 스캐폴드를 디스크에 쓴다. 기존 파일은 덮어쓰지 않고 skip 한다. routes.ts 는 패치. */
+export declare function writeAuthScaffold(cwd: string, opts?: AuthScaffoldOptions): ScaffoldResult;
+export interface GenerateAuthOptions {
+    readonly cwd?: string;
+    readonly app?: string;
+    readonly json?: boolean;
+}
+/** `gaon g auth` 진입점. 스캐폴드를 쓰고 결과를 사람/JSON 으로 출력한다. */
+export declare function runGenerateAuthCommand(opts?: GenerateAuthOptions): number;

package/dist/generate.js

@@ -0,0 +1,125 @@
+/**
+ * @gaonjs/cli · `gaon g auth` — 인증 스캐폴드 제너레이터 (M5)
+ *
+ * 회원가입/로그인/세션/보호 라우트의 스키마·모델·컨트롤러·페이지·배선을
+ * 한 번에 생성한다(§7). 생성 직후 회원가입→로그인→보호 라우트가 동작한다.
+ *
+ * 템플릿은 `templates/auth/*.tpl` 에 별도 파일로 둔다(Rails 관례) — 제너레이터
+ * 로직과 템플릿 디자인을 분리해 .vue 마크업을 파일 단위로 수정할 수 있게 한다.
+ * 이 파일은 템플릿을 읽어 토큰({{APP_NAME}})을 치환하고 목표 경로에 쓴다.
+ *
+ * 생성물은 파사드 서브패스(gaonjs/data·gaonjs/web·gaonjs/vue)만 import 한다
+ * — 개발자는 gaonjs 하나만 설치한다(§2.5.2). 세션은 Redis, passwordDigest 는
+ * hidden 컬럼이라 페이지로 새지 않는다(§4.2).
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// ── 템플릿 로드·치환 ───────────────────────────────────────────
+// 템플릿은 이 모듈과 같은 위치의 templates/auth/ 에 있다(빌드가 dist 로 복사).
+const TEMPLATE_DIR = join(dirname(fileURLToPath(import.meta.url)), 'templates', 'auth');
+/** 템플릿 파일을 읽어 토큰을 치환한다. {{APP_NAME}} 는 Vue 의 {{ }} 보간과
+ *  겹치지 않는 고정 리터럴이라 단순 replaceAll 로 안전하다. */
+function renderTemplate(name, app) {
+    const raw = readFileSync(join(TEMPLATE_DIR, name), 'utf8');
+    return raw.replaceAll('{{APP_NAME}}', app);
+}
+/** 템플릿 파일 → 생성 경로 매핑(라우트 제외 — 라우트는 패치로 처리). */
+const TEMPLATES = [
+    { tpl: 'user.schema.ts.tpl', out: () => 'domain/schema/user.ts' },
+    { tpl: 'user.model.ts.tpl', out: () => 'domain/models/user.ts' },
+    { tpl: 'auth.wiring.ts.tpl', out: (a) => `apps/${a}/auth.ts` },
+    { tpl: 'session.controller.ts.tpl', out: (a) => `apps/${a}/controllers/session.ts` },
+    { tpl: 'registration.controller.ts.tpl', out: (a) => `apps/${a}/controllers/registration.ts` },
+    { tpl: 'dashboard.controller.ts.tpl', out: (a) => `apps/${a}/controllers/dashboard.ts` },
+    { tpl: 'Login.vue.tpl', out: (a) => `apps/${a}/pages/auth/Login.vue` },
+    { tpl: 'Signup.vue.tpl', out: (a) => `apps/${a}/pages/auth/Signup.vue` },
+    { tpl: 'Dashboard.vue.tpl', out: (a) => `apps/${a}/pages/Dashboard.vue` },
+    { tpl: 'app.ts.tpl', out: (a) => `apps/${a}/app.ts` },
+    { tpl: 'server.ts.tpl', out: () => 'server.ts' },
+];
+/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다. */
+export function authScaffoldFiles(opts = {}) {
+    const app = opts.app ?? 'web';
+    return TEMPLATES.map(({ tpl, out }) => ({ path: out(app), contents: renderTemplate(tpl, app) }));
+}
+/**
+ * 기존 routes.ts 에 세션·회원가입 리소스를 끼워 넣는다. 이미 있으면 null.
+ * `routes((r) => {` 콜백 여는 지점 뒤에 두 줄을 삽입한다.
+ */
+export function patchRoutes(existing) {
+    if (existing.includes("resource('session')"))
+        return null;
+    const m = existing.match(/routes\(\s*\(\s*\w+\s*\)\s*=>\s*\{/);
+    if (!m || m.index === undefined)
+        return null;
+    const insertAt = m.index + m[0].length;
+    const inject = "\n  r.resource('session') // 로그인/로그아웃 (gaon g auth)" +
+        "\n  r.resource('registration') // 회원가입 (gaon g auth)";
+    return existing.slice(0, insertAt) + inject + existing.slice(insertAt);
+}
+/** 스캐폴드를 디스크에 쓴다. 기존 파일은 덮어쓰지 않고 skip 한다. routes.ts 는 패치. */
+export function writeAuthScaffold(cwd, opts = {}) {
+    const root = resolve(cwd);
+    const app = opts.app ?? 'web';
+    const created = [];
+    const skipped = [];
+    const patched = [];
+    for (const file of authScaffoldFiles(opts)) {
+        const abs = join(root, file.path);
+        if (existsSync(abs)) {
+            skipped.push(file.path);
+            continue;
+        }
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, file.contents, 'utf8');
+        created.push(file.path);
+    }
+    // routes.ts — 있으면 패치, 없으면 템플릿에서 생성.
+    const routesPath = join(root, 'apps', app, 'routes.ts');
+    const routesRel = `apps/${app}/routes.ts`;
+    if (existsSync(routesPath)) {
+        const patchedContent = patchRoutes(readFileSync(routesPath, 'utf8'));
+        if (patchedContent) {
+            writeFileSync(routesPath, patchedContent, 'utf8');
+            patched.push(routesRel);
+        }
+        else {
+            skipped.push(routesRel);
+        }
+    }
+    else {
+        mkdirSync(dirname(routesPath), { recursive: true });
+        writeFileSync(routesPath, renderTemplate('routes.ts.tpl', app), 'utf8');
+        created.push(routesRel);
+    }
+    return { created: created.sort(), skipped: skipped.sort(), patched: patched.sort() };
+}
+/** `gaon g auth` 진입점. 스캐폴드를 쓰고 결과를 사람/JSON 으로 출력한다. */
+export function runGenerateAuthCommand(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const app = opts.app ?? 'web';
+    const result = writeAuthScaffold(cwd, { app });
+    if (opts.json) {
+        process.stdout.write(JSON.stringify({ command: 'g auth', app, ...result }, null, 2) + '\n');
+        return 0;
+    }
+    const lines = [''];
+    lines.push(`  gaon g auth — 인증 스캐폴드 (${app} 앱)`);
+    lines.push('');
+    for (const f of result.created)
+        lines.push(`   + ${f}`);
+    for (const f of result.patched)
+        lines.push(`   ~ ${f} (라우트 추가)`);
+    for (const f of result.skipped)
+        lines.push(`   · ${f} (이미 있음 — 건너뜀)`);
+    lines.push('');
+    lines.push('  다음 단계:');
+    lines.push('   1) gaon dev 로 .gaon 타입 브리지를 생성한다 (tables·routes).');
+    lines.push('   2) gaon db diff && gaon db migrate 로 users 테이블을 만든다.');
+    lines.push('   3) REDIS_URL·SESSION_SECRET·COOKIE_SECRET 을 설정하고 server.ts 를 실행한다.');
+    lines.push('   → /registration/new 회원가입 · /session/new 로그인 · 보호 라우트는 this.requireAuth().');
+    lines.push('');
+    process.stdout.write(lines.join('\n') + '\n');
+    return 0;
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { runDevCommand, startDev, resolveDevLayout, type DevDeps, type DevLayout, type DevApp, type DevEvent, type DevHandle, type DevCommandOptions, } from "./dev.js";
 export { runCheck, runCheckCommand, type CheckDeps, type CheckResult, type TypecheckResult, type CheckCommandOptions, } from "./check.js";
+export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, type AuthScaffoldOptions, type ScaffoldFile, type ScaffoldResult, type GenerateAuthOptions, } from "./generate.js";
 export interface RoadmapReport {
     readonly name: "gaon";
     readonly version: string;

package/dist/index.js

@@ -12,8 +12,10 @@
 import { MILESTONES, VERSION, HOMEPAGE } from "@gaonjs/core";
 import { runDevCommand } from "./dev.js";
 import { runCheckCommand } from "./check.js";
+import { runGenerateAuthCommand } from "./generate.js";
 export { runDevCommand, startDev, resolveDevLayout, } from "./dev.js";
 export { runCheck, runCheckCommand, } from "./check.js";
+export { writeAuthScaffold, authScaffoldFiles, patchRoutes, runGenerateAuthCommand, } from "./generate.js";
 /** `--json` 출력용 구조화 리포트. */
 export function roadmapReport(version = VERSION) {
     return {
@@ -60,6 +62,7 @@ function renderHelp(version = VERSION) {
         "    gaon dev           .gaon 타입 브리지를 감시·재생성 (스키마·라우트)",
         "    gaon dev --json    재생성 이벤트를 JSON 으로 출력",
         "    gaon check         .gaon 재생성 후 타입 검사 (CI·AI 정합)",
+        "    gaon g auth        인증 스캐폴드 생성 (회원가입·로그인·세션·보호 라우트)",
         "    gaon --json        같은 정보를 JSON 으로 출력",
         "    gaon --version     버전 출력",
         "    gaon --help        이 도움말",
@@ -94,6 +97,20 @@ export function runCli(argv, opts = {}) {
         });
         return;
     }
+    // `gaon g auth` — 인증 스캐폴드 제너레이터(§7 M5). 다른 제너레이터는 후속.
+    if (argv[0] === "g" || argv[0] === "generate") {
+        if (argv[1] === "auth") {
+            const appIdx = argv.indexOf("--app");
+            const app = appIdx >= 0 ? argv[appIdx + 1] : undefined;
+            const code = runGenerateAuthCommand({ app, json: argv.includes("--json") });
+            process.exitCode = code;
+            return;
+        }
+        process.stderr.write(`  ✗ 알 수 없는 제너레이터: ${argv[1] ?? "(없음)"}\n` +
+            `  → 현재 지원: gaon g auth [--app <이름>]\n`);
+        process.exitCode = 1;
+        return;
+    }
     if (argv.includes("--help") || argv.includes("-h")) {
         process.stdout.write(renderHelp(version) + "\n");
         return;

package/dist/templates/auth/Dashboard.vue.tpl

@@ -0,0 +1,16 @@
+<script setup lang="ts">
+import { pageProps } from 'gaonjs/vue'
+
+// dashboard#show 의 render props — user 는 직렬화되며 passwordDigest 는 없다(§4.2).
+const { user } = pageProps<'dashboard#show'>()
+</script>
+
+<template>
+  <main>
+    <h1>환영합니다, {{ user.name }}님</h1>
+    <p>{{ user.email }}</p>
+    <form method="post" action="/session?_method=DELETE">
+      <button type="submit">로그아웃</button>
+    </form>
+  </main>
+</template>

package/dist/templates/auth/Login.vue.tpl

@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import { pageProps } from 'gaonjs/vue'
+
+// 컨트롤러 session#new 의 render props 타입이 그대로 흐른다(§6.2).
+const { error, csrf } = pageProps<'session#new'>()
+</script>
+
+<template>
+  <form method="post" action="/session">
+    <input type="hidden" name="_csrf" :value="csrf" />
+    <h1>로그인</h1>
+    <p v-if="error" class="error">{{ error }}</p>
+    <label>이메일 <input name="email" type="email" required /></label>
+    <label>비밀번호 <input name="password" type="password" required /></label>
+    <button type="submit">로그인</button>
+    <a href="/registration/new">회원가입</a>
+  </form>
+</template>

package/dist/templates/auth/Signup.vue.tpl

@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import { pageProps } from 'gaonjs/vue'
+
+const { error, csrf } = pageProps<'registration#new'>()
+</script>
+
+<template>
+  <form method="post" action="/registration">
+    <input type="hidden" name="_csrf" :value="csrf" />
+    <h1>회원가입</h1>
+    <p v-if="error" class="error">{{ error }}</p>
+    <label>이름 <input name="name" required /></label>
+    <label>이메일 <input name="email" type="email" required /></label>
+    <label>비밀번호 <input name="password" type="password" required /></label>
+    <button type="submit">회원가입</button>
+    <a href="/session/new">로그인</a>
+  </form>
+</template>

package/dist/templates/auth/app.ts.tpl

@@ -0,0 +1,29 @@
+// 웹 앱 팩토리 — gaon g auth 스캐폴드. createWebApp 으로 세션·인증을 배선한다.
+import { createApp, type AppSessionOptions } from 'gaonjs/web'
+import appRoutes from './routes.js'
+import session from './controllers/session.js'
+import registration from './controllers/registration.js'
+import dashboard from './controllers/dashboard.js'
+import { loadUser } from './auth.js'
+
+export interface WebAppDeps {
+  /** 세션 설정 — { redisUrl, secret } (또는 redis 인스턴스). */
+  readonly session: AppSessionOptions
+  /** 서명 쿠키/CSRF 용 비밀. */
+  readonly cookieSecret?: string
+}
+
+export function createWebApp(deps: WebAppDeps) {
+  return createApp({
+    apps: [
+      {
+        name: '{{APP_NAME}}',
+        routes: appRoutes,
+        controllers: { session, registration, dashboard },
+        session: deps.session,
+        auth: { loadUser, loginRedirect: '/session/new' },
+      },
+    ],
+    cookieSecret: deps.cookieSecret,
+  })
+}

package/dist/templates/auth/auth.wiring.ts.tpl

@@ -0,0 +1,16 @@
+// 인증 배선 — gaon g auth 스캐폴드.
+import type { AuthOptions } from 'gaonjs/web'
+import { User } from '../../domain/models/user.js'
+
+// 세션에 심긴 userId 로 사용자를 로드한다(§7). web 은 도메인을 loadUser 로 받는다.
+export const loadUser: AuthOptions['loadUser'] = async (id) =>
+  await User.query().where('id', '=', BigInt(String(id))).first()
+
+// this.currentUser 에 User 필드 타입을 얹는다(GaonRouteMap 과 동일 관례).
+declare module 'gaonjs/web' {
+  interface GaonCurrentUser {
+    id: bigint
+    name: string
+    email: string
+  }
+}

package/dist/templates/auth/dashboard.controller.ts.tpl

@@ -0,0 +1,10 @@
+// 보호 라우트 예시 — gaon g auth 스캐폴드. requireAuth 로 지킨다(§7).
+import { controller } from 'gaonjs/web'
+
+export default controller({
+  // GET / — 로그인해야 볼 수 있는 홈. 비로그인은 로그인 페이지로 보내진다.
+  async show() {
+    const user = this.requireAuth()
+    return this.render('Dashboard', { user })
+  },
+})

package/dist/templates/auth/registration.controller.ts.tpl

@@ -0,0 +1,20 @@
+// 회원가입 컨트롤러 — gaon g auth 스캐폴드.
+import { controller, hashPassword } from 'gaonjs/web'
+import { User } from '../../../domain/models/user.js'
+
+export default controller({
+  // GET /registration/new — 회원가입 폼
+  async new() {
+    return this.render('auth/Signup', { error: null as string | null, csrf: this.csrfToken() })
+  },
+  // POST /registration — 회원가입
+  async create() {
+    const { name, email, password } = this.params({
+      _row: {} as { name: string; email: string; password: string },
+    })
+    const passwordDigest = await hashPassword(password)
+    const user = await User.create({ name, email, passwordDigest })
+    this.auth.login(user)
+    return this.redirect('/')
+  },
+})

package/dist/templates/auth/routes.ts.tpl

@@ -0,0 +1,7 @@
+import { routes } from 'gaonjs/web'
+
+export default routes((r) => {
+  r.get('/', 'dashboard#show') // 보호 홈 (gaon g auth)
+  r.resource('session') // 로그인/로그아웃 (gaon g auth)
+  r.resource('registration') // 회원가입 (gaon g auth)
+})

package/dist/templates/auth/server.ts.tpl

@@ -0,0 +1,14 @@
+// 서버 진입점 — gaon g auth 스캐폴드. `node dist/server.js` 로 실행.
+import { createWebApp } from './apps/{{APP_NAME}}/app.js'
+
+const app = await createWebApp({
+  session: {
+    redisUrl: process.env.REDIS_URL ?? 'redis://127.0.0.1:6379',
+    secret: process.env.SESSION_SECRET ?? 'change-me-to-a-32+char-random-secret!!',
+  },
+  cookieSecret: process.env.COOKIE_SECRET,
+})
+
+const port = Number(process.env.PORT ?? 3000)
+await app.listen({ port, host: '0.0.0.0' })
+console.log(`web 앱이 http://localhost:${port} 에서 실행 중입니다.`)

package/dist/templates/auth/session.controller.ts.tpl

@@ -0,0 +1,29 @@
+// 세션 컨트롤러(로그인/로그아웃) — gaon g auth 스캐폴드.
+import { controller, verifyPassword } from 'gaonjs/web'
+import { User } from '../../../domain/models/user.js'
+
+export default controller({
+  // GET /session/new — 로그인 폼
+  async new() {
+    return this.render('auth/Login', { error: null as string | null, csrf: this.csrfToken() })
+  },
+  // POST /session — 로그인
+  async create() {
+    const { email, password } = this.params({ _row: {} as { email: string; password: string } })
+    const user = await User.query().where('email', '=', email).first()
+    // passwordDigest 는 hidden 이지만 서버 코드에서는 투명하게 읽힌다(§4.2).
+    if (user && (await verifyPassword(password, user.passwordDigest))) {
+      this.auth.login(user)
+      return this.redirect('/')
+    }
+    return this.render('auth/Login', {
+      error: '이메일 또는 비밀번호가 올바르지 않습니다.' as string | null,
+      csrf: this.csrfToken(),
+    })
+  },
+  // DELETE /session — 로그아웃
+  async destroy() {
+    this.auth.logout()
+    return this.redirect('/session/new')
+  },
+})

package/dist/templates/auth/user.model.ts.tpl

@@ -0,0 +1,5 @@
+// 사용자 모델 — gaon g auth 스캐폴드.
+import { model } from 'gaonjs/data'
+import { users } from '../schema/user.js'
+
+export const User = model(users, {})

package/dist/templates/auth/user.schema.ts.tpl

@@ -0,0 +1,11 @@
+// 사용자 스키마 — gaon g auth 스캐폴드.
+// 등록 보일러플레이트는 없다 — .gaon/tables.d.ts 가 자동 생성한다(§6.3).
+import { table, t } from 'gaonjs/data'
+
+export const users = table('users', {
+  id: t.id(),
+  name: t.string().max(100),
+  email: t.string().max(255),
+  passwordDigest: t.string().hidden(), // hidden — 페이지로 새지 않는다(§4.2)
+  ...t.timestamps(),
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Gaon CLI 구현: 제너레이터·스캐폴딩·로드맵 출력 (M1 스텁)",
   "type": "module",
   "license": "MIT",
@@ -24,11 +24,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@gaonjs/core": "0.1.2",
-    "@gaonjs/data": "0.2.0",
-    "@gaonjs/web": "0.1.3"
+    "@gaonjs/core": "0.1.3",
+    "@gaonjs/data": "0.2.2",
+    "@gaonjs/web": "0.2.0"
   },
   "scripts": {
-    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json"
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""
   }
 }