@beechcms/cli 0.6.0-preview.2 → 0.6.0-preview.4

package/src/commands/validate.ts

@@ -1,80 +1,80 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import pc from 'picocolors'
-import type { Seed } from '@beechcms/core'
-import { SEED_REGISTRY, validateSeedDefinitions } from '@beechcms/core'
-
-export interface ValidateOptions {
-  registry?: Record<string, Seed> | null
-}
-
-export interface SeedValidationError {
-  slug: string
-  messages: string[]
-  /** true = abort seed:load; false = warning only */
-  fatal: boolean
-}
-
-export function validateSeeds(registry: Record<string, Seed>): SeedValidationError[] {
-  return validateSeedDefinitions(Object.values(registry))
-}
-
-export async function validate(args: ValidateOptions): Promise<void> {
-  const registry = args.registry ?? SEED_REGISTRY
-
-  if (Object.keys(registry).length === 0) {
-    console.warn(pc.yellow('\n  Warning: SEED_REGISTRY is empty. Create a seeds.ts in your project root.\n'))
-    return
-  }
-
-  console.log(pc.cyan('\n  beech validate — checking seeds\n'))
-
-  const errors = validateSeeds(registry)
-  const fatalErrors = errors.filter(e => e.fatal)
-  const warnings = errors.filter(e => !e.fatal)
-
-  // Print fatal errors first
-  for (const e of fatalErrors) {
-    console.log(pc.red(`  ✗ ${e.slug} (fatal)`))
-    for (const msg of e.messages) {
-      console.log(pc.red(`      → ${msg}`))
-    }
-  }
-
-  // Print per-seed warnings
-  const warningMap = new Map(warnings.map(e => [e.slug, e.messages]))
-  const allWarningSlugsSeen = new Set(warnings.map(e => e.slug))
-
-  for (const seed of Object.values(registry)) {
-    const msgs = warningMap.get(seed.slug)
-    if (!msgs) {
-      if (!allWarningSlugsSeen.has(seed.slug)) {
-        // only print ✓ if no fatal error for this slug either
-        const hasFatal = fatalErrors.some(e => e.slug === seed.slug)
-        if (!hasFatal) console.log(pc.green(`  ✓ ${seed.slug}`))
-      }
-    } else {
-      console.log(pc.yellow(`  ⚠ ${seed.slug}`))
-      for (const msg of msgs) {
-        console.log(pc.yellow(`      → ${msg}`))
-      }
-    }
-  }
-
-  console.log('')
-
-  const totalFatal = fatalErrors.reduce((n, e) => n + e.messages.length, 0)
-  const totalWarnings = warnings.reduce((n, e) => n + e.messages.length, 0)
-
-  if (totalFatal > 0) {
-    const s = totalFatal !== 1 ? 's' : ''
-    console.log(pc.red(`  Found ${totalFatal} fatal error${s}. Fix before loading.\n`))
-    process.exit(1)
-  } else if (totalWarnings > 0) {
-    const s = totalWarnings !== 1 ? 's' : ''
-    console.log(pc.yellow(`  Found ${totalWarnings} warning${s}. Review seeds above.\n`))
-  } else {
-    console.log(pc.green('  All seeds valid.\n'))
-  }
-}
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import pc from 'picocolors'
+import type { Seed } from '@beechcms/core'
+import { SEED_REGISTRY, validateSeedDefinitions } from '@beechcms/core'
+
+export interface ValidateOptions {
+  registry?: Record<string, Seed> | null
+}
+
+export interface SeedValidationError {
+  slug: string
+  messages: string[]
+  /** true = abort seed:load; false = warning only */
+  fatal: boolean
+}
+
+export function validateSeeds(registry: Record<string, Seed>): SeedValidationError[] {
+  return validateSeedDefinitions(Object.values(registry))
+}
+
+export async function validate(args: ValidateOptions): Promise<void> {
+  const registry = args.registry ?? SEED_REGISTRY
+
+  if (Object.keys(registry).length === 0) {
+    console.warn(pc.yellow('\n  Warning: SEED_REGISTRY is empty. Create a seeds.ts in your project root.\n'))
+    return
+  }
+
+  console.log(pc.cyan('\n  beech validate — checking seeds\n'))
+
+  const errors = validateSeeds(registry)
+  const fatalErrors = errors.filter(e => e.fatal)
+  const warnings = errors.filter(e => !e.fatal)
+
+  // Print fatal errors first
+  for (const e of fatalErrors) {
+    console.log(pc.red(`  ✗ ${e.slug} (fatal)`))
+    for (const msg of e.messages) {
+      console.log(pc.red(`      → ${msg}`))
+    }
+  }
+
+  // Print per-seed warnings
+  const warningMap = new Map(warnings.map(e => [e.slug, e.messages]))
+  const allWarningSlugsSeen = new Set(warnings.map(e => e.slug))
+
+  for (const seed of Object.values(registry)) {
+    const msgs = warningMap.get(seed.slug)
+    if (!msgs) {
+      if (!allWarningSlugsSeen.has(seed.slug)) {
+        // only print ✓ if no fatal error for this slug either
+        const hasFatal = fatalErrors.some(e => e.slug === seed.slug)
+        if (!hasFatal) console.log(pc.green(`  ✓ ${seed.slug}`))
+      }
+    } else {
+      console.log(pc.yellow(`  ⚠ ${seed.slug}`))
+      for (const msg of msgs) {
+        console.log(pc.yellow(`      → ${msg}`))
+      }
+    }
+  }
+
+  console.log('')
+
+  const totalFatal = fatalErrors.reduce((n, e) => n + e.messages.length, 0)
+  const totalWarnings = warnings.reduce((n, e) => n + e.messages.length, 0)
+
+  if (totalFatal > 0) {
+    const s = totalFatal !== 1 ? 's' : ''
+    console.log(pc.red(`  Found ${totalFatal} fatal error${s}. Fix before loading.\n`))
+    process.exit(1)
+  } else if (totalWarnings > 0) {
+    const s = totalWarnings !== 1 ? 's' : ''
+    console.log(pc.yellow(`  Found ${totalWarnings} warning${s}. Review seeds above.\n`))
+  } else {
+    console.log(pc.green('  All seeds valid.\n'))
+  }
+}

