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

package/src/lib/wrangler.ts

@@ -1,129 +1,129 @@
-// 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'
-  }
-}
+// 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/generate-types.test.ts

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { existsSync, readFileSync, rmSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { tmpdir } from 'node:os'
+import type { Seed } from '@beechcms/core'
+import { generateTypes } from '../commands/generate-types.js'
+
+const ARTICLES_SEED: Seed = {
+  slug: 'articles',
+  label: 'Articles',
+  displayNameAlias: 'title',
+  branches: [
+    { alias: 'title', label: 'Title', type: 'text', requiredOnCreate: true },
+    { alias: 'body', label: 'Body', type: 'richtext' },
+  ],
+} as Seed
+
+const registry: Record<string, Seed> = { articles: ARTICLES_SEED }
+
+const outPath = resolve(tmpdir(), `beech-test-${Date.now()}.ts`)
+
+afterEach(() => {
+  if (existsSync(outPath)) rmSync(outPath)
+})
+
+describe('generateTypes — local registry (injected)', () => {
+  it('writes the output file', async () => {
+    await generateTypes({ out: outPath, local: true, registry })
+    expect(existsSync(outPath)).toBe(true)
+  })
+
+  it('output contains the interface', async () => {
+    await generateTypes({ out: outPath, local: true, registry })
+    const content = readFileSync(outPath, 'utf-8')
+    expect(content).toContain('export interface Articles {')
+  })
+
+  it('output starts with the auto-generated banner', async () => {
+    await generateTypes({ out: outPath, local: true, registry })
+    const content = readFileSync(outPath, 'utf-8')
+    expect(content).toContain('generato automaticamente')
+  })
+
+  it('output contains SeedRegistryTypes', async () => {
+    await generateTypes({ out: outPath, local: true, registry })
+    const content = readFileSync(outPath, 'utf-8')
+    expect(content).toContain('export interface SeedRegistryTypes {')
+  })
+
+  it('exits with an error when registry is empty', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+    await expect(generateTypes({ out: outPath, local: true, registry: {} })).rejects.toThrow('exit')
+    exitSpy.mockRestore()
+  })
+})

package/src/test/reset.test.ts

