mega-framework 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mega-framework",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Node.js 마이크로프레임웍 + CLI — Slim의 가벼움 + Rails의 관례",
   "type": "module",
   "engines": {

package/sample/crud/yarn.lock

@@ -1234,7 +1234,7 @@ marked@^18.0.5:
   integrity sha512-S6GcvALHg6K4ohtu4E7x0a1AqhAjp6cV8KhLSyN9qVapnzJkusVBxZRcIU9AeYsbe6P1hKDusSbEOzGyyuce6w==
 
 "mega-framework@file:../..":
-  version "0.1.3"
+  version "0.1.4"
   dependencies:
     "@fastify/cookie" "^11.0.2"
     "@fastify/cors" "^11.2.0"

package/src/cli/commands/new.js

@@ -1,26 +1,94 @@
 // @ts-check
 /**
- * `mega new <project>` — 빈 폴더에서 멀티앱 hello world 까지 한 명령 스캐폴드 (roadmap §336, ADR-142).
+ * `mega new <project>` — `sample/crud` 데모앱을 그대로 스캐폴드한다(ADR-179, 기존 미니멀/--views 모드 대체).
  *
- * 기본 앱 `main` + `*.localhost` 호스트 + README · `.env.example` · `.gitignore` · `package.json`
- * (scripts + concurrently devDep + PM2 `ecosystem.config.cjs`) 를 만든다. `ejsMate` 옵트인이면 EJS +
- * ejs-mate 뷰 골격(ADR-011/136) + i18next 다국어(ADR-037~039) + Bootstrap 5 디자인(ADR-151)을 더한다 —
- * 뷰 렌더 라우트, ko/en 로케일, 그리고 토큰 치환 없이 그대로 복사하는 정적 자산(vendored Bootstrap +
- * 브랜드 CSS/JS). 신규 dep 설치는 하지 않고(네트워크 회피) 안내만 출력한다.
+ * 빈 폴더에 14개 기능(auth·notes/users CRUD·WS 채팅·jobs·cron·metrics·logs·perf·redis·tracing·upload·
+ * worker·guide)을 모두 갖춘 멀티앱 데모를 찍어낸다. 원본은 레포의 `sample/crud`(npm `files` 에 포함돼
+ * 패키지에도 동봉) 트리를 **바이트 그대로 복사**하고, 프로젝트 이름이 박힌 소수 파일(package.json·README·
+ * ecosystem·.env)만 토큰 치환한다 — `sample-crud` → 프로젝트명, dep `file:../..` → 실제 버전(`^x.y.z`).
+ * 로컬 인프라 기동용 루트 `docker-compose.yml` 도 함께 복사한다(개발자 학습용, ADR-103).
+ *
+ * 복사 제외: 빌드 산출물(node_modules·coverage)·로크파일(package-lock/yarn.lock)·런타임 로그(*.log)·VCS,
+ * 그리고 런타임 업로드 데이터(`var/uploads/*` — 개인정보 포함 가능). 업로드 데모가 쓰는 디렉토리는
+ * 빈 `.gitkeep` 으로만 만든다. 신규 dep 설치는 하지 않고(네트워크 회피) 안내만 출력한다.
  *
  * @module cli/commands/new
  */
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, resolve, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { nameVariants, renderTemplate } from '../template-engine.js'
+import { nameVariants } from '../template-engine.js'
+
+/** 이 파일이 있는 디렉토리(src/cli/commands). 아래 원본 경로의 기준점. */
+const HERE = dirname(fileURLToPath(import.meta.url))
+/** 스캐폴드 원본 = 레포의 `sample/crud` 데모앱(src/cli/commands 기준 3단계 위 + sample/crud). */
+const SAMPLE_ROOT = resolve(HERE, '../../../sample/crud')
+/** 루트 `docker-compose.yml` — 로컬 인프라(postgres·mariadb·mongo·redis·nats·zipkin·otel) 기동용. */
+const COMPOSE_SRC = resolve(HERE, '../../../docker-compose.yml')
+/** 프레임워크 자체 package.json — 스캐폴드 dep 버전 핀(`^x.y.z`) 의 소스. */
+const FRAMEWORK_PKG = resolve(HERE, '../../../package.json')
+
+/** 복사 제외 디렉토리/파일 basename — 빌드 산출물·로크파일·VCS·런타임 데이터 디렉토리. */
+const EXCLUDE_NAMES = new Set([
+  'node_modules',
+  '.git',
+  'coverage',
+  '.nyc_output',
+  '.vitest',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  '.DS_Store',
+])
+/** 복사 제외 상대경로 prefix — 런타임 업로드 산출물(개인정보 포함 가능, 대신 .gitkeep 만 생성). */
+const EXCLUDE_PREFIXES = ['var/uploads']
+/** 프로젝트 이름 토큰 치환을 적용할 텍스트 파일(그 외는 바이트 그대로 복사 — 바이너리 보존). */
+const TRANSFORM_FILES = new Set(['package.json', 'README.md', 'ecosystem.config.cjs', '.env', '.env.example'])
+
+/**
+ * 한 상대경로가 복사 제외 대상인지.
+ * @param {string} rel - POSIX 슬래시 상대경로.
+ * @returns {boolean}
+ */
+function isExcluded(rel) {
+  if (rel.endsWith('.log')) return true
+  if (EXCLUDE_PREFIXES.some((p) => rel === p || rel.startsWith(`${p}/`))) return true
+  return rel.split('/').some((seg) => EXCLUDE_NAMES.has(seg))
+}
 
-/** templates/project 루트. src/cli/commands/new.js 기준 3단계 위 + templates/project. */
-const PROJECT_TEMPLATES = resolve(dirname(fileURLToPath(import.meta.url)), '../../../templates/project')
+/**
+ * 디렉토리를 재귀 순회해 복사 대상 파일의 상대경로(POSIX 슬래시) 목록을 만든다. 제외 디렉토리는
+ * 통째로 건너뛴다(node_modules 등 큰 트리 순회 비용 회피).
+ * @param {string} dir - 현재 순회 디렉토리(절대).
+ * @param {string} base - 상대경로 기준 루트(절대).
+ * @param {string[]} acc - 누적 결과.
+ * @returns {string[]}
+ */
+function walk(dir, base, acc) {
+  for (const ent of readdirSync(dir, { withFileTypes: true })) {
+    const abs = join(dir, ent.name)
+    const rel = relative(base, abs).split(sep).join('/')
+    if (isExcluded(rel)) continue
+    if (ent.isDirectory()) walk(abs, base, acc)
+    else acc.push(rel)
+  }
+  return acc
+}
 
-/** 프로젝트 템플릿을 읽어 토큰 치환. @param {string} file @param {Record<string,string>} vars @returns {string} */
-function renderProject(file, vars) {
-  return renderTemplate(readFileSync(join(PROJECT_TEMPLATES, file), 'utf8'), vars)
+/**
+ * 토큰 치환 — `sample-crud` 를 프로젝트명으로, package.json 의 모노레포 dep(`file:../..`)을 실제 버전으로.
+ * @param {string} rel - 파일 상대경로.
+ * @param {string} content - 원본 텍스트.
+ * @param {{ name: string, version: string }} vars
+ * @returns {string}
+ */
+function transformText(rel, content, vars) {
+  let out = content.replaceAll('sample-crud', vars.name)
+  if (rel === 'package.json') {
+    // 모노레포 로컬 링크 → 퍼블리시된 프레임워크 버전 핀. 스캐폴드된 프로젝트는 독립 패키지라 file: 가 안 풀린다.
+    out = out.replace('"file:../.."', `"^${vars.version}"`)
+  }
+  return out
 }
 
 /**
@@ -28,74 +96,54 @@ function renderProject(file, vars) {
  * @param {string} targetDir - 프로젝트 루트 절대/상대 경로.
  * @param {object} [opts]
  * @param {string} [opts.name] - 프로젝트 이름(기본: targetDir 의 마지막 세그먼트).
- * @param {boolean} [opts.ejsMate] - EJS + ejs-mate 뷰 골격 포함(기본 false).
  * @param {boolean} [opts.force] - 기존 파일 덮어쓰기(기본 false — 건너뜀).
  * @returns {{ root: string, written: string[], skipped: string[] }}
  */
-export function scaffoldProject(targetDir, { name, ejsMate = false, force = false } = {}) {
+export function scaffoldProject(targetDir, { name, force = false } = {}) {
   const root = resolve(targetDir)
   const projectName = nameVariants(name ?? root.split(/[/\\]/).pop() ?? 'mega-app').kebab
-  const vars = { name: projectName, Name: nameVariants(projectName).pascal }
-
-  // 뷰 옵트인이면 GET / 를 뷰 렌더로 바꾸고(JSON hello 대신) 그에 맞는 테스트를 쓴다.
-  /** @type {Array<{ rel: string, tpl: string }>} */
-  const files = [
-    { rel: 'mega.config.js', tpl: 'mega.config.tpl' },
-    { rel: 'apps/main/app.config.js', tpl: ejsMate ? 'app.config.views.tpl' : 'app.config.tpl' },
-    { rel: 'apps/main/routes/index.js', tpl: ejsMate ? 'route.views.tpl' : 'route.tpl' },
-    { rel: 'test/apps/main/index.test.js', tpl: ejsMate ? 'route.test.views.tpl' : 'route.test.tpl' },
-    { rel: 'package.json', tpl: 'package.tpl' },
-    { rel: 'README.md', tpl: 'readme.tpl' },
-    { rel: '.env.example', tpl: 'env.tpl' },
-    { rel: '.gitignore', tpl: 'gitignore.tpl' },
-    { rel: 'vitest.config.js', tpl: 'vitest.config.tpl' },
-    { rel: 'ecosystem.config.cjs', tpl: 'ecosystem.config.tpl' },
-  ]
-  if (ejsMate) {
-    files.push(
-      { rel: 'apps/main/views/layouts/main.ejs', tpl: 'views/layout.ejs.tpl' },
-      { rel: 'apps/main/views/index.ejs', tpl: 'views/index.ejs.tpl' },
-      { rel: 'apps/main/locales/server/ko.json', tpl: 'locales/server/ko.json.tpl' },
-      { rel: 'apps/main/locales/server/en.json', tpl: 'locales/server/en.json.tpl' },
-      { rel: 'apps/main/locales/client/ko.json', tpl: 'locales/client/ko.json.tpl' },
-      { rel: 'apps/main/locales/client/en.json', tpl: 'locales/client/en.json.tpl' },
-    )
-  }
-
-  // 정적 자산 — 토큰 치환 없이 바이트 그대로 복사한다(vendored Bootstrap 5 min 번들 + 브랜드 CSS/JS).
-  // 이들은 템플릿이 아니라 정적 파일이므로 renderTemplate(`{{token}}`)을 거치지 않는다.
-  /** @type {Array<{ rel: string, src: string }>} */
-  const assets = ejsMate
-    ? [
-        { rel: 'apps/main/public/vendor/bootstrap/bootstrap.min.css', src: 'public/vendor/bootstrap/bootstrap.min.css' },
-        { rel: 'apps/main/public/vendor/bootstrap/bootstrap.bundle.min.js', src: 'public/vendor/bootstrap/bootstrap.bundle.min.js' },
-        { rel: 'apps/main/public/css/app.css', src: 'public/css/app.css' },
-        { rel: 'apps/main/public/js/app.js', src: 'public/js/app.js' },
-        { rel: 'apps/main/public/js/theme-init.js', src: 'public/js/theme-init.js' },
-      ]
-    : []
+  /** @type {string} */
+  const version = JSON.parse(readFileSync(FRAMEWORK_PKG, 'utf8')).version
+  const vars = { name: projectName, version }
 
   /** @type {string[]} */ const written = []
   /** @type {string[]} */ const skipped = []
-  for (const { rel, tpl } of files) {
-    const out = join(root, rel)
+
+  /**
+   * 출력 파일 1개를 기록(존재 + !force 면 skip).
+   * @param {string} out - 출력 절대경로.
+   * @param {() => void} write - 실제 기록 동작.
+   */
+  const emit = (out, write) => {
     if (existsSync(out) && !force) {
       skipped.push(out)
-      continue
+      return
     }
     mkdirSync(dirname(out), { recursive: true })
-    writeFileSync(out, renderProject(tpl, vars))
+    write()
     written.push(out)
   }
-  for (const { rel, src } of assets) {
+
+  // 1) sample/crud 트리 복사(제외 규칙 적용). 토큰 치환 대상만 텍스트로 렌더, 그 외는 바이트 그대로.
+  for (const rel of walk(SAMPLE_ROOT, SAMPLE_ROOT, [])) {
+    const src = join(SAMPLE_ROOT, rel)
     const out = join(root, rel)
-    if (existsSync(out) && !force) {
-      skipped.push(out)
-      continue
-    }
-    mkdirSync(dirname(out), { recursive: true })
-    copyFileSync(join(PROJECT_TEMPLATES, src), out)
-    written.push(out)
+    emit(out, () => {
+      if (TRANSFORM_FILES.has(rel)) {
+        writeFileSync(out, transformText(rel, readFileSync(src, 'utf8'), vars))
+      } else {
+        copyFileSync(src, out)
+      }
+    })
   }
+
+  // 2) 루트 docker-compose.yml — 로컬 인프라(개발자 학습용). 프로젝트 이름과 무관해 그대로 복사.
+  const compose = join(root, 'docker-compose.yml')
+  emit(compose, () => copyFileSync(COMPOSE_SRC, compose))
+
+  // 3) 업로드 데모가 쓰는 디렉토리 placeholder — 실제 업로드 데이터(개인정보 PDF 등)는 동봉하지 않는다.
+  const gitkeep = join(root, 'var/uploads/.gitkeep')
+  emit(gitkeep, () => writeFileSync(gitkeep, ''))
+
   return { root, written, skipped }
 }

package/src/cli/commands/scaffold.js

@@ -7,7 +7,6 @@
  * @module cli/commands/scaffold
  */
 import { Command } from 'commander'
-import prompts from 'prompts'
 import { generate, GENERATOR_KINDS } from '../generators/index.js'
 import { scaffoldProject } from './new.js'
 import { runRoutesCommand } from './routes.js'
@@ -50,21 +49,16 @@ export async function runScaffoldCommand(argv, { out, err, projectRoot, logger }
 
   program
     .command('new <project>')
-    .description('빈 폴더에서 멀티앱 hello world 스캐폴드')
-    .option('--views', 'EJS + ejs-mate 뷰 골격 포함')
+    .description('sample/crud 데모앱(14기능) 전체를 빈 폴더에 스캐폴드')
     .option('--force', '기존 파일 덮어쓰기')
-    .action(async (/** @type {string} */ project, /** @type {any} */ opts) => {
-      // --views 미지정 + 대화형 터미널이면 ejs-mate 옵트인을 묻는다(비-TTY/CI 는 기본 false).
-      let ejsMate = opts.views === true
-      if (opts.views === undefined && process.stdin.isTTY) {
-        const ans = /** @type {any} */ (await prompts({ type: 'confirm', name: 'views', message: 'EJS + ejs-mate 뷰 골격을 포함할까요?', initial: false }))
-        ejsMate = ans.views === true
-      }
+    .action((/** @type {string} */ project, /** @type {any} */ opts) => {
       const target = project === '.' ? projectRoot : `${projectRoot}/${project}`
-      const r = scaffoldProject(target, { name: project === '.' ? undefined : project, ejsMate, force: opts.force === true })
+      const r = scaffoldProject(target, { name: project === '.' ? undefined : project, force: opts.force === true })
       out(`mega: scaffolded project at ${r.root}`)
       reportFiles(out, r, r.root)
-      out('\n다음 단계:\n  cd ' + project + '\n  npm install\n  npm run dev')
+      // 풀 데모는 로컬 인프라(postgres·redis·mongo·nats)가 있어야 부팅된다 — docker compose 로 띄운 뒤 마이그레이션.
+      const cd = project === '.' ? '' : `  cd ${project}\n`
+      out(`\n다음 단계:\n${cd}  npm install\n  docker compose up -d        # 로컬 인프라 기동(postgres·redis·mongo·nats)\n  npm run migrate             # DB 스키마 생성\n  npm run dev                 # 개발 서버`)
     })
 
   program

package/src/cli/index.js

@@ -45,7 +45,7 @@ Usage:
   mega migrate [--db KEY] [--root DIR]             pending 마이그레이션 일괄 적용(up)
   mega migrate:down [--db KEY]                      마지막 적용 마이그레이션 1개 롤백(down)
   mega migrate:status [--db KEY]                    적용/미적용 마이그레이션 목록
-  mega new <project> [--views] [--force]           빈 폴더에서 멀티앱 hello world 스캐폴드
+  mega new <project> [--force]                     sample/crud 데모앱(14기능) 전체를 스캐폴드
   mega g <kind> <name> [--app A] [--version vN]    코드+테스트 생성 (별칭: generate)
                        [--kind K] [--lng L] [--force]
   mega routes [--root DIR]                          등록 라우트 트리 출력

package/sample/crud/test/apps/main/auth-flow.integration.test.js

@@ -1,177 +0,0 @@
-// @ts-check
-/**
- * 인증 흐름 통합 테스트(ADR-155) — 실 redis(세션·brute-force) + postgres 로 sample/crud 를 부팅하고
- * HTTP 전 경로(회원가입→자동로그인→보호자원→로그아웃→차단, 잘못된 비밀번호→brute-force 잠금)를 검증한다.
- *
- * 인프라(redis·pg) env 가 없으면 통째로 skip 한다(단위 테스트는 `auth-service.test.js` 가 인프라 없이 커버).
- * 실행에 필요한 env(.env): DATABASE_URL(또는 PG_URL)·REDIS_SESSION_URL·REDIS_RATE_URL·SESSION_SECRET.
- *
- * CSRF(쿠키 double-submit, ADR-051)가 켜져 있어 POST 마다 폼 토큰+쿠키를 왕복시킨다 — 실제 브라우저 폼과
- * 같은 경로다. 세션 쿠키(mega.sid)도 누적 쿠키 jar 로 왕복한다.
- */
-import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-import { bootApp, MegaShutdown } from 'mega-framework'
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
-import { User } from '../../../apps/main/models/user.js'
-
-// 프로젝트 루트(mega.config.js 가 있는 sample/crud) — 이 파일 기준 상위 4단계.
-const PROJECT = resolve(dirname(fileURLToPath(import.meta.url)), '../../..')
-
-// .env 가 DATABASE_URL 대신 PG_URL 만 줄 수 있으므로(로컬 관례) 매핑한다.
-if (!process.env.DATABASE_URL && process.env.PG_URL) process.env.DATABASE_URL = process.env.PG_URL
-
-const hasInfra = Boolean(process.env.DATABASE_URL && process.env.REDIS_SESSION_URL && process.env.REDIS_RATE_URL && process.env.SESSION_SECRET)
-const d = hasInfra ? describe : describe.skip
-
-/** set-cookie 를 누적 쿠키 jar 에 반영(maxAge=0 → 삭제). @param {any} res @param {Record<string,string>} jar */
-function applyCookies(res, jar) {
-  const raw = res.headers['set-cookie']
-  const arr = Array.isArray(raw) ? raw : raw ? [raw] : []
-  for (const c of arr) {
-    const pair = String(c).split(';')[0]
-    const eq = pair.indexOf('=')
-    if (eq === -1) continue
-    const name = pair.slice(0, eq).trim()
-    const val = pair.slice(eq + 1).trim()
-    if (val === '') delete jar[name]
-    else jar[name] = val
-  }
-}
-
-/** @param {Record<string,string>} jar @returns {string} Cookie 헤더. */
-function cookieHeader(jar) {
-  return Object.entries(jar).map(([k, v]) => `${k}=${v}`).join('; ')
-}
-
-/** 렌더된 폼 HTML 에서 hidden `_csrf` 토큰을 뽑는다. @param {string} html @returns {string} */
-function csrfFrom(html) {
-  const m = /name="_csrf" value="([^"]+)"/.exec(html)
-  if (!m) throw new Error('csrf token not found in form HTML')
-  return m[1]
-}
-
-/** urlencoded 폼 바디 직렬화. @param {Record<string,string>} fields @returns {string} */
-function form(fields) {
-  return Object.entries(fields).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&')
-}
-
-d('인증 흐름 E2E — sample/crud 실 redis+pg (ADR-155)', () => {
-  /** @type {Awaited<ReturnType<typeof bootApp>>} */
-  let boot
-  /** @type {any} */
-  let fastify
-  const EMAIL = `itest-auth-${Date.now()}@example.com`
-  const PASSWORD = 'secret-pass-123'
-  const NAME = 'Auth Tester'
-
-  beforeAll(async () => {
-    MegaShutdown._reset()
-    boot = await bootApp(PROJECT, { listen: false })
-    const app = boot.megaApps.find((a) => a.name === 'main')
-    fastify = app?.fastify
-    await fastify.ready() // onReady → 세션 store connect(실 redis).
-    // 스키마 보장(마이그레이션과 동치, 멱등) — 테스트 전제. 실제 운영은 `mega migrate` 가 적용한다.
-    await User.query('CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE, created_at TIMESTAMPTZ NOT NULL DEFAULT now())')
-    await User.query('ALTER TABLE users ADD COLUMN IF NOT EXISTS password_hash TEXT')
-    await User.query('ALTER TABLE users ADD COLUMN IF NOT EXISTS last_login_at TIMESTAMPTZ')
-    await User.query('DELETE FROM users WHERE email = $1', [EMAIL])
-  })
-
-  afterAll(async () => {
-    if (!boot) return
-    await User.query('DELETE FROM users WHERE email = $1', [EMAIL]).catch(() => {})
-    await fastify?.close().catch(() => {})
-    const app = boot.megaApps.find((a) => a.name === 'main')
-    await app?.sessionStore?.disconnect().catch(() => {})
-    await boot.ctx.cache('rate').disconnect().catch(() => {})
-    await boot.ctx.db('primary').disconnect().catch(() => {})
-    MegaShutdown._reset()
-  })
-
-  test('비로그인: 랜딩(/)은 공개 200, /admin/users 는 로그인으로 302, /users API 는 401', async () => {
-    const home = await fastify.inject({ method: 'GET', url: '/' })
-    expect(home.statusCode).toBe(200)
-
-    const admin = await fastify.inject({ method: 'GET', url: '/admin/users' })
-    expect(admin.statusCode).toBe(302)
-    expect(admin.headers.location).toBe('/auth/login')
-
-    const api = await fastify.inject({ method: 'GET', url: '/users' })
-    expect(api.statusCode).toBe(401)
-    expect(api.json().error?.code).toBe('auth.required')
-  })
-
-  test('회원가입 → 자동 로그인 → 보호자원 접근 → API 접근 → 로그아웃 → 재차단', async () => {
-    /** @type {Record<string,string>} */
-    const jar = {}
-
-    // 1) 회원가입 폼 GET — _csrf 쿠키 + 토큰 확보.
-    const regForm = await fastify.inject({ method: 'GET', url: '/register' })
-    expect(regForm.statusCode).toBe(200)
-    applyCookies(regForm, jar)
-    const regToken = csrfFrom(regForm.body)
-
-    // 2) 회원가입 POST — 성공 시 자동 로그인(세션 발급) + /admin/users 로 302.
-    const reg = await fastify.inject({
-      method: 'POST',
-      url: '/register',
-      headers: { cookie: cookieHeader(jar), 'content-type': 'application/x-www-form-urlencoded' },
-      payload: form({ _csrf: regToken, name: NAME, email: EMAIL, password: PASSWORD }),
-    })
-    expect(reg.statusCode).toBe(302)
-    expect(reg.headers.location).toBe('/admin/users?notice=registered')
-    applyCookies(reg, jar)
-    expect(jar['mega.sid']).toBeTruthy() // 세션 쿠키 발급됨.
-
-    // 3) 보호 자원 GET — 세션 쿠키로 통과(200), 본문에 로그인 사용자 이름 표시.
-    const admin = await fastify.inject({ method: 'GET', url: '/admin/users', headers: { cookie: cookieHeader(jar) } })
-    expect(admin.statusCode).toBe(200)
-    expect(admin.body).toContain(NAME)
-    applyCookies(admin, jar)
-
-    // 4) JSON API GET — 같은 세션으로 통과(envelope ok).
-    const api = await fastify.inject({ method: 'GET', url: '/users', headers: { cookie: cookieHeader(jar) } })
-    expect(api.statusCode).toBe(200)
-    expect(api.json().ok).toBe(true)
-
-    // 5) 로그아웃 POST — 보호 페이지에서 받은 _csrf 토큰으로.
-    const logoutToken = csrfFrom(admin.body)
-    const logout = await fastify.inject({
-      method: 'POST',
-      url: '/auth/logout',
-      headers: { cookie: cookieHeader(jar), 'content-type': 'application/x-www-form-urlencoded' },
-      payload: form({ _csrf: logoutToken }),
-    })
-    expect(logout.statusCode).toBe(302)
-    expect(logout.headers.location).toBe('/auth/login?notice=logged_out')
-    applyCookies(logout, jar)
-
-    // 6) 로그아웃 후 보호 자원 재차단(302 → 로그인).
-    const blocked = await fastify.inject({ method: 'GET', url: '/admin/users', headers: { cookie: cookieHeader(jar) } })
-    expect(blocked.statusCode).toBe(302)
-    expect(blocked.headers.location).toBe('/auth/login')
-  })
-
-  test('잘못된 비밀번호 반복 → brute-force 잠금(423)', async () => {
-    const lockEmail = `itest-lock-${Date.now()}@example.com`
-    // 잠금 임계(기본 maxAttempts=5)까지 틀린 로그인을 반복한다. 없는 계정이라도 brute-force 는 subject(IP:email) 기준.
-    let lastStatus = 0
-    for (let i = 0; i < 6; i++) {
-      /** @type {Record<string,string>} */
-      const jar = {}
-      const formPage = await fastify.inject({ method: 'GET', url: '/auth/login' })
-      applyCookies(formPage, jar)
-      const token = csrfFrom(formPage.body)
-      const res = await fastify.inject({
-        method: 'POST',
-        url: '/auth/login',
-        headers: { cookie: cookieHeader(jar), 'content-type': 'application/x-www-form-urlencoded' },
-        payload: form({ _csrf: token, email: lockEmail, password: 'definitely-wrong' }),
-      })
-      lastStatus = res.statusCode
-    }
-    // 임계 도달 후에는 잠금(423)으로 응답한다(401 invalid 가 아니라).
-    expect(lastStatus).toBe(423)
-  })
-})

package/sample/crud/test/apps/main/auth-service.test.js

@@ -1,93 +0,0 @@
-// @ts-check
-/**
- * AuthService 단위 테스트(ADR-155) — 모델(static)을 스파이로 갈음해 DB 없이 비즈니스 로직을 검증한다.
- * 해싱은 실 MegaHash(scrypt)를 그대로 써서 register→authenticate 왕복이 진짜로 맞물리는지 본다(인프라 불필요).
- */
-import { describe, test, expect, vi, afterEach } from 'vitest'
-import { AuthService } from '../../../apps/main/services/auth-service.js'
-import { User } from '../../../apps/main/models/user.js'
-
-/** @returns {AuthService} */
-function makeService() {
-  return new AuthService(/** @type {any} */ ({ log: { debug() {} } }))
-}
-
-afterEach(() => vi.restoreAllMocks())
-
-describe('AuthService.register', () => {
-  test('유효 입력 → 해시 후 User.register 위임(평문 미저장)', async () => {
-    const reg = vi
-      .spyOn(User, 'register')
-      .mockResolvedValue(/** @type {any} */ ({ id: 1, name: 'Ada', email: 'ada@x.io', created_at: 't' }))
-    const out = await makeService().register({ name: ' Ada ', email: ' Ada@X.io ', password: 'secret-12' })
-    expect(out).toEqual({ id: 1, name: 'Ada', email: 'ada@x.io', created_at: 't' })
-    const arg = reg.mock.calls[0][0]
-    expect(arg.name).toBe('Ada') // trim.
-    expect(arg.email).toBe('ada@x.io') // trim + lowercase.
-    expect(arg.passwordHash).toMatch(/^\$scrypt\$/) // 평문이 아니라 scrypt 해시.
-    expect(arg.passwordHash).not.toContain('secret-12')
-  })
-
-  test('이름/이메일 누락 → MegaValidationError(auth.invalid)', async () => {
-    await expect(makeService().register({ name: '', email: 'a@b.c', password: 'secret-12' })).rejects.toMatchObject({
-      code: 'auth.invalid',
-    })
-  })
-
-  test('비밀번호 8자 미만 → MegaValidationError(auth.invalid)', async () => {
-    await expect(makeService().register({ name: 'Ada', email: 'a@b.c', password: 'short' })).rejects.toMatchObject({
-      code: 'auth.invalid',
-    })
-  })
-
-  test('이메일 중복(23505) → MegaConflictError(user.email_taken)', async () => {
-    vi.spyOn(User, 'register').mockRejectedValue(/** @type {any} */ (Object.assign(new Error('dup'), { code: '23505' })))
-    await expect(makeService().register({ name: 'Ada', email: 'a@b.c', password: 'secret-12' })).rejects.toMatchObject({
-      status: 409,
-      code: 'user.email_taken',
-    })
-  })
-})
-
-describe('AuthService.authenticate', () => {
-  test('올바른 비밀번호 → 신원 반환 + last_login 갱신', async () => {
-    const { MegaHash } = await import('mega-framework')
-    const hash = await MegaHash.password.hash('secret-12')
-    vi.spyOn(User, 'findByEmailWithHash').mockResolvedValue(
-      /** @type {any} */ ({ id: 7, name: 'Ada', email: 'ada@x.io', password_hash: hash }),
-    )
-    const touch = vi.spyOn(User, 'touchLastLogin').mockResolvedValue(undefined)
-    const out = await makeService().authenticate({ email: 'Ada@X.io', password: 'secret-12' })
-    expect(out).toEqual({ id: 7, name: 'Ada' })
-    expect(touch).toHaveBeenCalledWith(7)
-  })
-
-  test('틀린 비밀번호 → null(이유 비노출), last_login 미갱신', async () => {
-    const { MegaHash } = await import('mega-framework')
-    const hash = await MegaHash.password.hash('secret-12')
-    vi.spyOn(User, 'findByEmailWithHash').mockResolvedValue(
-      /** @type {any} */ ({ id: 7, name: 'Ada', email: 'ada@x.io', password_hash: hash }),
-    )
-    const touch = vi.spyOn(User, 'touchLastLogin').mockResolvedValue(undefined)
-    expect(await makeService().authenticate({ email: 'ada@x.io', password: 'wrong-pass' })).toBeNull()
-    expect(touch).not.toHaveBeenCalled()
-  })
-
-  test('없는 이메일 → null', async () => {
-    vi.spyOn(User, 'findByEmailWithHash').mockResolvedValue(null)
-    expect(await makeService().authenticate({ email: 'nope@x.io', password: 'secret-12' })).toBeNull()
-  })
-
-  test('비밀번호 미설정 계정(admin CRUD 생성) → null', async () => {
-    vi.spyOn(User, 'findByEmailWithHash').mockResolvedValue(
-      /** @type {any} */ ({ id: 3, name: 'NoPass', email: 'np@x.io', password_hash: null }),
-    )
-    expect(await makeService().authenticate({ email: 'np@x.io', password: 'secret-12' })).toBeNull()
-  })
-
-  test('이메일/비밀번호 공란 → null(조회 안 함)', async () => {
-    const find = vi.spyOn(User, 'findByEmailWithHash').mockResolvedValue(null)
-    expect(await makeService().authenticate({ email: '', password: '' })).toBeNull()
-    expect(find).not.toHaveBeenCalled()
-  })
-})