@beechcms/cli 0.4.0-preview.9 → 0.4.1

package/src/lib/schema-diff.ts

@@ -1,64 +1,64 @@
-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
-}
-
-export interface ColumnDiff {
-  name: string
-  status: 'ok' | 'missing' | 'extra' | 'type_mismatch'
-  expectedType?: string
-  actualType?: 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[] = []
-
-  for (const col of expected) {
-    const actual = actualMap.get(col.name)
-    if (!actual) {
-      columns.push({ name: col.name, status: 'missing', expectedType: col.sqlType })
-    } else if (actual.type.toUpperCase() !== col.sqlType) {
-      columns.push({ name: col.name, status: 'type_mismatch', expectedType: col.sqlType, actualType: actual.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 })
-    }
-  }
-
-  return { slug: seed.slug, tableExists: true, columns }
-}
+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
+}
+
+export interface ColumnDiff {
+  name: string
+  status: 'ok' | 'missing' | 'extra' | 'type_mismatch'
+  expectedType?: string
+  actualType?: 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[] = []
+
+  for (const col of expected) {
+    const actual = actualMap.get(col.name)
+    if (!actual) {
+      columns.push({ name: col.name, status: 'missing', expectedType: col.sqlType })
+    } else if (actual.type.toUpperCase() !== col.sqlType) {
+      columns.push({ name: col.name, status: 'type_mismatch', expectedType: col.sqlType, actualType: actual.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 })
+    }
+  }
+
+  return { slug: seed.slug, tableExists: true, columns }
+}

package/src/lib/wrangler.ts

@@ -1,108 +1,106 @@
-import { spawnSync } 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`. */
-export function executeD1File(sql: string, options: WranglerOptions): void {
-  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 })
-    if (result.status !== 0) {
-      process.exit(result.status ?? 1)
-    }
-  } finally {
-    try { rmSync(tmpFile) } catch {}
-  }
-}
-
-/** Esegue una query SQL e ritorna i risultati come array di oggetti (--json). */
-export function queryD1<T extends D1Row = D1Row>(sql: string, options: WranglerOptions): T[] {
-  const args = ['d1', 'execute', options.db, '--command', sql, '--json', ...buildArgs(options)]
-  const result = spawnSync('npx', ['wrangler', ...args], { encoding: 'utf-8', cwd: process.cwd(), shell: true })
-
-  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
-}
-
-/** 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'
-  }
-}
+import { spawnSync } 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). */
+export function queryD1<T extends D1Row = D1Row>(sql: string, options: WranglerOptions): T[] {
+  const args = ['d1', 'execute', options.db, '--command', sql, '--json', ...buildArgs(options)]
+  const result = spawnSync('npx', ['wrangler', ...args], { encoding: 'utf-8', cwd: process.cwd(), shell: true })
+
+  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
+}
+
+/** 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/tsconfig.json

@@ -1,16 +1,16 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "target": "ES2022"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"],
-  "references": [{ "path": "../core" }]
-}
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../core" }]
+}