@batadata/cli 0.2.10 → 0.2.12

package/dist/commands/import.d.ts

@@ -136,7 +136,18 @@ export declare function missingExtensions(sourceExts: string[], targetHasExts: s
  *    compute_ctl records applied internal SQL migrations here (table
  *    `neon_migration.migration_id`) on EVERY compute startup. Real Neon hides this
  *    schema from customer `pg_tables`; our compute exposes it, so ANY object under
- *    `neon_migration.*` is platform furniture, never user data.
+ *    `neon_migration.*` is platform furniture, never user data. Same story for
+ *    `neon` — compute_ctl seeds it with engine helper functions on every startup,
+ *    so a BataDB source's dump would carry `CREATE SCHEMA neon` straight into the
+ *    identical schema every target is provisioned with.
+ *
+ * Named objects are treated differently from whole schemas. A source
+ * `public.health_check` is still dumped and verified as real data (colliding
+ * loudly on the target rather than being silently dropped). Scaffolding SCHEMAS,
+ * by contrast, are engine furniture on the source too whenever they exist, so
+ * they are excluded from the dump itself (pg_dump --exclude-schema) and from
+ * source-side verify accounting — the target's own engine already maintains its
+ * copies, and restoring them is guaranteed to fail with "already exists".
  */
 export declare const PLATFORM_SCAFFOLDING_TABLES: string[];
 export declare const PLATFORM_SCAFFOLDING_SEQUENCES: string[];

package/dist/commands/import.js

@@ -273,12 +273,23 @@ export function missingExtensions(sourceExts, targetHasExts) {
  *    compute_ctl records applied internal SQL migrations here (table
  *    `neon_migration.migration_id`) on EVERY compute startup. Real Neon hides this
  *    schema from customer `pg_tables`; our compute exposes it, so ANY object under
- *    `neon_migration.*` is platform furniture, never user data.
+ *    `neon_migration.*` is platform furniture, never user data. Same story for
+ *    `neon` — compute_ctl seeds it with engine helper functions on every startup,
+ *    so a BataDB source's dump would carry `CREATE SCHEMA neon` straight into the
+ *    identical schema every target is provisioned with.
+ *
+ * Named objects are treated differently from whole schemas. A source
+ * `public.health_check` is still dumped and verified as real data (colliding
+ * loudly on the target rather than being silently dropped). Scaffolding SCHEMAS,
+ * by contrast, are engine furniture on the source too whenever they exist, so
+ * they are excluded from the dump itself (pg_dump --exclude-schema) and from
+ * source-side verify accounting — the target's own engine already maintains its
+ * copies, and restoring them is guaranteed to fail with "already exists".
  */
 export const PLATFORM_SCAFFOLDING_TABLES = ["public.health_check"];
 export const PLATFORM_SCAFFOLDING_SEQUENCES = ["public.health_check_id_seq"];
 /** Schemas whose ENTIRE contents are platform furniture (any `<schema>.*` object). */
-export const PLATFORM_SCAFFOLDING_SCHEMAS = ["neon_migration"];
+export const PLATFORM_SCAFFOLDING_SCHEMAS = ["neon_migration", "neon"];
 let PLATFORM_SCAFFOLDING_NAMES = new Set([
     ...PLATFORM_SCAFFOLDING_TABLES,
     ...PLATFORM_SCAFFOLDING_SEQUENCES,
@@ -432,7 +443,11 @@ function runMigration(sourceUri, targetUri) {
         // data corruption that row-count verify wouldn't catch. Forcing UTF8 makes the
         // server convert, guaranteeing a valid-UTF-8 stream; the dump carries
         // `SET client_encoding = 'UTF8';`, which restores correctly into any target.
-        const dump = spawn("pg_dump", [sourceUri, "--no-owner", "--no-privileges", "--encoding=UTF8"], {
+        // Scaffolding SCHEMAS are excluded at the dump: every target is provisioned
+        // with its own copies, so restoring them can only fail ("already exists").
+        // Read at call time — applyServerScaffolding() may have extended the list.
+        const excludeArgs = PLATFORM_SCAFFOLDING_SCHEMAS.flatMap((s) => ["--exclude-schema", s]);
+        const dump = spawn("pg_dump", [sourceUri, "--no-owner", "--no-privileges", "--encoding=UTF8", ...excludeArgs], {
             stdio: ["ignore", "pipe", "pipe"],
             env,
         });
@@ -833,10 +848,20 @@ export async function importDb(args) {
     const sourceScaffoldingHits = srcCollisionRes.code === 0
         ? scaffoldingCollisions(srcCollisionRes.stdout.split("\n").map((s) => s.trim()).filter(Boolean))
         : [];
-    if (sourceScaffoldingHits.length > 0 && !jsonMode) {
-        warn(`Source contains ${sourceScaffoldingHits.join(", ")}, which shares a name with BataDB's seeded ` +
-            'platform scaffolding on the target. The restore will likely fail with "relation already ' +
-            'exists" — rename or exclude it on the source to migrate cleanly.');
+    // Schema-level hits are engine furniture and are EXCLUDED from the dump
+    // outright (see runMigration); only named-object collisions still restore
+    // into a clash on the target.
+    const schemaHits = sourceScaffoldingHits.filter((n) => PLATFORM_SCAFFOLDING_SCHEMAS.some((s) => n.startsWith(`${s}.`)));
+    const namedHits = sourceScaffoldingHits.filter((n) => !schemaHits.includes(n));
+    if (schemaHits.length > 0 && !jsonMode) {
+        warn(`Source contains engine-internal object(s) ${schemaHits.join(", ")} — platform furniture the ` +
+            "target maintains itself. They are skipped by the migration (not customer data).");
+    }
+    if (namedHits.length > 0 && !jsonMode) {
+        warn(`Source contains ${namedHits.join(", ")}, which shares a name with BataDB's seeded ` +
+            "platform scaffolding. On a freshly created target the seeded copy is dropped so the " +
+            "source's version restores as real data; importing into an existing --project target " +
+            'will likely fail with "relation already exists".');
     }
     // ── Phase 2: check pg_dump AND psql are new enough ──────────────────────────
     // BOTH matter: pg_dump can't dump a newer server than itself, and psql must be
@@ -1048,6 +1073,27 @@ export async function importDb(args) {
     const strandedHintJson = "The target project was left in place (NOT deleted) for diagnosis/retry — re-run with " +
         `--project ${targetProjectId} --yes after fixing` +
         (created ? `, or remove it with: bata projects delete ${targetProjectId} --yes.` : ".");
+    // A freshly CREATED target's named scaffolding (public.health_check + its
+    // sequence) is disposable furniture — but the SOURCE may carry same-named
+    // tables (always true migrating FROM another BataDB, where provisioning
+    // seeded them too). Doctrine says source objects are real data and must
+    // restore + verify normally, so drop the target's seeded copies first;
+    // otherwise the restore is GUARANTEED to die on "already exists". Never
+    // touched on a --project target (created === false): its objects may be the
+    // user's own data, and the old collide-loudly behavior stays.
+    if (created && namedHits.length > 0) {
+        phase("Dropping seeded scaffolding the source will re-create");
+        for (const qn of namedHits) {
+            const dot = qn.indexOf(".");
+            const dropSql = `DROP TABLE IF EXISTS ${quoteIdent(qn.slice(0, dot))}.${quoteIdent(qn.slice(dot + 1))} CASCADE`;
+            const dropRes = runPsql(targetUri, dropSql);
+            if (dropRes.code !== 0) {
+                emitError("RESTORE_FAILED", `Could not clear the target's seeded ${qn} before restore.`, `The source has its own ${qn}, which cannot restore over the target's seeded copy. ` +
+                    strandedHintJson, 1);
+                return;
+            }
+        }
+    }
     // ── Phase 4: migrate ───────────────────────────────────────────────────────
     phase("Migrating schema + data (pg_dump | psql)");
     const migration = await runMigration(source, targetUri);
@@ -1083,7 +1129,11 @@ export async function importDb(args) {
         "FROM pg_tables WHERE schemaname NOT IN ('pg_catalog','information_schema')");
     if (tableListRes.code !== 0)
         verifyFailed = "could not list source tables";
-    const sourceTables = tableListRes.code === 0 ? safeJsonArray(tableListRes.stdout) : [];
+    // Scaffolding-SCHEMA tables were deliberately excluded from the dump (the
+    // target engine maintains its own copies), so they must not be counted on the
+    // source side either — they'd read as "missing on target" mismatches. Named
+    // scaffolding objects (public.health_check) stay in: they ARE dumped.
+    const sourceTables = (tableListRes.code === 0 ? safeJsonArray(tableListRes.stdout) : []).filter((t) => !PLATFORM_SCAFFOLDING_SCHEMAS.includes(t.schema));
     const srcCounts = new Map();
     const tgtCounts = new Map();
     if (!verifyFailed && sourceTables.length > 0) {
@@ -1125,8 +1175,13 @@ export async function importDb(args) {
             verifyFailed = "sequence query failed";
         }
         else {
-            for (const [k, v] of parseKvRows(sSeqRes.stdout))
-                srcSeq.set(k, v);
+            // Mirror the table filter: source sequences inside scaffolding schemas
+            // were never dumped, so they can't be expected on the target.
+            for (const [k, v] of parseKvRows(sSeqRes.stdout)) {
+                const schema = k.slice(0, k.indexOf("."));
+                if (!PLATFORM_SCAFFOLDING_SCHEMAS.includes(schema))
+                    srcSeq.set(k, v);
+            }
             for (const [k, v] of parseKvRows(tSeqRes.stdout))
                 tgtSeq.set(k, v);
         }

package/dist/commands/projects.d.ts

@@ -20,6 +20,7 @@ export declare function list(): Promise<void>;
 export declare function parseCreateComputeArgs(args: string[]): {
     tier: ComputeTier;
     sizeCu: number;
+    placement?: "fly" | "density";
 } | {
     error: string;
 };

package/dist/commands/projects.js

@@ -108,18 +108,21 @@ export async function list() {
 export function parseCreateComputeArgs(args) {
     let tierRaw;
     let sizeRaw;
+    let placementRaw;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        if (arg === "--tier" || arg === "--size") {
+        if (arg === "--tier" || arg === "--size" || arg === "--placement") {
             // The spaced form needs a value: reject a missing one (end of args, or
             // the next token is another flag) instead of silently using the default.
             const next = args[i + 1];
             if (next === undefined || next.startsWith("-")) {
-                const usage = arg === "--tier" ? "serverless|always-on" : "1|2|4|8|16|32|64|128";
+                const usage = arg === "--tier" ? "serverless|always-on" : arg === "--placement" ? "fly|density" : "1|2|4|8|16|32|64|128";
                 return { error: `${arg} requires a value (${usage}).` };
             }
             if (arg === "--tier")
                 tierRaw = next;
+            else if (arg === "--placement")
+                placementRaw = next;
             else
                 sizeRaw = next;
             i++;
@@ -128,6 +131,8 @@ export function parseCreateComputeArgs(args) {
             tierRaw = arg.slice("--tier=".length);
         else if (arg.startsWith("--size="))
             sizeRaw = arg.slice("--size=".length);
+        else if (arg.startsWith("--placement="))
+            placementRaw = arg.slice("--placement=".length);
     }
     let tier = "serverless";
     if (tierRaw !== undefined) {
@@ -158,7 +163,19 @@ export function parseCreateComputeArgs(args) {
         }
         sizeCu = parsed;
     }
-    return { tier, sizeCu };
+    let placement;
+    if (placementRaw !== undefined) {
+        const normalized = placementRaw.toLowerCase();
+        if (normalized === "fly" || normalized === "density")
+            placement = normalized;
+        else
+            return { error: `Invalid --placement "${placementRaw}". Use "fly" or "density".` };
+        // Placement pins a SERVERLESS compute's provider; always-on is Fly always.
+        if (tier === "always_on") {
+            return { error: `--placement applies to serverless projects only (always-on runs on Fly).` };
+        }
+    }
+    return { tier, sizeCu, ...(placement ? { placement } : {}) };
 }
 /** `--flag <value>` / `--flag=<value>` reader. Distinguishes "absent"
  * (undefined) from "present but missing its value" ({ error }) so a headless
@@ -275,6 +292,7 @@ export async function create(args = []) {
             // One friendly step: the compute is born on the chosen tier + size (no
             // follow-up `bata compute set` needed). Defaults to serverless / 1 CU.
             compute: { tier: compute.tier, size_cu: compute.sizeCu },
+            ...(compute.placement ? { placement: compute.placement } : {}),
         };
     if (teamId) {
         body.team_id = teamId;

package/dist/index.js

@@ -51,7 +51,7 @@ function help() {
     log(`  ${colors.bold("Projects")}`);
     log(`    ${colors.cyan("projects")}           List all projects`);
     log(`    ${colors.cyan("projects list")}      Alias for status`);
-    log(`    ${colors.cyan("projects create")}    Create a new project ${colors.dim("(--tier serverless|always-on, --size 1|2|4|8|16|32|64|128)")}`);
+    log(`    ${colors.cyan("projects create")}    Create a new project ${colors.dim("(--tier serverless|always-on, --size 1|2|4|8|16|32|64|128, --placement fly|density)")}`);
     log(`    ${colors.cyan("projects info")}      Show project details`);
     log(`    ${colors.cyan("projects delete")}    Delete a project`);
     log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batadata/cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"