package/src/index.ts

@@ -1,17 +1,24 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-export { seedLoad } from './commands/seed-load.js'
-export type { SeedLoadOptions } from './commands/seed-load.js'
-export { init } from './commands/init.js'
-export type { InitOptions } from './commands/init.js'
-export { validate, validateSeeds } from './commands/validate.js'
-export type { ValidateOptions, SeedValidationError } from './commands/validate.js'
-export { seedCreate } from './commands/seed-create.js'
-export type { SeedCreateOptions } from './commands/seed-create.js'
-export { deploy } from './commands/deploy.js'
-export type { DeployOptions } from './commands/deploy.js'
-export { onboard } from './commands/onboard.js'
-export type { OnboardOptions } from './commands/onboard.js'
-export { update } from './commands/update.js'
-export type { UpdateOptions } from './commands/update.js'
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+export { seedLoad } from './commands/seed-load.js'
+export type { SeedLoadOptions } from './commands/seed-load.js'
+export { init } from './commands/init.js'
+export type { InitOptions } from './commands/init.js'
+export { validate, validateSeeds } from './commands/validate.js'
+export type { ValidateOptions, SeedValidationError } from './commands/validate.js'
+export { seedCreate } from './commands/seed-create.js'
+export type { SeedCreateOptions } from './commands/seed-create.js'
+export { deploy } from './commands/deploy.js'
+export type { DeployOptions } from './commands/deploy.js'
+export { onboard } from './commands/onboard.js'
+export type { OnboardOptions } from './commands/onboard.js'
+export { update } from './commands/update.js'
+export type { UpdateOptions } from './commands/update.js'
+export { reset } from './commands/reset.js'
+export type { ResetOptions } from './commands/reset.js'
+export { generateTypes } from './commands/generate-types.js'
+export type { GenerateTypesOptions } from './commands/generate-types.js'
+export { schemaDiff } from './commands/schema-diff.js'
+export type { SchemaDiffOptions } from './commands/schema-diff.js'
+

