@beechcms/cli 0.5.0 → 0.6.0-preview.2

package/dist/index.js

@@ -6,7 +6,11 @@ import {
   generateDraftTable,
   generateIndexes,
   generateFtsTable,
-  generateFtsTriggers
+  generateFtsTriggers,
+  generateJunctionTable,
+  generateJunctionIndexes,
+  generateJunctionDraftTable,
+  sortSeedsByDependencies
 } from "@beechcms/core";
 
 // src/lib/wrangler.ts
@@ -36,8 +40,18 @@ function executeD1File(sql, options) {
   }
 }
 function queryD1(sql, options) {
-  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 });
+  const tmpFile = join(tmpdir(), `beech-query-${Date.now()}.sql`);
+  let result;
+  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:
 ${result.stderr}`);
@@ -67,6 +81,9 @@ function findWranglerConfig() {
   }
   return null;
 }
+function sqlQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
 function resolveDbName(configPath) {
   if (!configPath) return "beech-db";
   try {
@@ -107,11 +124,11 @@ async function diffSeed(seed, options) {
   const expectedSet = new Set(expected.map((c) => c.name));
   const columns = [];
   for (const col of expected) {
-    const actual2 = actualMap.get(col.name);
-    if (!actual2) {
+    const actualRow = actualMap.get(col.name);
+    if (!actualRow) {
       columns.push({ name: col.name, status: "missing", expectedType: col.sqlType });
-    } else if (actual2.type.toUpperCase() !== col.sqlType) {
-      columns.push({ name: col.name, status: "type_mismatch", expectedType: col.sqlType, actualType: actual2.type });
+    } 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" });
     }
@@ -121,37 +138,57 @@ async function diffSeed(seed, options) {
       columns.push({ name: row.name, status: "extra", actualType: row.type });
     }
   }
+  const relationBranches = seed.branches.filter((b) => b.type === "relation" && b.targetSeed);
+  if (relationBranches.length > 0) {
+    let fkList = [];
+    let indexList = [];
+    try {
+      fkList = queryD1(`PRAGMA foreign_key_list(${tableName})`, options);
+      indexList = queryD1(`PRAGMA index_list(${tableName})`, options);
+    } catch {
+    }
+    const fkByCol = /* @__PURE__ */ new Map();
+    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}`;
+      const colDiff = columns.find((c) => c.name === branch.alias);
+      if (!colDiff || colDiff.status === "missing") continue;
+      const fk = fkByCol.get(branch.alias);
+      if (!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 = `\u2192 ${expectedFkTable}(id) ON DELETE ${expectedOnDelete}`;
+          colDiff.actual = `\u2192 ${actualTable}(id) ON DELETE ${actualOnDelete}`;
+          colDiff.expectedTarget = branch.targetSeed;
+        }
+      }
+      if (!indexNames.has(expectedIndexName)) {
+        if (colDiff.status === "ok") {
+          colDiff.status = "index_missing";
+        } else {
+          columns.push({ name: branch.alias, status: "index_missing" });
+        }
+      }
+    }
+  }
   return { slug: seed.slug, tableExists: true, columns };
 }
 
 // src/commands/validate.ts
 import pc from "picocolors";
