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

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,17 @@
-// 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'

package/src/lib/schema-diff.ts

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