package/src/lib/migration-writer.ts

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import { readdirSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  generateAddColumn,
+  generateIndexes,
+  planCreateSeed,
+  type Seed,
+} from '@beechcms/core'
+import type { SeedDiff } from './schema-diff.js'
+
+/** Statuses we will NOT auto-migrate — they need human review in a hand-written file. */
+const DESTRUCTIVE: ReadonlySet<SeedDiff['columns'][number]['status']> = new Set([
+  'extra', 'type_mismatch', 'fk_mismatch',
+])
+
+export interface MigrationPlan {
+  /** Full SQL file body (may be empty if no additive changes). */
+  sql: string
+  /** Number of executable (additive) statements emitted. */
+  additiveCount: number
+  /** Slugs whose drift includes destructive changes that were NOT emitted. */
+  destructiveSlugs: string[]
+}
+
+/** Scans a migrations dir and returns the next zero-padded 4-digit prefix (e.g. "0034"). */
+export function nextMigrationIndex(migrationsDir: string): string {
+  if (!existsSync(migrationsDir)) return '0000'
+  let max = -1
+  for (const f of readdirSync(migrationsDir)) {
+    const m = /^(\d{4})_/.exec(f)
+    if (m) max = Math.max(max, Number(m[1]))
+  }
+  return String(max + 1).padStart(4, '0')
+}
+
+/**
+ * Build an ADDITIVE migration from already-computed diffs.
+ * - tableExists === false        → full planCreateSeed(seed)
+ * - status 'missing'             → generateAddColumn(seed, branch)
+ * - status 'index_missing'       → matching CREATE INDEX IF NOT EXISTS line
+ * - destructive statuses         → emitted as a commented -- ⚠ block, never executable
+ * `seeds` MUST be dependency-sorted by the caller (sortSeedsByDependencies).
+ */
+export function buildMigrationSql(
+  diffs: SeedDiff[],
+  registry: Record<string, Seed>,
+): MigrationPlan {
+  const lines: string[] = []
+  let additiveCount = 0
+  const destructiveSlugs: string[] = []
+
+  for (const diff of diffs) {
+    const seed = registry[diff.slug]
+    if (!seed) continue
+
+    if (!diff.tableExists) {
+      lines.push(`-- ${diff.slug}: create table from scratch`)
+      for (const stmt of planCreateSeed(seed)) { lines.push(stmt); additiveCount++ }
+      lines.push('')
+      continue
+    }
+
+    const missing = diff.columns.filter(c => c.status === 'missing')
+    const idxMissing = diff.columns.filter(c => c.status === 'index_missing')
+    const destructive = diff.columns.filter(c => DESTRUCTIVE.has(c.status))
+
+    if (missing.length || idxMissing.length) {
+      lines.push(`-- ${diff.slug}: additive changes`)
+      for (const col of missing) {
+        const branch = seed.branches.find(b => b.alias === col.name)
+        if (branch) { lines.push(generateAddColumn(seed, branch)); additiveCount++ }
+      }
+      // generateIndexes is idempotent (CREATE INDEX IF NOT EXISTS) — re-emitting is safe.
+      if (idxMissing.length) {
+        for (const stmt of generateIndexes(seed)) { lines.push(stmt); additiveCount++ }
+      }
+      lines.push('')
+    }
+
+    if (destructive.length) {
+      destructiveSlugs.push(diff.slug)
+      lines.push(`-- ⚠ ${diff.slug}: DESTRUCTIVE drift NOT auto-migrated — review manually:`)
+      for (const col of destructive) {
+        lines.push(`--   ${col.status}: ${col.name}` +
+          (col.actualType ? ` (db: ${col.actualType})` : ''))
+      }
+      lines.push('')
+    }
+  }
+
+  return { sql: lines.join('\n').trimEnd() + '\n', additiveCount, destructiveSlugs }
+}
+
+/** Writes the migration file and returns its absolute path. */
+export function writeMigrationFile(
+  migrationsDir: string, index: string, name: string, sql: string,
+): string {
+  if (!existsSync(migrationsDir)) mkdirSync(migrationsDir, { recursive: true })
+  const safe = name.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '') || 'schema_sync'
+  const file = join(migrationsDir, `${index}_${safe}.sql`)
+  writeFileSync(file, sql, 'utf-8')
+  return file
+}

package/src/lib/schema-diff.ts