-import { SEED_REGISTRY } from "@beechcms/core";
+import { SEED_REGISTRY, validateSeedDefinitions } from "@beechcms/core";
 function validateSeeds(registry) {
-  const result = [];
-  const slugsSeen = /* @__PURE__ */ new Set();
-  for (const seed of Object.values(registry)) {
-    const messages = [];
-    if (slugsSeen.has(seed.slug)) {
-      messages.push(`duplicate slug "${seed.slug}" \u2014 each seed must have a unique slug`);
-    }
-    slugsSeen.add(seed.slug);
-    const aliasesSeen = /* @__PURE__ */ new Set();
-    for (const branch of seed.branches) {
-      if (aliasesSeen.has(branch.alias)) {
-        messages.push(`duplicate branch alias "${branch.alias}"`);
-      }
-      aliasesSeen.add(branch.alias);
-    }
-    const allAliases = new Set(seed.branches.map((b) => b.alias));
-    if (!allAliases.has(seed.displayNameAlias)) {
-      messages.push(`displayNameAlias "${seed.displayNameAlias}" not found in branches`);
-    }
-    if (messages.length > 0) {
-      result.push({ slug: seed.slug, messages });
-    }
-  }
-  return result;
+  return validateSeedDefinitions(Object.values(registry));
 }
 async function validate(args) {
   const registry = args.registry ?? SEED_REGISTRY;
@@ -161,32 +198,57 @@ async function validate(args) {
   }
   console.log(pc.cyan("\n  beech validate \u2014 checking seeds\n"));
   const errors = validateSeeds(registry);
-  const errorMap = new Map(errors.map((e) => [e.slug, e.messages]));
-  let totalIssues = 0;
+  const fatalErrors = errors.filter((e) => e.fatal);
+  const warnings = errors.filter((e) => !e.fatal);
+  for (const e of fatalErrors) {
+    console.log(pc.red(`  \u2717 ${e.slug} (fatal)`));
+    for (const msg of e.messages) {
+      console.log(pc.red(`      \u2192 ${msg}`));
+    }
+  }
+  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 = errorMap.get(seed.slug);
+    const msgs = warningMap.get(seed.slug);
     if (!msgs) {
-      console.log(pc.green(`  \u2713 ${seed.slug}`));
+      if (!allWarningSlugsSeen.has(seed.slug)) {
+        const hasFatal = fatalErrors.some((e) => e.slug === seed.slug);
+        if (!hasFatal) console.log(pc.green(`  \u2713 ${seed.slug}`));
+      }
     } else {
-      totalIssues += msgs.length;
-      console.log(pc.red(`  \u2717 ${seed.slug}`));
+      console.log(pc.yellow(`  \u26A0 ${seed.slug}`));
       for (const msg of msgs) {
-        console.log(pc.red(`      \u2192 ${msg}`));
+        console.log(pc.yellow(`      \u2192 ${msg}`));
       }
     }
   }
   console.log("");
-  if (totalIssues > 0) {
-    const s = totalIssues !== 1 ? "s" : "";
-    console.log(pc.red(`  Found ${totalIssues} issue${s}. Fix the seeds above before loading.
+  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.
 `));
     process.exit(1);
+  } else if (totalWarnings > 0) {
+    const s = totalWarnings !== 1 ? "s" : "";
+    console.log(pc.yellow(`  Found ${totalWarnings} warning${s}. Review seeds above.
+`));
   } else {
     console.log(pc.green("  All seeds valid.\n"));
   }
 }
 
 // src/commands/seed-load.ts
