@gaonjs/cli 0.47.0 → 0.55.0

package/dist/commands/check.d.ts

@@ -40,6 +40,8 @@ export interface CheckRegen {
     readonly tables: boolean;
     /** routes.d.ts 를 재생성한 앱 이름. */
     readonly apps: readonly string[];
+    /** messages.d.ts(i18n 카탈로그 키 유니온)를 재생성했는가 — 결정 414(축 보고 누락 봉합). */
+    readonly messages?: boolean;
     /** 실패 시 에러 + 수리 안내. done/skipped 는 undefined. */
     readonly output?: string;
 }
@@ -52,7 +54,7 @@ export interface CheckReport {
 /**
  * `gaon check` 진입점. 검사 전에 .gaon 을 재생성(규칙 3)한 뒤 각 단계를
  * 순서대로 실행하고, 하나라도 실패하면 exit 1. --only 지정 시 그 단계만
- * 실행. --include-doctor 시 doctor 추가.
+ * 실행. doctor 는 기본 포함(결정 157) — --no-doctor 로만 뺀다.
  *
  * §9 실 인프라 · 목업 X — 실 spawn 으로 검증한다.
  */

package/dist/commands/check.js

@@ -32,6 +32,8 @@ import { generateTablesDts } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
 import { computeDoctorResult } from '../doctor.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
+import { analyzeProjectI18n, resolveLocalesDir } from '../i18n-config.js';
+import { loadLocales } from '@gaonjs/i18n';
 import { registerTsResolve } from '../tsResolve.js';
 import { listFrontendApps, verifyAppDist } from '../dev/build.js';
 import { generateMessagesDts } from '../messages-gen.js';
@@ -239,9 +241,41 @@ async function runDoctorStep(cwd) {
  * 실패를 내지 않게 한다. --only 여부와 무관하게 항상 먼저 돈다 —
  * typecheck·vue-tsc·build 가 모두 .gaon 을 소비하기 때문.
  */
+/**
+ * 결정 413: 결정 353(부팅 fail-loud)의 정적 미러 — i18n 을 켰는데 카탈로그가 비었거나
+ * fallbackLng/supportedLngs 가 지목한 파일이 없으면 부팅이 죽는다. 같은 사유·같은 수리
+ * 안내를 check 단계에서 먼저 낸다. 정적으로 못 읽은 키는 건너뛴다(결정 412 경고가 별도로 알림).
+ */
+function verifyI18nCatalogs(cwd) {
+    const cfg = analyzeProjectI18n(cwd);
+    if (!cfg.declared)
+        return undefined;
+    const dir = cfg.dir ?? 'locales';
+    const abs = resolveLocalesDir(cwd, cfg.dir);
+    const resources = existsSync(abs) ? loadLocales(abs) : {};
+    if (Object.keys(resources).length === 0) {
+        return (`i18n 이 설정됐지만 로케일 카탈로그가 비어 있습니다: ${abs}\n` +
+            `  → ${dir}/${cfg.fallbackLng ?? '<fallbackLng>'}.json 을 만들거나(최소 fallbackLng 카탈로그),\n` +
+            `  → gaon.config.ts 의 i18n.dir 이 실제 카탈로그 폴더를 가리키는지 확인하세요.\n` +
+            `  (이 상태로는 gaon serve 가 부팅에서 실패합니다 — 결정 353)`);
+    }
+    const wanted = [...(cfg.fallbackLng ? [cfg.fallbackLng] : []), ...(cfg.supportedLngs ?? [])];
+    const missing = wanted.filter((lng, i, arr) => arr.indexOf(lng) === i && !resources[lng]);
+    if (missing.length > 0) {
+        return (`i18n 설정이 지목한 로케일의 카탈로그 파일이 없습니다: ${missing.join(', ')}\n` +
+            `  → ${dir}/ 에 ${missing.map((l) => `${l}.json`).join(' · ')} 을 추가하거나,\n` +
+            `  → gaon.config.ts 의 fallbackLng/supportedLngs 에서 해당 로케일을 제거하세요.\n` +
+            `  (이 상태로는 gaon serve 가 부팅에서 실패합니다 — 결정 353)`);
+    }
+    return undefined;
+}
 async function regenerateGaon(cwd) {
     const layout = resolveDevLayout(cwd);
     if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
+        // 카탈로그가 통째로 없어도 config 가 i18n 을 켰으면 부팅이 죽는다 — 그 경우만 잡는다.
+        const problem = verifyI18nCatalogs(cwd);
+        if (problem)
+            return { status: 'failed', tables: false, apps: [], output: problem };
         return { status: 'skipped', tables: false, apps: [] };
     }
     // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
@@ -255,7 +289,15 @@ async function regenerateGaon(cwd) {
             regenerateMessages: generateMessagesDts,
             regenerateEnv: generateEnvDts,
         });
-        return { status: 'done', tables: result.tables, apps: result.apps };
+        // 결정 413: 부팅(결정 353)이 throw 하는 조건을 **정적으로 미리** 본다 — check 는
+        // AI 자가검증의 정본 경로인데, 통과해 놓고 `gaon serve` 가 죽으면 자가검증이
+        // 부팅 가능성을 담보하지 못한다(i18n 한정 구멍). 재료(dir·fallbackLng·supportedLngs)는
+        // 이미 정적으로 있다.
+        const i18nProblem = verifyI18nCatalogs(cwd);
+        if (i18nProblem) {
+            return { status: 'failed', tables: result.tables, apps: result.apps, messages: result.messages, output: i18nProblem };
+        }
+        return { status: 'done', tables: result.tables, apps: result.apps, messages: result.messages };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -271,7 +313,7 @@ async function regenerateGaon(cwd) {
 /**
  * `gaon check` 진입점. 검사 전에 .gaon 을 재생성(규칙 3)한 뒤 각 단계를
  * 순서대로 실행하고, 하나라도 실패하면 exit 1. --only 지정 시 그 단계만
- * 실행. --include-doctor 시 doctor 추가.
+ * 실행. doctor 는 기본 포함(결정 157) — --no-doctor 로만 뺀다.
  *
  * §9 실 인프라 · 목업 X — 실 spawn 으로 검증한다.
  */

package/dist/commands/db.js

@@ -79,6 +79,15 @@ export async function runDbCommand(subcommand, opts = {}) {
                 emit(r.text, r.json);
                 return r.exitCode;
             }
+            // 결정 367: seed 는 커넥션별 반복이 아니라 **1회 실행**이다 — domain/seed.ts 는
+            // 프로젝트 단일 시드라 키당 재실행하면 중복 삽입이고, 패스마다 단일 커넥션만
+            // 등록해 타 커넥션 모델이 '미등록' throw 로 순회가 항상 exit 1 이었다.
+            // runDbSeedCommand 가 선언된 전 SQL 커넥션을 등록하고 한 번 실행한다.
+            if (subcommand === 'seed') {
+                const r = await runDbSeedCommand({ root: cwd, json, configPath });
+                emit(r.text, r.json);
+                return r.exitCode;
+            }
             return runAcrossConnections(subcommand, keys, runOne, emit, json, mongoKeys);
         }
         // 단일 커넥션 경로(--db <키> · reset · env-only 폴백) — 종전 동작 그대로.

package/dist/commands/gen.d.ts

@@ -13,6 +13,8 @@ export interface GenResult {
     readonly apps: readonly string[];
     /** env.d.ts 를 재생성했는가(프론트 앱 존재 · 결정 198). */
     readonly env?: boolean;
+    /** messages.d.ts 를 재생성했는가(locales/ 존재 · 결정 158). 결정 414: 재생성만 하고 보고에서 빠져 있었다. */
+    readonly messages?: boolean;
     /** 실패 시 에러 + 수리 안내. */
     readonly error?: string;
 }

package/dist/commands/gen.js

@@ -48,7 +48,7 @@ export async function runGenCommand(opts = {}) {
     let result;
     try {
         const r = await regenerateProjectGaon(cwd);
-        result = { ok: true, skipped: r.skipped, tables: r.tables, apps: r.apps, env: r.env };
+        result = { ok: true, skipped: r.skipped, tables: r.tables, apps: r.apps, env: r.env, messages: r.messages };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -77,6 +77,8 @@ export async function runGenCommand(opts = {}) {
         for (const app of result.apps) {
             parts.push(`apps/${app}/.gaon/routes.d.ts`, `apps/${app}/.gaon/routes.manifest.ts`);
         }
+        if (result.messages)
+            parts.push('.gaon/messages.d.ts');
         if (result.env)
             parts.push('.gaon/env.d.ts');
         process.stdout.write(`  ✓ gaon gen — ${parts.join(', ')}\n`);

package/dist/commands/new.js

@@ -44,6 +44,19 @@ export function validateProjectName(name) {
             `    대문자·언더스코어(_)는 인프라 기동·버킷 생성에서 실패합니다.\n` +
             `  → 예: gaon new my-app · gaon new demo`);
     }
+    // 결정 409: 결정 315 가 남긴 같은 클래스의 잔여 두 갈래 — 버킷명은 **영숫자로 끝나야**
+    // 하고 **3~63자**여야 한다. 종전 정규식은 'my-app-'·'ab' 를 통과시켜 생성은 성공하고
+    // `gaon dev` 의 버킷 생성(mc mb)에서 뒤늦게 깨졌다.
+    if (name.endsWith('-')) {
+        throw new Error(`프로젝트 이름은 하이픈(-)으로 끝날 수 없습니다: ${name}\n` +
+            `  → 스토리지 버킷명은 영문/숫자로 끝나야 해 'mc mb' 가 실패합니다.\n` +
+            `  → 예: gaon new ${name.replace(/-+$/, '')}`);
+    }
+    if (name.length < 3 || name.length > 63) {
+        throw new Error(`프로젝트 이름은 3~63자여야 합니다(현재 ${name.length}자): ${name}\n` +
+            `  → 이름이 스토리지 버킷명으로 그대로 쓰이고, 버킷명 길이 제한이 3~63자입니다.\n` +
+            `  → 예: gaon new my-app`);
+    }
 }
 /**
  * 파사드(gaonjs) 패키지의 실 버전을 찾는다 — package.json 을 위로 훑는다.

package/dist/commands/test.js

@@ -106,7 +106,11 @@ async function provisionTestDatabases(cwd, json, onOutput) {
                 connectionOverride: testCfg,
             });
             if (res.exitCode !== 0) {
-                if (!json)
+                // 결정 360: json 모드도 구조화 에러를 낸다 — 이전엔 이 분기만 0 바이트로
+                // exit 1 이라 자동화가 실패 원인을 전혀 못 받았다(catch 분기와 비대칭).
+                if (json)
+                    writeOut(JSON.stringify({ ok: false, kind: 'provision', db: key, error: res.text }) + '\n');
+                else
                     writeErr(`  ✗ 테스트 DB '${key}' 마이그레이션 실패\n${res.text}\n`);
                 return false;
             }
@@ -211,18 +215,27 @@ export async function runTestCommand(args = [], opts = {}) {
     else {
         writeOut(`  gaon test · ${cmd} ${spawnArgs.join(' ')} (scope=${scope})\n`);
     }
+    // 결정 360: --json 은 stdout 이 순수 JSON 라인이어야 한다(결정 269 check 와 대칭).
+    // 이전엔 json 모드도 stdio:'inherit' 라 vitest 사람용 출력이 JSON 라인 사이에 섞여
+    // `gaon test --json | jq` 류 자동화가 깨졌다. 자식 출력은 {kind:'output'} 라인으로 감싼다.
+    const jsonPipe = json && !capture;
     const exitCode = await new Promise((resolvePromise) => {
         // capture(MCP) 모드는 자식 출력을 파이프로 모아 싱크로 흘린다(도구 응답에 담기).
-        // CLI 경로(미지정)는 vitest 컬러 출력·리포터를 그대로 보이게 stdio 를 상속한다.
+        // CLI 사람 경로(미지정)는 vitest 컬러 출력·리포터를 그대로 보이게 stdio 를 상속한다.
         const child = spawn(cmd, spawnArgs, {
             cwd,
             env: testEnv,
-            stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+            stdio: capture || jsonPipe ? ['ignore', 'pipe', 'pipe'] : 'inherit',
         });
         if (capture) {
             child.stdout?.on('data', (d) => opts.onOutput(d.toString('utf8')));
             child.stderr?.on('data', (d) => opts.onOutput(d.toString('utf8')));
         }
+        else if (jsonPipe) {
+            const emit = (stream) => (d) => writeOut(JSON.stringify({ kind: 'output', stream, chunk: d.toString('utf8') }) + '\n');
+            child.stdout?.on('data', emit('stdout'));
+            child.stderr?.on('data', emit('stderr'));
+        }
         child.on('error', (err) => {
             writeErr(`  ✗ gaon test spawn 실패: ${String(err)}\n`);
             resolvePromise(127);

package/dist/db/journal.d.ts

@@ -1,4 +1,5 @@
 import { type Kysely } from 'kysely';
+import { type AdapterName } from '@gaonjs/data';
 export type MigrationKind = 'file' | 'schema';
 export interface JournalEntry {
     readonly id: string;
@@ -17,13 +18,16 @@ export interface JournalEntry {
  * pg 는 count 를 bigint(문자열)로, mysql 은 number 로 돌려주므로 `Number()` 로 통일한다
  * (양 방언 공통 · 결정 268).
  */
-export declare function journalExists(db: Kysely<any>): Promise<boolean>;
+export declare function journalExists(db: Kysely<any>, adapter?: AdapterName): Promise<boolean>;
 /**
  * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
  * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
  * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ * 결정 380: mysql 의 down_sql 은 **mediumtext**(16MB) — TEXT(64KB)는 큰 배치의
+ * down SQL(JSON 배열)이 조용히 잘려 저장 파손 위험이었다. 기존(legacy) 테이블은
+ * data_type 확인 후 한 번만 MODIFY 로 승격한다(매 실행 재빌드 방지). pg text 는 무제한.
  */
-export declare function ensureJournal(db: Kysely<any>): Promise<void>;
+export declare function ensureJournal(db: Kysely<any>, adapter?: AdapterName): Promise<void>;
 export interface RecordArgs {
     readonly id: string;
     readonly kind: MigrationKind;
@@ -35,7 +39,7 @@ export interface RecordArgs {
 /** 이력 한 행을 남긴다. 호출자가 트랜잭션(trx)을 넘기면 그 안에서 실행된다. */
 export declare function recordEntry(db: Kysely<any>, e: RecordArgs): Promise<void>;
 /** 가장 최근 적용된 이력(롤백 대상). 원장 미존재 시 undefined. */
-export declare function latestEntry(db: Kysely<any>): Promise<JournalEntry | undefined>;
+export declare function latestEntry(db: Kysely<any>, adapter?: AdapterName): Promise<JournalEntry | undefined>;
 /** kind='file' 로 적용된 파일명 집합. 원장 미존재 시 빈 집합. */
-export declare function appliedFileMigrations(db: Kysely<any>): Promise<Set<string>>;
+export declare function appliedFileMigrations(db: Kysely<any>, adapter?: AdapterName): Promise<Set<string>>;
 export declare function deleteEntry(db: Kysely<any>, id: string): Promise<void>;

package/dist/db/journal.js

@@ -17,12 +17,23 @@ import { MIGRATIONS_TABLE } from '@gaonjs/data';
  * pg 는 count 를 bigint(문자열)로, mysql 은 number 로 돌려주므로 `Number()` 로 통일한다
  * (양 방언 공통 · 결정 268).
  */
-export async function journalExists(db) {
-    const rows = await sql `
-    select count(*) as n
-    from information_schema.tables
-    where table_name = ${MIGRATIONS_TABLE}
-  `.execute(db);
+export async function journalExists(db, adapter = 'postgres') {
+    // 결정 326: mysql/mariadb 의 information_schema.tables 는 **서버 전체(모든 database)** 를
+    // 보므로 같은 서버 다른 DB 의 _gaon_migrations 에 오탐했다 — 존재 오판 뒤
+    // appliedFileMigrations 가 없는 테이블을 select 해 migrate/status 가 죽는다(공유 dev 서버
+    // 현실 시나리오) → database() 로 현재 DB 에 한정한다. pg 는 카탈로그가 database 단위라
+    // 종전대로 둔다(스키마('public') 한정은 커스텀 search_path 프로젝트를 깨서 안 한다).
+    const rows = adapter === 'mysql'
+        ? await sql `
+          select count(*) as n
+          from information_schema.tables
+          where table_name = ${MIGRATIONS_TABLE} and table_schema = database()
+        `.execute(db)
+        : await sql `
+          select count(*) as n
+          from information_schema.tables
+          where table_name = ${MIGRATIONS_TABLE}
+        `.execute(db);
     const first = rows.rows[0];
     return first ? Number(first.n) > 0 : false;
 }
@@ -30,31 +41,64 @@ export async function journalExists(db) {
  * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
  * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
  * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ * 결정 380: mysql 의 down_sql 은 **mediumtext**(16MB) — TEXT(64KB)는 큰 배치의
+ * down SQL(JSON 배열)이 조용히 잘려 저장 파손 위험이었다. 기존(legacy) 테이블은
+ * data_type 확인 후 한 번만 MODIFY 로 승격한다(매 실행 재빌드 방지). pg text 는 무제한.
  */
-export async function ensureJournal(db) {
+export async function ensureJournal(db, adapter = 'postgres') {
+    const downType = adapter === 'mysql' ? 'mediumtext' : 'text';
     await sql
         .raw(`create table if not exists ${MIGRATIONS_TABLE} (` +
         ` id varchar(255) not null primary key,` +
         ` kind varchar(16) not null default 'schema',` +
-        ` applied_at timestamp not null,` +
+        ` applied_at timestamp(6) not null,` +
         ` db_key varchar(64) not null,` +
         ` statements integer not null,` +
         ` summary text not null,` +
-        ` down_sql text` +
+        ` down_sql ${downType}` +
         `)`)
         .execute(db);
+    if (adapter === 'mysql') {
+        // 결정 380: legacy 테이블 승격 — down_sql text→mediumtext(64KB 절단 방지) ·
+        // applied_at 초 해상 timestamp→timestamp(6)(ms 단조 증가가 저장에서 뭉개지지 않게).
+        // 둘 다 상태 확인 후 한 번만 MODIFY(매 실행 테이블 재빌드 방지).
+        const cur = await sql `
+      select column_name as c, data_type as t, datetime_precision as p
+      from information_schema.columns
+      where table_schema = database() and table_name = ${MIGRATIONS_TABLE}
+        and column_name in ('down_sql', 'applied_at')
+    `.execute(db);
+        for (const row of cur.rows) {
+            if (row.c === 'down_sql' && row.t.toLowerCase() === 'text') {
+                await sql.raw(`alter table ${MIGRATIONS_TABLE} modify down_sql mediumtext`).execute(db);
+            }
+            if (row.c === 'applied_at' && Number(row.p ?? 0) === 0) {
+                await sql.raw(`alter table ${MIGRATIONS_TABLE} modify applied_at timestamp(6) not null`).execute(db);
+            }
+        }
+    }
+}
+// 결정 380: 프로세스 내 단조 증가 applied_at — 같은 migrate 실행의 파일 리플레이·schema
+// 배치가 같은 ms 에 기록되면 롤백 대상 선정(`order by applied_at desc, id desc`)이 서로
+// 다른 id 체계(파일명 vs `<epochMs>-<n>`)의 **사전순**으로 갈려 최신이 아닌 항목을 되돌릴
+// 수 있었다. 동률이면 1ms 씩 밀어 순서를 시각에 각인한다(동시 다중 migrate 는 원래 미지원).
+let lastAppliedAtMs = 0;
+function nextAppliedAt() {
+    const now = Date.now();
+    lastAppliedAtMs = now > lastAppliedAtMs ? now : lastAppliedAtMs + 1;
+    return new Date(lastAppliedAtMs);
 }
 /** 이력 한 행을 남긴다. 호출자가 트랜잭션(trx)을 넘기면 그 안에서 실행된다. */
 export async function recordEntry(db, e) {
     await sql `
     insert into ${sql.ref(MIGRATIONS_TABLE)}
       (id, kind, applied_at, db_key, statements, summary, down_sql)
-    values (${e.id}, ${e.kind}, ${new Date()}, ${e.dbKey}, ${e.statements}, ${e.summary}, ${e.downSql})
+    values (${e.id}, ${e.kind}, ${nextAppliedAt()}, ${e.dbKey}, ${e.statements}, ${e.summary}, ${e.downSql})
   `.execute(db);
 }
 /** 가장 최근 적용된 이력(롤백 대상). 원장 미존재 시 undefined. */
-export async function latestEntry(db) {
-    if (!(await journalExists(db)))
+export async function latestEntry(db, adapter = 'postgres') {
+    if (!(await journalExists(db, adapter)))
         return undefined;
     const rows = await sql `
     select id, kind, db_key, statements, summary, down_sql, applied_at
@@ -65,8 +109,8 @@ export async function latestEntry(db) {
     return rows.rows[0];
 }
 /** kind='file' 로 적용된 파일명 집합. 원장 미존재 시 빈 집합. */
-export async function appliedFileMigrations(db) {
-    if (!(await journalExists(db)))
+export async function appliedFileMigrations(db, adapter = 'postgres') {
+    if (!(await journalExists(db, adapter)))
         return new Set();
     const rows = await sql `
     select id from ${sql.ref(MIGRATIONS_TABLE)} where kind = 'file'

package/dist/db/migrate.d.ts

@@ -1,4 +1,4 @@
-import { type ConnectionConfig } from '@gaonjs/data';
+import { type MigrationOp, type ConnectionConfig } from '@gaonjs/data';
 import { listMigrationFiles } from './replay.js';
 export interface DbMigrateOptions {
     readonly cwd: string;
@@ -16,6 +16,8 @@ export interface DbMigrateResult {
     readonly text: string;
     readonly json: unknown;
 }
+/** drop 계열 부속 op 을 사람이 읽는 한 줄로 — 크게 알리는 note 용(status 도 재사용 · 결정 326). */
+export declare function describeDeferred(op: MigrationOp): string;
 /**
  * `gaon db migrate` — 진짜 apply(합성형: replay → schema-diff). 실 DB 필요(§9).
  */

package/dist/db/migrate.js

@@ -12,13 +12,12 @@
 //
 // 트랜잭션: postgres 는 트랜잭셔널 DDL 이라 각 단계가 원자적. mysql/mariadb 는
 // DDL 이 autocommit 이라 순차 실행하고 이력만 남긴다(§4.5 방언 차이).
-import { sql } from 'kysely';
-import { computeMigration, renderUp, renderDown, summarizeOp, DEFERRED_DROP_KINDS } from '@gaonjs/data';
+import { applyStatements, computeMigration, renderUp, renderDown, summarizeOp, partitionDeferredOps } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
 import { ensureJournal, journalExists, recordEntry } from './journal.js';
 import { listMigrationFiles, replayPending, rollbackLast } from './replay.js';
-/** drop 계열 부속 op 을 사람이 읽는 한 줄로 — 크게 알리는 note 용. */
-function describeDeferred(op) {
+/** drop 계열 부속 op 을 사람이 읽는 한 줄로 — 크게 알리는 note 용(status 도 재사용 · 결정 326). */
+export function describeDeferred(op) {
     switch (op.kind) {
         case 'dropUnique':
             return `unique(${op.name}: ${op.columns.join(', ')})`;
@@ -62,12 +61,15 @@ export async function runDbMigrate(opts) {
         // 자동 적용하지 않는다** — replay 가 만든/외부 객체·수동 추가한 제약을 보호한다. 제거는
         // 손작성 마이그로 하고, 'gaon db diff' 가 계속 보여준다(조용히 넘어가지 않는다). ADD·SET
         // (unique·index·check·default 추가)은 자동 적용해 "조용한 no-op"(결정 220 배경)을 없앤다.
+        // 결정 366: 단 **재생성 쌍**(같은 이름 dropIndex→addIndex / dropCheck→addCheck — 인덱스
+        // method 변경·enum 값 변경)의 drop 반쪽은 defer 하지 않는다 — kind 만 보고 걸러내면
+        // add 반쪽이 기존 객체 위에 실행돼 "already exists" 로 migrate 가 매번 죽었다.
         const full = await computeMigration(target.db, target.tables, target.dialect);
-        const droppedTables = full.ops
+        const { apply: schemaOps, deferred } = partitionDeferredOps(full.ops);
+        const droppedTables = deferred
             .filter((o) => o.kind === 'dropTable')
             .map((o) => o.name);
-        const deferredDrops = full.ops.filter((o) => o.kind !== 'dropTable' && DEFERRED_DROP_KINDS.has(o.kind));
-        const schemaOps = full.ops.filter((o) => !DEFERRED_DROP_KINDS.has(o.kind));
+        const deferredDrops = deferred.filter((o) => o.kind !== 'dropTable');
         const plan = {
             ops: schemaOps,
             up: renderUp(schemaOps, target.dialect),
@@ -116,23 +118,21 @@ export async function runDbMigrate(opts) {
             };
         }
         // baseline 감지 — journal 이 없는데 createTable 이 포함 → 안내(§7.5.3).
-        const hadJournal = await journalExists(target.db);
+        const hadJournal = await journalExists(target.db, target.adapter);
         const hasCreate = plan.ops.some((o) => o.kind === 'createTable');
         const baselineNote = !hadJournal && hasCreate
             ? `  ℹ 최초 마이그레이션(_gaon_migrations 미존재) — 이 배치가 baseline 이 됩니다.\n` +
                 `    → 기존 DB 를 이어 쓰고 있었다면, 먼저 'gaon db diff' 로 계획을 확인하세요.`
             : '';
         // 3) schema-diff apply — up 을 순차 적용하고 이력 한 행(kind='schema')을 남긴다.
-        await ensureJournal(target.db);
+        await ensureJournal(target.db, target.adapter);
         const id = batchId(plan.up.length);
         const summary = JSON.stringify(ops);
         const downSql = JSON.stringify(plan.down);
         const applySchema = async (db) => {
-            for (const stmt of plan.up) {
-                if (stmt.trim().startsWith('--'))
-                    continue;
-                await sql.raw(stmt).execute(db);
-            }
+            // 결정 374: raw 실행 대신 applyStatements 경유 — 비호환 타입 변경(F5 · 결정 275)의
+            // 수리 안내(enrichAlterError · USING 절 예시)가 정본 CLI 경로에서도 나온다.
+            await applyStatements(db, [...plan.up]);
             await recordEntry(db, {
                 id,
                 kind: 'schema',

package/dist/db/replay.js

@@ -66,12 +66,12 @@ export async function replayPending(opts) {
     const all = listMigrationFiles(opts.cwd);
     if (all.length === 0)
         return { applied: [], pending: [], all: [] };
-    const done = await appliedFileMigrations(opts.db);
+    const done = await appliedFileMigrations(opts.db, opts.adapter);
     const pending = all.filter((f) => !done.has(f));
     if (opts.dryRun || pending.length === 0) {
         return { applied: [], pending, all };
     }
-    await ensureJournal(opts.db);
+    await ensureJournal(opts.db, opts.adapter);
     const applied = [];
     for (const file of pending) {
         const mig = await loadMigration(opts.cwd, file);
@@ -104,7 +104,7 @@ export async function replayPending(opts) {
  * 되돌린 뒤 이력 행을 지운다. --dry-run 은 대상만 보고 실행하지 않는다.
  */
 export async function rollbackLast(opts) {
-    const entry = await latestEntry(opts.db);
+    const entry = await latestEntry(opts.db, opts.adapter);
     if (!entry)
         return { rolledBack: null, kind: null };
     if (opts.dryRun)

package/dist/db/resolve.d.ts

@@ -1,4 +1,4 @@
-import { type ConnectionConfig, type TableDef } from '@gaonjs/data';
+import { type ConnectionConfig, type SqlConnectionConfig, type TableDef } from '@gaonjs/data';
 import type { Kysely } from 'kysely';
 import { type Dialect, type AdapterName } from '@gaonjs/data';
 export interface ResolveDbOptions {
@@ -48,4 +48,14 @@ export interface ConnectionKeysByKind {
  * config 선언이 없으면(env-only) SQL ['main'] 폴백 — listConnectionKeys 와 정합.
  */
 export declare function listConnectionKeysByKind(cwd: string, configPath?: string): Promise<ConnectionKeysByKind>;
+/**
+ * 결정 367: 선언된 **전 SQL 커넥션**의 설정 목록 — `gaon db seed` 가 시드 실행 전에
+ * 전부 등록하는 데 쓴다(시드는 커넥션을 몰라도 된다 · §10.1 — 모델이 자기 커넥션에
+ * 자동 바인딩). config 선언이 없으면(env-only) GAON_DATABASE_URL 기반 main 하나.
+ * 문서형(mongodb)은 제외(§7.4 — gaon db 는 SQL 축).
+ */
+export declare function listSqlConnectionConfigs(cwd: string, configPath?: string): Promise<Array<{
+    key: string;
+    cfg: SqlConnectionConfig;
+}>>;
 export declare function resolveDbTarget(opts: ResolveDbOptions): Promise<ResolvedDbTarget>;

package/dist/db/resolve.js

@@ -119,6 +119,23 @@ export async function listConnectionKeysByKind(cwd, configPath) {
     }
     return { sql, mongo };
 }
+/**
+ * 결정 367: 선언된 **전 SQL 커넥션**의 설정 목록 — `gaon db seed` 가 시드 실행 전에
+ * 전부 등록하는 데 쓴다(시드는 커넥션을 몰라도 된다 · §10.1 — 모델이 자기 커넥션에
+ * 자동 바인딩). config 선언이 없으면(env-only) GAON_DATABASE_URL 기반 main 하나.
+ * 문서형(mongodb)은 제외(§7.4 — gaon db 는 SQL 축).
+ */
+export async function listSqlConnectionConfigs(cwd, configPath) {
+    const { config } = await loadDbConfig(resolvePath(cwd), configPath);
+    const entries = Object.entries(config.db ?? {});
+    if (entries.length === 0) {
+        const url = env.optional('GAON_DATABASE_URL');
+        return url ? [{ key: 'main', cfg: dbConfigFromUrl(url) }] : [];
+    }
+    return entries
+        .filter(([, cfg]) => cfg?.adapter !== 'mongodb')
+        .map(([key, cfg]) => ({ key, cfg: cfg }));
+}
 export async function resolveDbTarget(opts) {
     const cwd = resolvePath(opts.cwd);
     // 사용자가 --config <path> 를 준 경우 그 경로에서 default export 를 로드한다.
@@ -153,9 +170,14 @@ export async function resolveDbTarget(opts) {
     // 결정 279(§7.4): 문서형(mongodb) 커넥션은 마이그레이션이 없다 — SQL 전용 경로(diff/migrate/
     // introspect)로 흘리지 않고 명확히 안내한다. 몽고 인덱스는 Mongoose 스키마 선언으로 관리한다.
     if (connCfg.adapter === 'mongodb') {
+        // 결정 384: 안내문을 실동작(결정 333·365)으로 정정 — 이전 문구("autoIndex 기본값이
+        // 부팅 시 보장 · dev·prod 공통")는 운영 autoIndex=false 이후 거짓 안내였다.
         throw new Error(`[gaon db] 커넥션 '${dbKey}' 은 문서형(mongodb)입니다 — 문서형은 마이그레이션이 없습니다(§7.4).\n` +
-            `  → 몽고 인덱스는 Mongoose 스키마 선언(index:true / schema.index())으로 관리합니다(mongoose autoIndex 기본값이 부팅 시 보장).\n` +
-            `  → gaon db diff/migrate 는 SQL 커넥션(postgres·mysql)에만 실행하세요(키 생략 시 순회가 문서형을 자동으로 건너뜁니다 · 결정 292).`);
+            `  → 몽고 인덱스는 Mongoose 스키마 선언(index:true / schema.index())으로 관리합니다 — dev·test 는 autoIndex 가\n` +
+            `    첫 사용 시 만들고, 운영(NODE_ENV=production)은 autoIndex 기본 false 라 배포 절차에서 syncMongoIndexes() 로\n` +
+            `    명시 동기화합니다(결정 333·365).\n` +
+            `  → gaon db 서브커맨드(diff/migrate/status/seed/reset)는 SQL 커넥션(postgres·mysql) 전용입니다 —\n` +
+            `    키 생략 시 순회가 문서형을 자동으로 건너뜁니다(결정 292).`);
     }
     const db = createDb(connCfg);
     registerConnection(dbKey, db, connCfg.adapter);

package/dist/db/status.js

@@ -2,9 +2,10 @@
 //
 // db/migrations/*.ts 각각의 적용/미적용과, 스키마↔DB 사이에 아직 반영 안 된
 // 변경(schema drift) 수를 함께 보여준다. 아무것도 실행하지 않는다.
-import { computeMigration } from '@gaonjs/data';
+import { computeMigration, summarizeOp, partitionDeferredOps } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
 import { appliedFileMigrations } from './journal.js';
+import { describeDeferred } from './migrate.js';
 import { listMigrationFiles } from './replay.js';
 export async function runDbStatus(opts) {
     const target = await resolveDbTarget({
@@ -14,16 +15,23 @@ export async function runDbStatus(opts) {
     });
     try {
         const files = listMigrationFiles(opts.cwd);
-        const done = await appliedFileMigrations(target.db);
+        const done = await appliedFileMigrations(target.db, target.adapter);
         const migrations = files.map((f) => ({ file: `db/migrations/${f}`, applied: done.has(f) }));
         const pendingFiles = migrations.filter((m) => !m.applied).length;
         // migrate 는 스키마에 없는 테이블을 자동 DROP 하지 않으므로(결정 39 · §4.8)
         // dropTable 은 drift 로 세지 않는다 — 별도로 참고 정보(extraTables)로만 보고.
         const plan = await computeMigration(target.db, target.tables, target.dialect);
-        const extraTables = plan.ops
+        // 결정 326: deferred aux drop(제약·인덱스·기본값 제거)도 migrate 가 자동 적용하지
+        // 않는다(결정 220) — drift 로 세면 "'gaon db migrate' 로 반영하세요" 가 영원히 안
+        // 지워지는 거짓 안내가 된다. dropTable 과 같은 축의 참고 항목으로 분리한다.
+        // 결정 366: 재생성 쌍(인덱스 method·enum 값 변경)의 drop 반쪽은 migrate 가 자동
+        // 적용하므로 deferred 가 아니라 drift(schemaChanges)로 계상한다 — migrate 와 한 판정.
+        const { apply, deferred } = partitionDeferredOps(plan.ops);
+        const extraTables = deferred
             .filter((o) => o.kind === 'dropTable')
             .map((o) => o.name);
-        const schemaChanges = plan.ops.length - extraTables.length;
+        const deferredDrops = deferred.filter((o) => o.kind !== 'dropTable');
+        const schemaChanges = apply.length;
         const lines = [];
         if (migrations.length === 0) {
             lines.push(`  [${opts.dbKey}] 마이그레이션 파일 없음 (db/migrations/).`);
@@ -42,6 +50,10 @@ export async function runDbStatus(opts) {
         if (extraTables.length > 0) {
             lines.push(`  참고: 스키마에 없는 테이블 ${extraTables.length}개(자동 DROP 안 함): ${extraTables.join(', ')}`);
         }
+        if (deferredDrops.length > 0) {
+            lines.push(`  참고: 스키마에서 사라진 제약·인덱스·기본값 ${deferredDrops.length}개(자동 제거 안 함 — ` +
+                `'gaon db diff' 의 down SQL 로 손작성 마이그): ${deferredDrops.map(describeDeferred).join(', ')}`);
+        }
         return {
             exitCode: 0,
             text: lines.join('\n'),
@@ -52,6 +64,7 @@ export async function runDbStatus(opts) {
                 pendingFiles,
                 schemaChanges,
                 extraTables,
+                deferredDrops: deferredDrops.map(summarizeOp),
             },
         };
     }

package/dist/db.js

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createDb, registerConnection, destroyAllConnections, isSeedDef, } from '@gaonjs/data';
 import { registerTsResolve } from './tsResolve.js';
-import { resolveDbTarget } from './db/resolve.js';
+import { resolveDbTarget, listSqlConnectionConfigs } from './db/resolve.js';
 import { registerInProjectData, isSplitDataInstance } from './db/projectData.js';
 /** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
 function dbConfigFromUrl(url) {
@@ -77,15 +77,36 @@ export async function runDbSeedCommand(opts = {}) {
         throw new Error(`[gaon db seed] 커넥션 '${dbKey}' 에 url 이 없어 시드를 실행할 수 없습니다.\n` +
             `  → gaon.config.ts 의 db.${dbKey} 에 url 을 두거나 .env 의 GAON_DATABASE_URL 을 설정하세요.`);
     }
-    const projData = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
+    // 결정 367: 시드는 커넥션을 몰라도 된다(§10.1 — 모델이 자기 커넥션에 자동 바인딩).
+    // dbKey 하나만 등록하면 ≥2 SQL 커넥션 프로젝트의 시드가 타 커넥션 모델의 '미등록'
+    // throw 로 항상 실패했다(그리고 그 에러가 결정 156 오진 안내로 이어졌다) — 선언된
+    // **전 SQL 커넥션**을 등록하고 시드는 1회만 실행한다. url 없는 보조 커넥션은 연결
+    // 불가라 건너뛴다(그 커넥션 모델을 시드가 쓰면 미등록 에러가 원인을 가리킨다).
+    const others = (await listSqlConnectionConfigs(root, opts.configPath)).filter((c) => c.key !== dbKey && ('url' in c.cfg ? c.cfg.url : true));
+    const registered = [dbKey];
+    const projHandles = [];
+    const primaryHandle = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
+    if (primaryHandle)
+        projHandles.push(primaryHandle);
+    for (const { key, cfg } of others) {
+        registerConnection(key, createDb(cfg), cfg.adapter);
+        const h = await registerInProjectData(root, key, { ...cfg, poolMax: 1 });
+        if (h)
+            projHandles.push(h);
+        registered.push(key);
+    }
     try {
         const def = await loadSeed(root);
         await runSeed(def, root);
-        return { exitCode: 0, ...SEED_OK };
+        return {
+            exitCode: 0,
+            text: `${SEED_OK.text} (커넥션: ${registered.join(', ')})`,
+            json: { command: 'seed', ok: true, connections: registered },
+        };
     }
     finally {
-        if (projData)
-            await projData.close();
+        for (const h of projHandles)
+            await h.close();
         await target.close();
     }
 }