@@ -0,0 +1,128 @@
+// 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/schema-diff.test.ts

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mkdirSync, readdirSync, rmSync } from 'node:fs'
+import type { Seed } from '@beechcms/core'
+
+// ── fixtures ─────────────────────────────────────────────────────────────────
+
+const ARTICLE_SEED: Seed = {
+  slug: 'articles',
+  label: 'Articles',
+  displayNameAlias: 'title',
+  branches: [
+    { alias: 'title', label: 'Title', type: 'text' },
+    { alias: 'views', label: 'Views', type: 'number' },
+  ],
+} as Seed
+
+const REGISTRY: Record<string, Seed> = { articles: ARTICLE_SEED }
+
+// ── nextMigrationIndex ────────────────────────────────────────────────────────
+
+describe('nextMigrationIndex', () => {
+  let dir: string
+
+  beforeEach(() => {
+    dir = join(tmpdir(), `beech-test-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+  })
+
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
+
+  it('returns 0000 when directory is empty', async () => {
+    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
+    expect(nextMigrationIndex(dir)).toBe('0000')
+  })
+
+  it('returns 0034 when highest prefix is 0033', async () => {
+    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
+    for (const name of ['0031_foo.sql', '0033_bar.sql', '0029_baz.sql']) {
+      const { writeFileSync } = await import('node:fs')
+      writeFileSync(join(dir, name), '')
+    }
+    expect(nextMigrationIndex(dir)).toBe('0034')
+  })
+
+  it('returns 0000 when directory does not exist', async () => {
+    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
+    expect(nextMigrationIndex(join(tmpdir(), 'no-such-dir-beech'))).toBe('0000')
+  })
+})
+
+// ── buildMigrationSql ─────────────────────────────────────────────────────────
+
+describe('buildMigrationSql — additive emission', () => {
+  it('emits planCreateSeed statements when table is missing', async () => {
+    const { buildMigrationSql } = await import('../lib/migration-writer.js')
+    const diffs = [{ slug: 'articles', tableExists: false, columns: [] }]
+    const plan = buildMigrationSql(diffs, REGISTRY)
+    expect(plan.additiveCount).toBeGreaterThan(0)
+    expect(plan.sql).toContain('articles')
+    expect(plan.destructiveSlugs).toHaveLength(0)
+  })
+
+  it('emits generateAddColumn for missing columns', async () => {
+    const { buildMigrationSql } = await import('../lib/migration-writer.js')
+    const diffs = [{
+      slug: 'articles',
+      tableExists: true,
+      columns: [
+        { name: 'title', status: 'ok' as const },
+        { name: 'views', status: 'missing' as const, expectedType: 'REAL' },
+      ],
+    }]
+    const plan = buildMigrationSql(diffs, REGISTRY)
+    expect(plan.additiveCount).toBeGreaterThan(0)
+    expect(plan.sql).toContain('views')
+    expect(plan.destructiveSlugs).toHaveLength(0)
+  })
+
+  it('emits commented block for destructive drift, not executable SQL', async () => {
+    const { buildMigrationSql } = await import('../lib/migration-writer.js')
+    const diffs = [{
+      slug: 'articles',
+      tableExists: true,
+      columns: [
+        { name: 'title', status: 'type_mismatch' as const, expectedType: 'TEXT', actualType: 'INTEGER' },
+      ],
+    }]
+    const plan = buildMigrationSql(diffs, REGISTRY)
+    expect(plan.additiveCount).toBe(0)
+    expect(plan.destructiveSlugs).toContain('articles')
+    expect(plan.sql).toContain('-- ⚠')
+    expect(plan.sql).not.toMatch(/^ALTER TABLE/m)
+    expect(plan.sql).not.toMatch(/^DROP/m)
+  })
+
+  it('additiveCount is 0 when only destructive drift exists', async () => {
+    const { buildMigrationSql } = await import('../lib/migration-writer.js')
+    const diffs = [{
+      slug: 'articles',
+      tableExists: true,
+      columns: [
+        { name: 'title', status: 'extra' as const, actualType: 'TEXT' },
+      ],
+    }]
+    const plan = buildMigrationSql(diffs, REGISTRY)
+    expect(plan.additiveCount).toBe(0)
+    expect(plan.destructiveSlugs).toContain('articles')
+  })
+
+  it('processes seeds with no drift as no-op', async () => {
+    const { buildMigrationSql } = await import('../lib/migration-writer.js')
+    const diffs = [{
+      slug: 'articles',
+      tableExists: true,
+      columns: [
+        { name: 'title', status: 'ok' as const },
+        { name: 'views', status: 'ok' as const },
+      ],
+    }]
+    const plan = buildMigrationSql(diffs, REGISTRY)
+    expect(plan.additiveCount).toBe(0)
+    expect(plan.destructiveSlugs).toHaveLength(0)
+  })
+})
+
+// ── schemaDiff command ────────────────────────────────────────────────────────
+
+describe('schemaDiff command', () => {
+  beforeEach(() => { vi.resetModules() })
+
+  it('exits early when registry is empty', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const { schemaDiff } = await import('../commands/schema-diff.js')
+    await schemaDiff({ local: true, write: false, registry: {} })
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No seeds found'))
+    consoleSpy.mockRestore()
+  })
+
+  it('prints preview SQL without writing files when no --write', async () => {
+    vi.doMock('../lib/wrangler.js', () => ({
+      findWranglerConfig: () => null,
+      resolveDbName: () => 'beech-db',
+      queryD1: () => [],
+    }))
+    vi.doMock('../lib/schema-diff.js', async () => {
+      const actual = await vi.importActual('../lib/schema-diff.js') as object
+      return {
+        ...actual,
+        diffSeed: vi.fn().mockResolvedValue({
+          slug: 'articles', tableExists: false, columns: [],
+        }),
+      }
+    })
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const { schemaDiff } = await import('../commands/schema-diff.js')
+    await schemaDiff({ local: true, write: false, registry: REGISTRY })
+    const output = consoleSpy.mock.calls.flat().join('\n')
+    expect(output).toContain('Re-run with --write')
+    consoleSpy.mockRestore()
+    vi.doUnmock('../lib/wrangler.js')
+    vi.doUnmock('../lib/schema-diff.js')
+  })
+
+  it('writes migration file when --write and additive drift exists', async () => {
+    const dir = join(tmpdir(), `beech-schema-diff-test-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+
+    vi.doMock('../lib/wrangler.js', () => ({
+      findWranglerConfig: () => null,
+      resolveDbName: () => 'beech-db',
+      queryD1: () => [],
+    }))
+    vi.doMock('../lib/schema-diff.js', async () => {
+      const actual = await vi.importActual('../lib/schema-diff.js') as object
+      return {
+        ...actual,
+        diffSeed: vi.fn().mockResolvedValue({
+          slug: 'articles', tableExists: false, columns: [],
+        }),
+      }
+    })
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const { schemaDiff } = await import('../commands/schema-diff.js')
+    await schemaDiff({ local: true, write: true, name: 'test_migration', migrationsDir: dir, registry: REGISTRY })
+
+    const files = readdirSync(dir)
+    expect(files.some(f => f.endsWith('.sql'))).toBe(true)
+    const output = consoleSpy.mock.calls.flat().join('\n')
+    expect(output).toContain('Wrote')
+
+    consoleSpy.mockRestore()
+    rmSync(dir, { recursive: true, force: true })
+    vi.doUnmock('../lib/wrangler.js')
+    vi.doUnmock('../lib/schema-diff.js')
+  })
+
+  it('does not write file when only destructive drift', async () => {
+    vi.doMock('../lib/wrangler.js', () => ({
+      findWranglerConfig: () => null,
+      resolveDbName: () => 'beech-db',
+      queryD1: () => [],
+    }))
+    vi.doMock('../lib/schema-diff.js', async () => {
+      const actual = await vi.importActual('../lib/schema-diff.js') as object
+      return {
+        ...actual,
+        diffSeed: vi.fn().mockResolvedValue({
+          slug: 'articles',
+          tableExists: true,
+          columns: [{ name: 'title', status: 'type_mismatch', expectedType: 'TEXT', actualType: 'INTEGER' }],
+        }),
+      }
+    })
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const { schemaDiff } = await import('../commands/schema-diff.js')
+    await schemaDiff({ local: true, write: true, registry: REGISTRY })
+    const output = consoleSpy.mock.calls.flat().join('\n')
+    expect(output).toContain('Only destructive drift')
+
+    consoleSpy.mockRestore()
+    vi.doUnmock('../lib/wrangler.js')
+    vi.doUnmock('../lib/schema-diff.js')
+  })
+})