+function buildSeedRegistrationSql(seed) {
+  const json = sqlQuote(JSON.stringify(seed));
+  return [
+    `INSERT INTO seeds (slug, definition, status, source, created_at, updated_at)`,
+    `VALUES (${sqlQuote(seed.slug)}, ${json}, 'active', 'code', unixepoch(), unixepoch())`,
+    `ON CONFLICT(slug) DO UPDATE SET definition = excluded.definition, status = 'active', updated_at = excluded.updated_at;`
+  ].join("\n");
+}
+var SEED_META_BUMP_SQL = `UPDATE seed_meta SET value = CAST(CAST(value AS INTEGER) + 1 AS TEXT) WHERE id = 'registry_version';`;
 function buildStatements(seed) {
   const stmts = [generateCreateTable(seed), ...generateIndexes(seed)];
   const draft = generateDraftTable(seed);
@@ -195,10 +257,16 @@ function buildStatements(seed) {
   if (fts) {
     stmts.push(fts, ...generateFtsTriggers(seed));
   }
+  for (const branch of seed.branches) {
+    if (branch.type !== "relation" || branch.multiple !== true) continue;
+    stmts.push(generateJunctionTable(seed, branch), ...generateJunctionIndexes(seed, branch));
+    const draftJunction = generateJunctionDraftTable(seed, branch);
+    if (draftJunction) stmts.push(draftJunction);
+  }
   return stmts;
 }
 async function runDiff(options, registry) {
-  const seeds = Object.values(registry);
+  const seeds = sortSeedsByDependencies(Object.values(registry));
   console.log(pc2.cyan("\n  Diffing schema\u2026\n"));
   let allOk = true;
   for (const seed of seeds) {
@@ -223,6 +291,12 @@ async function runDiff(options, registry) {
         console.log(pc2.dim(`    ~ orphaned column: "${col.name}" (${col.actualType}) \u2014 exists in DB but not in seeds.ts`));
       } else if (col.status === "type_mismatch") {
         console.log(pc2.red(`    \u2260 type mismatch:  ${col.name} (expected ${col.expectedType}, got ${col.actualType})`));
+      } else if (col.status === "fk_missing") {
+        console.log(pc2.red(`    \u292C missing FK: ${col.name} \u2192 content_${col.expectedTarget}(id)`));
+      } else if (col.status === "fk_mismatch") {
+        console.log(pc2.yellow(`    \u292C FK mismatch: ${col.name} expected ${col.expected}, got ${col.actual}`));
+      } else if (col.status === "index_missing") {
+        console.log(pc2.yellow(`    \u2298 missing index on ${col.name}`));
       }
     }
   }
@@ -234,7 +308,7 @@ async function runDiff(options, registry) {
   }
 }
 async function runLoad(options, dryRun, registry) {
-  const seeds = Object.values(registry);
+  const seeds = sortSeedsByDependencies(Object.values(registry));
   if (dryRun) {
     console.log(pc2.cyan("\n  -- dry-run: SQL that would be executed\n"));
     for (const seed of seeds) {
@@ -243,14 +317,18 @@ async function runLoad(options, dryRun, registry) {
       for (const stmt of stmts) {
         console.log(stmt + "\n");
       }
+      console.log(pc2.dim(`  -- register ${seed.slug} in seeds table`));
+      console.log(buildSeedRegistrationSql(seed) + "\n");
     }
+    console.log(pc2.dim("  -- bump registry_version"));
+    console.log(SEED_META_BUMP_SQL + "\n");
     return;
   }
   console.log(pc2.cyan(`
   Loading seeds into ${options.local ? "local" : "remote"} D1 (${options.db})\u2026
 `));
   for (const seed of seeds) {
-    const stmts = buildStatements(seed);
+    const stmts = [...buildStatements(seed), buildSeedRegistrationSql(seed)];
     const sql = stmts.join("\n\n") + "\n";
     process.stdout.write(`  ${pc2.dim("\u2192")} content_${seed.slug}\u2026 `);
     const ok = executeD1File(sql, options);
@@ -274,7 +352,10 @@ async function runLoad(options, dryRun, registry) {
     }
     console.log(pc2.green("done"));
   }
+  executeD1File(SEED_META_BUMP_SQL, options);
   console.log(pc2.green("\n  All seeds loaded.\n"));
+  console.log(pc2.dim("  Definitions registered in the database."));
+  console.log(pc2.dim("  seed.ts is no longer required at runtime \u2014 you may keep it for code-first edits or delete it.\n"));
 }
 async function seedLoad(args) {
   const registry = args.registry ?? SEED_REGISTRY2;
@@ -285,8 +366,25 @@ async function seedLoad(args) {
     return;
   }
   const validationErrors = validateSeeds(registry);
-  if (validationErrors.length > 0) {
-    const total = validationErrors.reduce((n, e) => n + e.messages.length, 0);
+  const fatalErrors = validationErrors.filter((e) => e.fatal);
+  const warnings = validationErrors.filter((e) => !e.fatal);
+  if (fatalErrors.length > 0) {
+    const total = fatalErrors.reduce((n, e) => n + e.messages.length, 0);
+    const s = total !== 1 ? "s" : "";
+    console.log(pc2.red(`
+  \u2717 Seed validation found ${total} fatal error${s}. Cannot load schema.
+`));
+    for (const e of fatalErrors) {
+      console.log(pc2.red(`  \u2717 ${e.slug}`));
+      for (const msg of e.messages) {
+        console.log(pc2.red(`      \u2192 ${msg}`));
+      }
+    }
+    console.log("");
+    process.exit(1);
+  }
+  if (warnings.length > 0) {
+    const total = warnings.reduce((n, e) => n + e.messages.length, 0);
     const s = total !== 1 ? "s" : "";
     console.log(pc2.yellow(`
   \u26A0 Seed validation found ${total} issue${s}. Schema changes will still be applied.
@@ -300,6 +398,27 @@ async function seedLoad(args) {
     local: args.local,
     configPath
   };
+  if (!args.dryRun && !args.diff) {
+    try {
+      const rows = queryD1(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name IN ('seeds','seed_meta')`,
+        options
+      );
+      if (rows.length < 2) {
+        console.log(pc2.red("\n  \u2717 System tables not found (seeds, seed_meta)\n"));
+        console.log(pc2.dim("  Run `beech init --db` first to initialise the database."));
+        const flag = args.local ? " --local" : "";
+        console.log(pc2.cyan(`
+  \u2192 Run: npx beech init --db${flag}
+`));
+        process.exit(1);
+      }
+    } catch {
+      console.log(pc2.red("\n  \u2717 Could not query the database\n"));
+      console.log(pc2.dim("  Run `beech init --db` first to initialise the database."));
+      process.exit(1);
+    }
+  }
   if (args.diff) {
     await runDiff(options, registry);
   } else {
@@ -324,7 +443,10 @@ var SYSTEM_TABLES = [
   "notifications",
   "media_objects",
   "content_event_log",
-  "automations"
+  "automations",
+  "seeds",
+  "seed_meta",
+  "site_settings"
 ];
 var BASE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS users (
@@ -462,6 +584,31 @@ CREATE TABLE IF NOT EXISTS automations (
 
 CREATE INDEX IF NOT EXISTS idx_automations_seed_slug ON automations(seed_slug);
 CREATE INDEX IF NOT EXISTS idx_automations_enabled   ON automations(enabled);
+
+CREATE TABLE IF NOT EXISTS seeds (
+    slug        TEXT    NOT NULL PRIMARY KEY,
+    definition  TEXT    NOT NULL,
+    status      TEXT    NOT NULL DEFAULT 'active'
+                        CHECK (status IN ('active', 'deleted')),
+    source      TEXT    NOT NULL DEFAULT 'runtime'
+                        CHECK (source IN ('code', 'runtime')),
+    created_at  INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at  INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE INDEX IF NOT EXISTS idx_seeds_status ON seeds(status);
+
+CREATE TABLE IF NOT EXISTS seed_meta (
+    id      TEXT NOT NULL PRIMARY KEY,
+    value   TEXT NOT NULL
+);
+
+INSERT OR IGNORE INTO seed_meta (id, value) VALUES ('registry_version', '1');
+
+CREATE TABLE IF NOT EXISTS site_settings (
+    key   TEXT NOT NULL PRIMARY KEY,
+    value TEXT NOT NULL
+);
 `.trim();
 var PLACEHOLDER_DB_IDS = [
   "INCOLLA_QUI_IL_TUO_ID_D1",
@@ -601,7 +748,7 @@ function checkFiles(cwd, checkDevVars) {
   }
   const seedsExists = existsSync2(resolve2(cwd, "seeds.ts")) || existsSync2(resolve2(cwd, "seeds.js")) || existsSync2(resolve2(cwd, "seed.ts")) || existsSync2(resolve2(cwd, "seed.js"));
   if (!seedsExists) {
-    console.log(pc3.yellow("  \u26A0 seeds.ts         \u2014 missing (create it, then run beech seed:load)"));
+    console.log(pc3.yellow("  \u26A0 seeds.ts         \u2014 not found (optional: needed only for the one-time code \u2192 DB load; after `beech seed:load`, the DB is canonical)"));
   } else {
     console.log(pc3.green("  \u2713 seeds.ts"));
   }
@@ -618,7 +765,7 @@ function printNextSteps(local) {
   const localFlag = local ? " --local" : "";
   console.log(pc3.dim("  Next steps:"));
   console.log(pc3.cyan(`  1. npx beech seed:load${localFlag}`));
-  console.log(pc3.dim("      \u2192 create content tables from seeds.ts"));
+  console.log(pc3.dim("      \u2192 create content tables and register seed definitions in D1"));
   console.log(pc3.cyan("  2. npx wrangler dev"));
   console.log(pc3.dim("      \u2192 start API + dashboard"));
   console.log(pc3.dim("  3. Open http://localhost:8789/admin\n"));
@@ -663,7 +810,7 @@ async function init(args) {
       for (const issue of placeholders) {
         console.log(pc3.yellow(`    - ${issue}`));
       }
-      if (process.stdin.isTTY) {
+      if (process.stdin.isTTY && !args.nonInteractive) {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
         let autoCreate = false;
         try {
@@ -721,7 +868,14 @@ async function init(args) {
           printManualDbInstructions();
           process.exit(1);
         }
+      } else if (args.nonInteractive && args.local) {
+        console.log(pc3.dim("  --yes: proceeding with local mode (no remote resources needed)\n"));
       } else {
+        if (args.nonInteractive) {
+          console.log(pc3.red("\n  \u2717 Cannot proceed non-interactively: remote database has a placeholder database_id\n"));
+          console.log(pc3.dim("  Set a real database_id in wrangler.jsonc, then retry."));
+          process.exit(1);
+        }
         printManualDbInstructions();
         process.exit(1);
       }
@@ -1039,50 +1193,65 @@ async function deploy(args) {
   }
 }
 
-// src/commands/update.ts
+// src/commands/onboard.ts
 import pc6 from "picocolors";
+async function onboard(args) {
+  console.log(pc6.cyan("\n  beech onboard \u2014 full provisioning\n"));
+  await init({ initDb: true, local: args.local, db: args.db, nonInteractive: args.yes });
+  await seedLoad({ dryRun: false, diff: false, local: args.local, db: args.db, registry: args.registry ?? null });
+  console.log(pc6.cyan("\n  Provisioning complete.\n"));
+  console.log(pc6.dim("  Next steps:"));
+  console.log(pc6.cyan("  1. npx wrangler dev"));
+  console.log(pc6.dim("      \u2192 start API + dashboard"));
+  console.log(pc6.dim("  2. Open http://localhost:8789/admin"));
+  console.log(pc6.dim("      \u2192 complete setup wizard to create admin user\n"));
+}
+
+// src/commands/update.ts
+import pc7 from "picocolors";
 import { spawnSync as spawnSync4 } from "node:child_process";
 async function update(_args) {
-  console.log(pc6.cyan("\n  beech update\n"));
-  console.log(pc6.dim("  [1/2] Installing latest BeechCMS packages\u2026\n"));
+  console.log(pc7.cyan("\n  beech update\n"));
+  console.log(pc7.dim("  [1/2] Installing latest BeechCMS packages\u2026\n"));
   const installResult = spawnSync4(
     "npm",
     ["install", "@beechcms/api@latest", "@beechcms/core@latest"],
     { stdio: "inherit", cwd: process.cwd(), shell: true }
   );
   if (installResult.status !== 0) {
-    console.log(pc6.red("\n  \u2717 npm install failed\n"));
-    console.log(pc6.dim("  Check the output above for details."));
-    console.log(pc6.dim("  You may need to resolve version conflicts manually."));
-    console.log(pc6.cyan("\n  \u2192 Try: npm install --legacy-peer-deps\n"));
+    console.log(pc7.red("\n  \u2717 npm install failed\n"));
+    console.log(pc7.dim("  Check the output above for details."));
+    console.log(pc7.dim("  You may need to resolve version conflicts manually."));
+    console.log(pc7.cyan("\n  \u2192 Try: npm install --legacy-peer-deps\n"));
     process.exit(1);
   }
-  console.log(pc6.green("\n  \u2713 Packages updated"));
-  console.log(pc6.dim("\n  [2/2] Applying system migrations to local database\u2026\n"));
+  console.log(pc7.green("\n  \u2713 Packages updated"));
+  console.log(pc7.dim("\n  [2/2] Applying system migrations to local database\u2026\n"));
   const initResult = spawnSync4(
     "npx",
     ["beech", "init", "--db", "--local"],
     { stdio: "inherit", cwd: process.cwd(), shell: true }
   );
   if (initResult.status !== 0) {
-    console.log(pc6.yellow("\n  \u26A0 Local DB update failed\n"));
-    console.log(pc6.dim("  Apply system migrations manually:"));
-    console.log(pc6.cyan("  \u2192 Run: npx beech init --db --local\n"));
+    console.log(pc7.yellow("\n  \u26A0 Local DB update failed\n"));
+    console.log(pc7.dim("  Apply system migrations manually:"));
+    console.log(pc7.cyan("  \u2192 Run: npx beech init --db --local\n"));
   } else {
-    console.log(pc6.green("\n  \u2713 Local database updated"));
+    console.log(pc7.green("\n  \u2713 Local database updated"));
   }
-  console.log(pc6.dim("\n  Local update complete.\n"));
-  console.log(pc6.dim("  Next steps:"));
-  console.log(pc6.cyan("  1. npx beech seed:load --local"));
-  console.log(pc6.dim("      \u2192 sync content schema to local DB"));
-  console.log(pc6.cyan("  2. npm run deploy"));
-  console.log(pc6.dim("      \u2192 deploy updated API + dashboard"));
-  console.log(pc6.cyan("  3. npx beech seed:load"));
-  console.log(pc6.dim("      \u2192 sync remote schema\n"));
+  console.log(pc7.dim("\n  Local update complete.\n"));
+  console.log(pc7.dim("  Next steps:"));
+  console.log(pc7.cyan("  1. npx beech seed:load --local"));
+  console.log(pc7.dim("      \u2192 sync content schema to local DB"));
+  console.log(pc7.cyan("  2. npm run deploy"));
+  console.log(pc7.dim("      \u2192 deploy updated API + dashboard"));
+  console.log(pc7.cyan("  3. npx beech seed:load"));
+  console.log(pc7.dim("      \u2192 sync remote schema\n"));
 }
 export {
   deploy,
   init,
+  onboard,
   seedCreate,
   seedLoad,
   update,

package/dist/lib/schema-diff.d.ts

@@ -0,0 +1,15 @@
+import type { Seed } from '@beech/core';
+import type { WranglerOptions } from './wrangler.js';
+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 declare function diffSeed(seed: Seed, options: WranglerOptions): Promise<SeedDiff>;
+//# sourceMappingURL=schema-diff.d.ts.map

package/dist/lib/schema-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-diff.d.ts","sourceRoot":"","sources":["../../src/lib/schema-diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAS,MAAM,eAAe,CAAA;AAU3D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,eAAe,CAAA;IACpD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,OAAO,CAAA;IACpB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsCtF"}

package/dist/lib/schema-diff.js

@@ -0,0 +1,37 @@
+import { getExpectedColumns } from '@beech/core';
+import { queryD1 } from './wrangler.js';
+export async function diffSeed(seed, options) {
+    const tableName = `content_${seed.slug}`;
+    const expected = getExpectedColumns(seed);
+    let actual;
+    try {
+        actual = queryD1(`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(actual.map(r => [r.name, r]));
+    const expectedSet = new Set(expected.map(c => c.name));
+    const columns = [];
+    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/dist/lib/wrangler.d.ts

@@ -0,0 +1,17 @@
+export interface WranglerOptions {
+    db: string;
+    local: boolean;
+    configPath: string | null;
+}
+export interface D1Row {
+    [key: string]: unknown;
+}
+/** Esegue SQL da file temporaneo via `wrangler d1 execute --file`. */
+export declare function executeD1File(sql: string, options: WranglerOptions): void;
+/** Esegue una query SQL e ritorna i risultati come array di oggetti (--json). */
+export declare function queryD1<T extends D1Row = D1Row>(sql: string, options: WranglerOptions): T[];
+/** Trova il path di wrangler.jsonc in apps/api/ relativo a cwd. */
+export declare function findWranglerConfig(): string | null;
+/** Risolve il nome del database D1 da wrangler.jsonc (grepping 'database_name'). */
+export declare function resolveDbName(configPath: string | null): string;
+//# sourceMappingURL=wrangler.d.ts.map

package/dist/lib/wrangler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrangler.d.ts","sourceRoot":"","sources":["../../src/lib/wrangler.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,OAAO,CAAA;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAgBD,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAYzE;AAED,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,CAAC,EAAE,CAc3F;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAGlD;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAS/D"}

package/dist/lib/wrangler.js

@@ -0,0 +1,65 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+function buildArgs(options) {
+    const args = [];
+    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, options) {
+    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() });
+        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(sql, options) {
+    const args = ['d1', 'execute', options.db, '--command', sql, '--json', ...buildArgs(options)];
+    const result = spawnSync('npx', ['wrangler', ...args], { encoding: 'utf-8', cwd: process.cwd() });
+    if (result.status !== 0) {
+        throw new Error(`wrangler d1 execute failed:\n${result.stderr}`);
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        return (parsed[0]?.results ?? []);
+    }
+    catch {
+        throw new Error(`Failed to parse wrangler JSON output:\n${result.stdout}`);
+    }
+}
+/** Trova il path di wrangler.jsonc in apps/api/ relativo a cwd. */
+export function findWranglerConfig() {
+    const candidate = resolve(process.cwd(), 'apps', 'api', 'wrangler.jsonc');
+    return existsSync(candidate) ? candidate : null;
+}
+/** Risolve il nome del database D1 da wrangler.jsonc (grepping 'database_name'). */
+export function resolveDbName(configPath) {
+    if (!configPath)
+        return 'beech-db';
+    try {
+        const content = execSync(`cat "${configPath}"`, { encoding: 'utf-8' });
+        const match = content.match(/"database_name"\s*:\s*"([^"]+)"/);
+        return match?.[1] ?? 'beech-db';
+    }
+    catch {
+        return 'beech-db';
+    }
+}