@@ -1,150 +1,175 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import type { Seed } from '@beechcms/core'
-import { getExpectedColumns, type SchemaColumn } from '@beechcms/core'
-import type { WranglerOptions, D1Row } from './wrangler.js'
-import { queryD1 } from './wrangler.js'
-
-interface PragmaRow extends D1Row {
-  name: string
-  type: string
-  notnull: number
-  pk: number
-}
-
-interface FkRow extends D1Row {
-  id: number
-  seq: number
-  table: string
-  from: string
-  to: string
-  on_update: string
-  on_delete: string
-  match: string
-}
-
-interface IndexRow extends D1Row {
-  seq: number
-  name: string
-  unique: number
-}
-
-export interface ColumnDiff {
-  name: string
-  status: 'ok' | 'missing' | 'extra' | 'type_mismatch' | 'fk_missing' | 'fk_mismatch' | 'index_missing'
-  expectedType?: string
-  actualType?: string
-  /** For fk_missing/fk_mismatch: expected FK target table */
-  expectedTarget?: string
-  /** For fk_mismatch: what the DB actually has */
-  expected?: string
-  actual?: string
-}
-
-export interface SeedDiff {
-  slug: string
-  tableExists: boolean
-  columns: ColumnDiff[]
-}
-
-export async function diffSeed(seed: Seed, options: WranglerOptions): Promise<SeedDiff> {
-  const tableName = `content_${seed.slug}`
-  const expected = getExpectedColumns(seed)
-
-  let actual: PragmaRow[]
-  try {
-    actual = queryD1<PragmaRow>(`PRAGMA table_info(${tableName})`, options)
-  } catch {
-    return { slug: seed.slug, tableExists: false, columns: expected.map(c => ({ name: c.name, status: 'missing', expectedType: c.sqlType })) }
-  }
-
-  if (actual.length === 0) {
-    return { slug: seed.slug, tableExists: false, columns: expected.map(c => ({ name: c.name, status: 'missing', expectedType: c.sqlType })) }
-  }
-
-  const actualMap = new Map<string, PragmaRow>(actual.map(r => [r.name, r]))
-  const expectedSet = new Set<string>(expected.map(c => c.name))
-
-  const columns: ColumnDiff[] = []
-
-  // ── Column presence + type checks ────────────────────────────────────────
-  for (const col of expected) {
-    const actualRow = actualMap.get(col.name)
-    if (!actualRow) {
-      columns.push({ name: col.name, status: 'missing', expectedType: col.sqlType })
-    } else if (actualRow.type.toUpperCase() !== col.sqlType) {
-      columns.push({ name: col.name, status: 'type_mismatch', expectedType: col.sqlType, actualType: actualRow.type })
-    } else {
-      columns.push({ name: col.name, status: 'ok' })
-    }
-  }
-
-  for (const row of actual) {
-    if (!expectedSet.has(row.name)) {
-      columns.push({ name: row.name, status: 'extra', actualType: row.type })
-    }
-  }
-
-  // ── FK + index checks for relation branches ──────────────────────────────
-  const relationBranches = seed.branches.filter(b => b.type === 'relation' && b.targetSeed)
-
-  if (relationBranches.length > 0) {
-    let fkList: FkRow[] = []
-    let indexList: IndexRow[] = []
-    try {
-      fkList = queryD1<FkRow>(`PRAGMA foreign_key_list(${tableName})`, options)
-      indexList = queryD1<IndexRow>(`PRAGMA index_list(${tableName})`, options)
-    } catch {
-      // If PRAGMA fails (table may not exist yet), skip FK checks
-    }
-
-    // Build maps for fast lookup
-    // fkList has one row per FK column; `from` = local col, `table` = referenced table
-    const fkByCol = new Map<string, FkRow>()
-    for (const fk of fkList) {
-      fkByCol.set(fk.from, fk)
-    }
-    const indexNames = new Set(indexList.map(i => i.name))
-
-    for (const branch of relationBranches) {
-      const expectedFkTable = `content_${branch.targetSeed}`
-      const expectedOnDelete = (branch.onDelete ?? 'SET NULL').toUpperCase()
-      const expectedIndexName = `idx_${seed.slug}_${branch.alias}`
-
-      // Find column diff entry for this branch (already evaluated above)
-      const colDiff = columns.find(c => c.name === branch.alias)
-      if (!colDiff || colDiff.status === 'missing') continue // already flagged
-
-      const fk = fkByCol.get(branch.alias)
-
-      if (!fk) {
-        // Column exists but no FK
-        colDiff.status = 'fk_missing'
-        colDiff.expectedTarget = branch.targetSeed
-      } else {
-        const actualTable = fk.table
-        const actualOnDelete = fk.on_delete.toUpperCase()
-        if (actualTable !== expectedFkTable || actualOnDelete !== expectedOnDelete) {
-          colDiff.status = 'fk_mismatch'
-          colDiff.expected = `→ ${expectedFkTable}(id) ON DELETE ${expectedOnDelete}`
-          colDiff.actual = `→ ${actualTable}(id) ON DELETE ${actualOnDelete}`
-          colDiff.expectedTarget = branch.targetSeed
-        }
-      }
-
-      // Check index separately (can coexist with fk status)
-      if (!indexNames.has(expectedIndexName)) {
-        // Only add index_missing if the column is otherwise OK (FK issue takes precedence)
-        if (colDiff.status === 'ok') {
-          colDiff.status = 'index_missing'
-        } else {
-          // Append index info to the existing diff row as a separate entry
-          columns.push({ name: branch.alias, status: 'index_missing' })
-        }
-      }
-    }
-  }
-
-  return { slug: seed.slug, tableExists: true, columns }
-}
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import pc from 'picocolors'
+import type { Seed } from '@beechcms/core'
+import { getExpectedColumns } from '@beechcms/core'
+import type { WranglerOptions, D1Row } from './wrangler.js'
+import { queryD1 } from './wrangler.js'
+
+interface PragmaRow extends D1Row {
+  name: string
+  type: string
+  notnull: number
+  pk: number
+}
+
+interface FkRow extends D1Row {
+  id: number
+  seq: number
+  table: string
+  from: string
+  to: string
+  on_update: string
+  on_delete: string
+  match: string
+}
+
+interface IndexRow extends D1Row {
+  seq: number
+  name: string
+  unique: number
+}
+
+export interface ColumnDiff {
+  name: string
+  status: 'ok' | 'missing' | 'extra' | 'type_mismatch' | 'fk_missing' | 'fk_mismatch' | 'index_missing'
+  expectedType?: string
+  actualType?: string
+  /** For fk_missing/fk_mismatch: expected FK target table */
+  expectedTarget?: string
+  /** For fk_mismatch: what the DB actually has */
+  expected?: string
+  actual?: string
+}
+
+export interface SeedDiff {
+  slug: string
+  tableExists: boolean
+  columns: ColumnDiff[]
+}
+
+/** Returns true if the seed's table fully matches its Seed (no drift). */
+export function isSeedClean(diff: SeedDiff): boolean {
+  return diff.tableExists && diff.columns.every(c => c.status === 'ok')
+}
+
+/** Human-readable drift report for one seed. Pure formatting — no I/O decisions. */
+export function renderSeedDiff(diff: SeedDiff): void {
+  const table = `content_${diff.slug}`
+  if (!diff.tableExists) { console.log(pc.red(`  ✗ ${table} — table missing`)); return }
+  const problems = diff.columns.filter(c => c.status !== 'ok')
+  if (problems.length === 0) { console.log(pc.green(`  ✓ ${table}`)); return }
+  console.log(pc.yellow(`  ⚠ ${table}`))
+  for (const col of problems) {
+    switch (col.status) {
+      case 'missing':       console.log(pc.red(`    + missing column: ${col.name} ${col.expectedType}`)); break
+      case 'extra':         console.log(pc.dim(`    ~ orphaned column: "${col.name}" (${col.actualType}) — in DB, not in seeds.ts`)); break
+      case 'type_mismatch': console.log(pc.red(`    ≠ type mismatch:  ${col.name} (expected ${col.expectedType}, got ${col.actualType})`)); break
+      case 'fk_missing':    console.log(pc.red(`    ⤬ missing FK: ${col.name} → content_${col.expectedTarget}(id)`)); break
+      case 'fk_mismatch':   console.log(pc.yellow(`    ⤬ FK mismatch: ${col.name} expected ${col.expected}, got ${col.actual}`)); break
+      case 'index_missing': console.log(pc.yellow(`    ⊘ missing index on ${col.name}`)); break
+    }
+  }
+}
+
+export async function diffSeed(seed: Seed, options: WranglerOptions): Promise<SeedDiff> {
+  const tableName = `content_${seed.slug}`
+  const expected = getExpectedColumns(seed)
+
+  let actual: PragmaRow[]
+  try {
+    actual = queryD1<PragmaRow>(`PRAGMA table_info(${tableName})`, options)
+  } catch {
+    return { slug: seed.slug, tableExists: false, columns: expected.map(c => ({ name: c.name, status: 'missing', expectedType: c.sqlType })) }
+  }
+
+  if (actual.length === 0) {
+    return { slug: seed.slug, tableExists: false, columns: expected.map(c => ({ name: c.name, status: 'missing', expectedType: c.sqlType })) }
+  }
+
+  const actualMap = new Map<string, PragmaRow>(actual.map(r => [r.name, r]))
+  const expectedSet = new Set<string>(expected.map(c => c.name))
+
+  const columns: ColumnDiff[] = []
+
+  // ── Column presence + type checks ────────────────────────────────────────
+  for (const col of expected) {
+    const actualRow = actualMap.get(col.name)
+    if (!actualRow) {
+      columns.push({ name: col.name, status: 'missing', expectedType: col.sqlType })
+    } else if (actualRow.type.toUpperCase() !== col.sqlType) {
+      columns.push({ name: col.name, status: 'type_mismatch', expectedType: col.sqlType, actualType: actualRow.type })
+    } else {
+      columns.push({ name: col.name, status: 'ok' })
+    }
+  }
+
+  for (const row of actual) {
+    if (!expectedSet.has(row.name)) {
+      columns.push({ name: row.name, status: 'extra', actualType: row.type })
+    }
+  }
+
+  // ── FK + index checks for relation branches ──────────────────────────────
+  const relationBranches = seed.branches.filter(b => b.type === 'relation' && b.targetSeed)
+
+  if (relationBranches.length > 0) {
+    let fkList: FkRow[] = []
+    let indexList: IndexRow[] = []
+    try {
+      fkList = queryD1<FkRow>(`PRAGMA foreign_key_list(${tableName})`, options)
+      indexList = queryD1<IndexRow>(`PRAGMA index_list(${tableName})`, options)
+    } catch {
+      // If PRAGMA fails (table may not exist yet), skip FK checks
+    }
+
+    // Build maps for fast lookup
+    // fkList has one row per FK column; `from` = local col, `table` = referenced table
+    const fkByCol = new Map<string, FkRow>()
+    for (const fk of fkList) {
+      fkByCol.set(fk.from, fk)
+    }
+    const indexNames = new Set(indexList.map(i => i.name))
+
+    for (const branch of relationBranches) {
+      const expectedFkTable = `content_${branch.targetSeed}`
+      const expectedOnDelete = (branch.onDelete ?? 'SET NULL').toUpperCase()
+      const expectedIndexName = `idx_${seed.slug}_${branch.alias}`
+
+      // Find column diff entry for this branch (already evaluated above)
+      const colDiff = columns.find(c => c.name === branch.alias)
+      if (!colDiff || colDiff.status === 'missing') continue // already flagged
+
+      const fk = fkByCol.get(branch.alias)
+
+      if (!fk) {
+        // Column exists but no FK
+        colDiff.status = 'fk_missing'
+        colDiff.expectedTarget = branch.targetSeed
+      } else {
+        const actualTable = fk.table
+        const actualOnDelete = fk.on_delete.toUpperCase()
+        if (actualTable !== expectedFkTable || actualOnDelete !== expectedOnDelete) {
+          colDiff.status = 'fk_mismatch'
+          colDiff.expected = `→ ${expectedFkTable}(id) ON DELETE ${expectedOnDelete}`
+          colDiff.actual = `→ ${actualTable}(id) ON DELETE ${actualOnDelete}`
+          colDiff.expectedTarget = branch.targetSeed
+        }
+      }
+
+      // Check index separately (can coexist with fk status)
+      if (!indexNames.has(expectedIndexName)) {
+        // Only add index_missing if the column is otherwise OK (FK issue takes precedence)
+        if (colDiff.status === 'ok') {
+          colDiff.status = 'index_missing'
+        } else {
+          // Append index info to the existing diff row as a separate entry
+          columns.push({ name: branch.alias, status: 'index_missing' })
+        }
+      }
+    }
+  }
+
+  return { slug: seed.slug, tableExists: true, columns }
+}