mega-framework 0.1.3 → 0.1.5

package/src/lib/logger/telegram-transport.js

@@ -61,6 +61,8 @@ export function httpsPost(url, body, { request = httpsRequestRaw, timeoutMs = 10
  * @param {string} [opts.retryDir] - retry queue 디렉터리(디폴트 './logs/telegram-retry').
  * @param {string} [opts.serviceName]
  * @param {number} [opts.retryDrainMs] - retry 드레인 주기(디폴트 30_000).
+ * @param {number} [opts.retryMaxEntries] - retry 큐 보관 최대 항목 수(디폴트 5000, 0=무제한, H4 cap).
+ * @param {number} [opts.retryMaxAgeMs] - retry 항목 최대 보존 ms(디폴트 24h, 0=무제한, H4 cap).
  * @param {(url: string, body: string) => Promise<{ statusCode: number }>} [opts.httpsRequest] - HTTP 주입(기본=httpsPost). 단위 테스트용 seam(ADR-165 동일 패턴) — pino worker 는 미전달.
  * @returns {import('node:stream').Writable}
  */
@@ -73,10 +75,20 @@ export default function telegramTransport(opts) {
     retryDir = './logs/telegram-retry',
     serviceName = 'mega',
     retryDrainMs = 30_000,
+    retryMaxEntries = 5000,
+    retryMaxAgeMs = 86_400_000,
     httpsRequest = httpsPost,
   } = opts
   const throttle = createThrottle(throttleMax, throttleWindowMs)
-  const queue = new RetryQueue(join(retryDir, 'telegram-retry.jsonl'))
+  /** throttle 로 드롭된 메시지 수(폭주 억제) — 주기적으로 관측 노출(silent 드롭 사각 제거). */
+  let droppedByThrottle = 0
+  // retry queue cap(H4) — 무한 디스크/메모리 증가 방지. cap 드롭은 stderr 로 관측(텔레그램 sink 라
+  // logger 재귀를 피해 process.stderr 직접 사용).
+  const queue = new RetryQueue(join(retryDir, 'telegram-retry.jsonl'), {
+    maxEntries: retryMaxEntries,
+    maxAgeMs: retryMaxAgeMs,
+    onDrop: (n) => process.stderr.write(`[telegram-transport] dropped ${n} stale/over-cap retry entries (H4 cap)\n`),
+  })
 
   /** 한 건 전송 시도 — 실패/throw 시 retry queue 로. */
   async function trySend(/** @type {string} */ text) {
@@ -92,6 +104,11 @@ export default function telegramTransport(opts) {
   // 주기 드레인 — 쌓인 실패분을 재전송(여전히 실패하면 다시 큐로). unref 로 프로세스 종료 막지 않음.
   /** @returns {Promise<void>} 쌓인 실패분 재전송(여전히 실패하면 trySend 가 다시 큐로). */
   const drainTick = async () => {
+    // throttle 로 조용히 드롭된 수를 주기적으로 노출(관측 사각 제거, Med). stderr 직접(logger 재귀 회피).
+    if (droppedByThrottle > 0) {
+      process.stderr.write(`[telegram-transport] throttled-dropped ${droppedByThrottle} messages in last window\n`)
+      droppedByThrottle = 0
+    }
     const pending = await queue.drain().catch(() => /** @type {string[]} */ ([]))
     for (const text of pending) await trySend(text)
   }
@@ -113,7 +130,10 @@ export default function telegramTransport(opts) {
         } catch {
           continue // 손상 라인 skip — 다음 라인 계속.
         }
-        if (!throttle.tryAcquire(Date.now())) continue // 폭주 억제(초과분 드롭).
+        if (!throttle.tryAcquire(Date.now())) {
+          droppedByThrottle++ // 폭주 억제(초과분 드롭) — 수를 세어 drainTick 에서 관측 노출.
+          continue
+        }
         void trySend(formatMessage(record, serviceName))
       }
       cb()

package/src/lib/mega-job-queue.js

@@ -62,6 +62,19 @@ const NOT_FOUND_CODE = '404'
 /** DLQ 스트림 `max_age` 디폴트(ms) — 7일. 무한 적재 방지(ADR-134). `dlqMaxAgeMs: 0` 으로 끌 수 있다. */
 export const DEFAULT_DLQ_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000
 
+/** DLQ 봉투에 싣는 error.stack 최대 길이(자) — poison 잡 폭주 시 DLQ 비대 방지(Med). */
+const DLQ_MAX_STACK_LEN = 4000
+
+/**
+ * DLQ 봉투용 stack 문자열을 상한으로 자른다. 초과 시 말미에 잘림 표식을 붙인다.
+ * @param {string | undefined} stack
+ * @returns {string | undefined}
+ */
+function truncateStack(stack) {
+  if (typeof stack !== 'string' || stack.length <= DLQ_MAX_STACK_LEN) return stack
+  return stack.slice(0, DLQ_MAX_STACK_LEN) + `\n… [truncated ${stack.length - DLQ_MAX_STACK_LEN} chars]`
+}
+
 /**
  * @typedef {Object} MegaJobQueueOptions
  * @property {import('nats').NatsConnection} nc - **연결된** NatsConnection(`ctx.bus(alias).native`).
@@ -387,6 +400,11 @@ export class MegaJobQueue extends EventEmitter {
    * (소비 워커 라이프사이클·bus 별명 배선은 `MegaJobWorker` 영역 — 본 메서드는 "처리 베이스".
    * 정본 `MegaWorker` = CPU `worker_threads` 풀로 별개 추상(ADR-120/ADR-121).)
    *
+   * ⚠️ **head-of-line blocking 운영 주의(Med)**: in-flight 상한은 `concurrency`(= `max_ack_pending`)다.
+   * 일시 장애로 **모든 in-flight 가 동시에 긴 백오프**(`static backoff.max` 큼 + `retries` 많음)에 들어가면
+   * 그 subject 처리량이 0 에 수렴하고 정상 메시지도 뒤에서 대기한다(메모리는 안전 — 무한 증가 X). 큰
+   * backoff 를 쓰면 `concurrency` 를 충분히 키우고, 재시도 적체를 메트릭(`job:start`/`fail` 이벤트)으로 관측하라.
+   *
    * @param {typeof MegaJob} JobClass @param {MegaJob} instance - `run` 호출 대상(서브클래스 인스턴스).
    * @param {Record<string, any>} ctx - run 에 넘길 컨텍스트.
    * @returns {Promise<{ stop: () => Promise<void> }>}
@@ -489,9 +507,11 @@ export class MegaJobQueue extends EventEmitter {
     this.#safeEmit('start', { subject, seq })
     let settled = false
     // 재시도 동안 메시지를 점유하므로 ack_wait 만료(→중복 재전달)를 막기 위해 working() 으로 lease 갱신.
+    // unref — in-flight 잡이 길게 돌아도 이 타이머가 프로세스 자연 종료를 막지 않게(형제 모듈 정합, Med).
     const heartbeat = setInterval(() => {
       if (!settled) msg.working()
     }, this.#heartbeatMs)
+    if (typeof heartbeat.unref === 'function') heartbeat.unref()
 
     // run(재시도) 결과를 변수에 담는다 — ack/DLQ(부작용) + emit 은 try/catch **밖**에서 처리한다(M-3·L-3).
     // 이유: emit('done')/emit('fail') 리스너가 throw 했을 때 run 의 catch 가 잡으면 성공 잡이 spurious
@@ -546,7 +566,8 @@ export class MegaJobQueue extends EventEmitter {
           originalSubject: subject,
           failedAt: new Date().toISOString(),
           deliveryCount: msg.info.deliveryCount,
-          error: { name: error.name, message: error.message, stack: error.stack },
+          // stack 전체를 봉투에 담으면 poison 잡 폭주 시 DLQ 직렬화 비용·디스크가 급증한다 → 상한으로 truncate(Med).
+          error: { name: error.name, message: error.message, stack: truncateStack(error.stack) },
           payload,
         }),
       )

package/src/lib/mega-logger.js

@@ -92,11 +92,49 @@ export function buildTargets(sinks, level) {
   return targets
 }
 
+/**
+ * 기본 시크릿 redact 경로(ADR-023, H2 보안). 사용자가 `logger.redact` 를 지정하지 않아도 **항상** 적용해
+ * 토큰·비밀번호·인증 헤더가 stdout/파일/텔레그램(외부 sink)으로 평문 유출되는 것을 막는다(CLAUDE.md P5).
+ * pino(fast-redact) 경로 문법으로 부팅 시 1회 검증됨(leading wildcard `*.x` 포함). 사용자 redact 는 병합된다.
+ * @type {ReadonlyArray<string>}
+ */
+export const DEFAULT_REDACT_PATHS = Object.freeze([
+  'req.headers.authorization',
+  'req.headers.cookie',
+  '*.password',
+  '*.token',
+  '*.secret',
+  '*.accessToken',
+  '*.refreshToken',
+  '*.apiKey',
+])
+
+/**
+ * 사용자 redact 설정(배열 또는 `{ paths, censor?, remove? }`)을 기본 경로와 **병합**한다(중복 제거).
+ * 사용자가 미지정이어도 기본 경로는 항상 적용된다.
+ * @param {unknown} userRedact
+ * @returns {{ paths: string[], censor?: any, remove?: boolean }}
+ */
+function mergeRedact(userRedact) {
+  /** @type {string[]} */
+  let userPaths = []
+  /** @type {Record<string, any>} */
+  let extra = {}
+  if (Array.isArray(userRedact)) {
+    userPaths = userRedact.filter((p) => typeof p === 'string')
+  } else if (userRedact && typeof userRedact === 'object' && Array.isArray(/** @type {any} */ (userRedact).paths)) {
+    const { paths, ...rest } = /** @type {any} */ (userRedact)
+    userPaths = paths.filter((/** @type {any} */ p) => typeof p === 'string')
+    extra = rest // censor/remove 보존.
+  }
+  return { paths: [...new Set([...DEFAULT_REDACT_PATHS, ...userPaths])], ...extra }
+}
+
 /**
  * `logger` config → pino 옵션(또는 비활성 시 `null`). Fastify `logger` 또는 `pino()` 에 그대로 전달 가능.
  *
  * @param {unknown} config - `MegaLoggerConfig`(`{ level, sinks, redact?, includeRequestId? }`).
- * @returns {{ level: string, mixin: Function, redact?: string[], transport: { targets: any[] } } | null}
+ * @returns {{ level: string, mixin: Function, redact: { paths: string[] }, transport: { targets: any[] } } | null}
  */
 export function buildLoggerOptions(config) {
   if (!config || typeof config !== 'object') return null
@@ -109,7 +147,8 @@ export function buildLoggerOptions(config) {
     level,
     // trace_id/span_id 자동 주입(ADR-116) — 활성 span 없으면 빈 객체(0 비용).
     mixin: MegaTracing.logMixin,
-    ...(Array.isArray(c.redact) && c.redact.length > 0 ? { redact: c.redact } : {}),
+    // 기본 시크릿 redact 를 **항상** 적용 + 사용자 설정 병합(H2 보안). 미지정이어도 마스킹된다.
+    redact: mergeRedact(c.redact),
     transport: { targets },
   }
 }

package/src/lib/mega-shutdown.js

@@ -31,6 +31,12 @@ let isShuttingDownFlag = false
 let gracePeriodMs = 30_000
 let hardKillMs = 60_000
 let exitedHandlers = new Set()
+/** 전역 에러 핸들러 등록 여부 + 참조(reset 시 removeListener 용). @type {boolean} */
+let globalErrorsRegistered = false
+/** @type {((reason: unknown) => void) | null} */
+let unhandledRejectionHandler = null
+/** @type {((err: Error, origin?: string) => void) | null} */
+let uncaughtExceptionHandler = null
 
 /**
  * cleanup hook 등록. 순서는 등록 역순(LIFO)으로 실행.
@@ -74,8 +80,9 @@ function isShuttingDown() {
 }
 
 /**
- * SIGTERM/SIGINT 시그널 등록 (한 번만 등록됨).
- * @param {{ gracePeriodMs?: number, hardKillMs?: number, signals?: string[] }} [opts]
+ * SIGTERM/SIGINT 시그널 등록 (한 번만 등록됨). 전역 에러 핸들러(unhandledRejection/uncaughtException)도
+ * 기본 등록한다 — `globalErrorHandlers: false` 로 끌 수 있다(REPL 등).
+ * @param {{ gracePeriodMs?: number, hardKillMs?: number, signals?: string[], globalErrorHandlers?: boolean }} [opts]
  */
 function setupSignals(opts = {}) {
   if (signalsRegistered) return   // 멱등성
@@ -88,6 +95,36 @@ function setupSignals(opts = {}) {
       void now({ signal: sig, exitCode: 0 })
     })
   }
+  // 전역 에러 핸들러도 함께 등록(opt-out: globalErrorHandlers === false). REPL(console-cmd) 등은 끌 수 있다.
+  if (opts.globalErrorHandlers !== false) setupGlobalErrorHandlers()
+}
+
+/**
+ * 전역 `unhandledRejection`/`uncaughtException` 핸들러 등록 (ADR-178, 멱등). floating promise reject 나
+ * 미처리 예외로 프로세스가 **graceful 없이 즉사**(어댑터 disconnect·드레인 미실행 → 커넥션/락 누수, 진행 중
+ * 잡 유실)하는 것을 막는다. 둘 다 fatal 로깅 후 graceful shutdown(exit 1)을 트리거한다 — uncaughtException
+ * 이후의 프로세스 상태는 신뢰 불가라 복구하지 않고 정리 후 종료가 표준.
+ * @param {{ exitCode?: number }} [opts]
+ * @returns {void}
+ */
+function setupGlobalErrorHandlers({ exitCode = 1 } = {}) {
+  if (globalErrorsRegistered) return
+  globalErrorsRegistered = true
+  unhandledRejectionHandler = (reason) => {
+    const log = /** @type {any} */ (globalThis).logger
+    const err = reason instanceof Error ? reason : new Error(`unhandledRejection: ${String(reason)}`)
+    if (log?.fatal) log.fatal({ err }, 'unhandledRejection — initiating graceful shutdown')
+    else console.error('[mega-shutdown] unhandledRejection — initiating graceful shutdown:', err)
+    void now({ signal: 'unhandledRejection', exitCode })
+  }
+  uncaughtExceptionHandler = (err, origin) => {
+    const log = /** @type {any} */ (globalThis).logger
+    if (log?.fatal) log.fatal({ err, origin }, 'uncaughtException — initiating graceful shutdown')
+    else console.error('[mega-shutdown] uncaughtException — initiating graceful shutdown:', err, origin)
+    void now({ signal: 'uncaughtException', exitCode })
+  }
+  process.on('unhandledRejection', unhandledRejectionHandler)
+  process.on('uncaughtException', uncaughtExceptionHandler)
 }
 
 /**
@@ -159,6 +196,12 @@ function _reset() {
   gracePeriodMs = 30_000
   hardKillMs = 60_000
   exitedHandlers = new Set()
+  // 전역 에러 핸들러도 떼어 테스트 간 누적 방지.
+  if (unhandledRejectionHandler) process.removeListener('unhandledRejection', unhandledRejectionHandler)
+  if (uncaughtExceptionHandler) process.removeListener('uncaughtException', uncaughtExceptionHandler)
+  unhandledRejectionHandler = null
+  uncaughtExceptionHandler = null
+  globalErrorsRegistered = false
 }
 
 /**
@@ -170,6 +213,7 @@ export const MegaShutdown = {
   unregister,
   isShuttingDown,
   setupSignals,
+  setupGlobalErrorHandlers,
   now,
   registeredCount,
   _reset,

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()
-  })
-})