@beechcms/cli 0.6.0-preview.4 → 0.6.1

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,24 +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'
-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

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

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/generate-types.test.ts

@@ -1,58 +0,0 @@
-// 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()
-  })
-})