@beechcms/cli 0.6.0-preview.3 → 0.6.0

package/src/commands/validate.ts

@@ -1,80 +0,0 @@
-// 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,20 +0,0 @@
-// 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'
-

package/src/lib/schema-diff.ts

@@ -1,150 +0,0 @@
-// 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 }
-}

package/src/lib/wrangler.ts

@@ -1,129 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import { spawnSync, type SpawnSyncReturns } from 'node:child_process'
-import { writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-
-export interface WranglerOptions {
-  db: string
-  local: boolean
-  configPath: string | null
-}
-
-export interface D1Row {
-  [key: string]: unknown
-}
-
-interface WranglerResult {
-  results: D1Row[]
-  success: boolean
-  error?: string
-}
-
-function buildArgs(options: WranglerOptions): string[] {
-  const args: string[] = []
-  if (options.configPath) args.push('--config', options.configPath)
-  if (options.local) args.push('--local')
-  else args.push('--remote')
-  return args
-}
-
-/** Esegue SQL da file temporaneo via `wrangler d1 execute --file`. Returns true on success. */
-export function executeD1File(sql: string, options: WranglerOptions): boolean {
-  const tmpFile = join(tmpdir(), `beech-seed-${Date.now()}.sql`)
-  try {
-    writeFileSync(tmpFile, sql, 'utf-8')
-    const args = ['d1', 'execute', options.db, '--file', tmpFile, ...buildArgs(options)]
-    const result = spawnSync('npx', ['wrangler', ...args], { stdio: 'inherit', cwd: process.cwd(), shell: true })
-    return result.status === 0
-  } finally {
-    try { rmSync(tmpFile) } catch {}
-  }
-}
-
-/**
- * Esegue una query SQL e ritorna i risultati come array di oggetti (--json).
- *
- * Passa il SQL via file temporaneo (`--file`) anziché `--command`: su Windows,
- * `spawnSync` con `shell: true` non preserva le virgolette/spazi/virgole interni
- * a un argomento inline, e wrangler riceve il comando spezzato in token sciolti
- * ("Unknown arguments: name, FROM, sqlite_master, …"). Il file evita del tutto
- * il riquoting della shell — stesso approccio di `executeD1File`.
- */
-export function queryD1<T extends D1Row = D1Row>(sql: string, options: WranglerOptions): T[] {
-  const tmpFile = join(tmpdir(), `beech-query-${Date.now()}.sql`)
-  let result: SpawnSyncReturns<string>
-  try {
-    writeFileSync(tmpFile, sql, 'utf-8')
-    const args = ['d1', 'execute', options.db, '--file', tmpFile, '--json', ...buildArgs(options)]
-    result = spawnSync('npx', ['wrangler', ...args], { encoding: 'utf-8', cwd: process.cwd(), shell: true })
-  } finally {
-    try { rmSync(tmpFile) } catch {}
-  }
-
-  if (result.status !== 0) {
-    throw new Error(`wrangler d1 execute failed:\n${result.stderr}`)
-  }
-
-  try {
-    const parsed: WranglerResult[] = JSON.parse(result.stdout)
-    return (parsed[0]?.results ?? []) as T[]
-  } catch {
-    throw new Error(`Failed to parse wrangler JSON output:\n${result.stdout}`)
-  }
-}
-
-/** Trova il path di wrangler.jsonc risalendo l'albero da CWD fino alla root del filesystem. */
-export function findWranglerConfig(): string | null {
-  let dir = process.cwd()
-  while (true) {
-    for (const name of ['wrangler.jsonc', 'wrangler.json', 'wrangler.toml']) {
-      const p = resolve(dir, name)
-      if (existsSync(p)) return p
-    }
-    for (const name of ['wrangler.jsonc', 'wrangler.json', 'wrangler.toml']) {
-      const p = resolve(dir, 'apps', 'api', name)
-      if (existsSync(p)) return p
-    }
-    const parent = resolve(dir, '..')
-    if (parent === dir) break
-    dir = parent
-  }
-  return null
-}
-
-/** Wraps a string value in single quotes, escaping internal single quotes for SQL literals. */
-export function sqlQuote(value: string): string {
-  return `'${value.replace(/'/g, "''")}'`
-}
-
-/** Risolve il nome del database D1 da wrangler.jsonc (stripping JSONC comments). */
-export function resolveDbName(configPath: string | null): string {
-  if (!configPath) return 'beech-db'
-  try {
-    const raw = readFileSync(configPath, 'utf-8')
-    
-    if (configPath.endsWith('.toml')) {
-      // Basic regex-based TOML parsing for d1_databases
-      // Matches both [d1_databases] and [[d1_databases]]
-      const d1SectionMatch = raw.match(/\[\[?d1_databases\]\]?[\s\S]*?(?=\n\[|$)/)
-      if (d1SectionMatch) {
-        const section = d1SectionMatch[0]
-        const dbNameMatch = section.match(/database_name\s*=\s*["'](.+?)["']/)
-        if (dbNameMatch) return dbNameMatch[1]
-      }
-      return 'beech-db'
-    }
-
-    const stripped = raw
-      .replace(/\/\/[^\n]*/g, '')
-      .replace(/\/\*[\s\S]*?\*\//g, '')
-    const parsed = JSON.parse(stripped)
-    const bindings: { database_name?: string }[] = parsed?.d1_databases ?? []
-    return bindings[0]?.database_name ?? 'beech-db'
-  } catch {
-    return 'beech-db'
-  }
-}

package/src/test/reset.test.ts

@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { reset } from '../commands/reset.js'
-import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-
-vi.mock('node:child_process', () => ({
-  spawnSync: vi.fn(() => ({ status: 0 })),
-}))
-
-vi.mock('node:fs', () => ({
-  existsSync: vi.fn(),
-  rmSync: vi.fn(),
-  readFileSync: vi.fn(() => '{}'),
-}))
-
-vi.mock('picocolors', () => ({
-  default: {
-    cyan: (s: string) => s,
-    dim: (s: string) => s,
-    green: (s: string) => s,
-    red: (s: string) => s,
-    yellow: (s: string) => s,
-  },
-}))
-
-describe('reset command', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(spawnSync).mockImplementation(() => ({ status: 0 } as any))
-  })
-
-  it('runs docker compose down when --docker is passed and docker is running', async () => {
-    await reset({ docker: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'docker',
-      ['compose', 'down', '-v'],
-      expect.any(Object)
-    )
-  })
-
-  it('does not run docker compose down when docker is not installed', async () => {
-    // Mock docker --version to fail
-    vi.mocked(spawnSync).mockImplementation((cmd: string, args?: any) => {
-      if (cmd === 'docker' && args && args[0] === '--version') {
-        return { status: 1 } as any
-      }
-      return { status: 0 } as any
-    })
-
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
-    try {
-      await reset({ docker: true })
-      expect(spawnSync).not.toHaveBeenCalledWith(
-        'docker',
-        ['compose', 'down', '-v'],
-        expect.any(Object)
-      )
-      expect(mockExit).toHaveBeenCalledWith(1)
-    } finally {
-      mockExit.mockRestore()
-    }
-  })
-
-  it('does not run docker compose down when docker daemon is not running', async () => {
-    // Mock docker info to fail
-    vi.mocked(spawnSync).mockImplementation((cmd: string, args?: any) => {
-      if (cmd === 'docker' && args && args[0] === 'info') {
-        return { status: 1 } as any
-      }
-      return { status: 0 } as any
-    })
-
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
-    try {
-      await reset({ docker: true })
-      expect(spawnSync).not.toHaveBeenCalledWith(
-        'docker',
-        ['compose', 'down', '-v'],
-        expect.any(Object)
-      )
-      expect(mockExit).toHaveBeenCalledWith(1)
-    } finally {
-      mockExit.mockRestore()
-    }
-  })
-
-  it('runs db reset using npm script when apps/api has package.json', async () => {
-    vi.mocked(existsSync).mockImplementation((path: any) => {
-      if (typeof path === 'string' && path.includes('apps') && path.includes('package.json')) {
-        return true
-      }
-      return false
-    })
-
-    await reset({ db: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'db:reset:local'],
-      expect.objectContaining({
-        cwd: expect.stringMatching(/apps[/\\]api/),
-      })
-    )
-  })
-
-  it('runs both docker and db when --all is passed', async () => {
-    vi.mocked(existsSync).mockImplementation((path: any) => {
-      if (typeof path === 'string' && path.includes('apps') && path.includes('package.json')) {
-        return true
-      }
-      return false
-    })
-
-    await reset({ all: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'docker',
-      ['compose', 'down', '-v'],
-      expect.any(Object)
-    )
-    expect(spawnSync).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'db:reset:local'],
-      expect.any(Object)
-    )
-  })
-})

package/src/test/seed-load.test.ts

@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { sortSeedsByDependencies } from '@beechcms/core'
-import type { Seed } from '@beechcms/core'
-import { sqlQuote } from '../lib/wrangler.js'
-import { buildSeedRegistrationSql } from '../commands/seed-load.js'
-
-// These seeds declare articles BEFORE team (arbitrary user order in seed.ts)
-const TEAM_SEED: Seed = {
-  slug: 'team',
-  label: 'Team',
-  displayNameAlias: 'name',
-  branches: [{ alias: 'name', label: 'Name', type: 'text' }],
-} as Seed
-
-const ARTICLES_SEED: Seed = {
-  slug: 'articles',
-  label: 'Articles',
-  displayNameAlias: 'title',
-  branches: [
-    { alias: 'title', label: 'Title', type: 'text' },
-    { alias: 'author_id', label: 'Author', type: 'relation', targetSeed: 'team' },
-  ],
-} as Seed
-
-describe('sortSeedsByDependencies — topological ordering', () => {
-  it('puts team before articles even when articles is declared first', () => {
-    // articles declared first — arbitrary insertion order
-    const sorted = sortSeedsByDependencies([ARTICLES_SEED, TEAM_SEED])
-    const slugs = sorted.map(s => s.slug)
-    expect(slugs.indexOf('team')).toBeLessThan(slugs.indexOf('articles'))
-  })
-
-  it('preserves order for seeds with no relations', () => {
-    const a = { slug: 'a', label: 'A', displayNameAlias: 'x', branches: [{ alias: 'x', label: 'X', type: 'text' }] } as Seed
-    const b = { slug: 'b', label: 'B', displayNameAlias: 'x', branches: [{ alias: 'x', label: 'X', type: 'text' }] } as Seed
-    const sorted = sortSeedsByDependencies([a, b])
-    expect(sorted).toHaveLength(2)
-  })
-
-  it('throws on unknown targetSeed', () => {
-    const bad: Seed = {
-      slug: 'bad',
-      label: 'Bad',
-      displayNameAlias: 'title',
-      branches: [
-        { alias: 'title', label: 'Title', type: 'text' },
-        { alias: 'ref_id', label: 'Ref', type: 'relation', targetSeed: 'ghost' },
-      ],
-    } as Seed
-    expect(() => sortSeedsByDependencies([bad])).toThrow(/unknown target|ghost/)
-  })
-
-  it('throws on cyclic graph', () => {
-    const a = {
-      slug: 'a', label: 'A', displayNameAlias: 'x',
-      branches: [
-        { alias: 'x', label: 'X', type: 'text' },
-        { alias: 'b_id', label: 'B', type: 'relation', targetSeed: 'b' },
-      ],
-    } as Seed
-    const b = {
-      slug: 'b', label: 'B', displayNameAlias: 'x',
-      branches: [
-        { alias: 'x', label: 'X', type: 'text' },
-        { alias: 'a_id', label: 'A', type: 'relation', targetSeed: 'a' },
-      ],
-    } as Seed
-    expect(() => sortSeedsByDependencies([a, b])).toThrow(/[Cc]ycl/)
-  })
-})
-
-// ── sqlQuote ─────────────────────────────────────────────────────────────
-
-describe('sqlQuote', () => {
-  it('wraps value in single quotes', () => {
-    expect(sqlQuote('hello')).toBe("'hello'")
-  })
-
-  it("escapes internal single quotes by doubling them", () => {
-    expect(sqlQuote("it's")).toBe("'it''s'")
-  })
-
-  it('handles multiple single quotes', () => {
-    expect(sqlQuote("a'b'c")).toBe("'a''b''c'")
-  })
-
-  it('handles empty string', () => {
-    expect(sqlQuote('')).toBe("''")
-  })
-})
-
-// ── buildSeedRegistrationSql ─────────────────────────────────────────────
-
-describe('buildSeedRegistrationSql', () => {
-  const SIMPLE_SEED: Seed = {
-    slug: 'posts',
-    label: 'Posts',
-    displayNameAlias: 'title',
-    branches: [{ id: 'br_01', alias: 'title', label: 'Title', type: 'text' }],
-  } as Seed
-
-  it('produces INSERT … ON CONFLICT for the correct slug', () => {
-    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
-    expect(sql).toContain("INSERT INTO seeds")
-    expect(sql).toContain("ON CONFLICT(slug) DO UPDATE SET")
-    expect(sql).toContain("'posts'")
-  })
-
-  it("sets source to 'code'", () => {
-    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
-    expect(sql).toContain("'code'")
-  })
-
-  it('escapes single quotes in slug and JSON literal', () => {
-    const seedWithApostrophe: Seed = {
-      ...SIMPLE_SEED,
-      slug: "it's",
-      label: "It's",
-    }
-    const sql = buildSeedRegistrationSql(seedWithApostrophe)
-    // Slug value must have its single quote doubled
-    expect(sql).toContain("'it''s'")
-    // JSON label must also have its single quote doubled
-    expect(sql).toContain("It''s")
-  })
-
-  it('does not contain unescaped single quotes inside the JSON literal', () => {
-    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
-    const jsonStart = sql.indexOf("VALUES (")
-    const jsonPart = sql.slice(jsonStart)
-    // Extract the JSON literal between the second pair of outer quotes
-    // Verify it round-trips back to the original seed
-    const inner = JSON.stringify(SIMPLE_SEED).replace(/'/g, "''")
-    expect(sql).toContain(inner)
-  })
-})
-
-// ── Dry-run output ordering ───────────────────────────────────────────────
-// Verify that seed-load uses sortSeedsByDependencies (not Object.values order)
-// by testing the pure function behavior that underpins it.
-
-describe('seed-load dry-run ordering contract', () => {
-  it('content_team CREATE TABLE appears before content_articles when articles declared first', () => {
-    // The dry-run loops over sortSeedsByDependencies(Object.values(registry)).
-    // We verify the sort result here — the integration is in seed-load.ts.
-    const registry = {
-      articles: ARTICLES_SEED, // declared first
-      team: TEAM_SEED,
-    }
-    const sorted = sortSeedsByDependencies(Object.values(registry))
-    const slugs = sorted.map(s => s.slug)
-    // team must come first so its CREATE TABLE is emitted before articles'
-    expect(slugs.indexOf('team')).toBeLessThan(slugs.indexOf('articles'))
-  })
-})