@batadata/cli 0.2.0 → 0.2.1

package/dist/commands/import.d.ts

@@ -1,7 +1,7 @@
 /**
  * bata import — Neon (or any Postgres) → BataDB migration.
  *
- *   bata import --source <postgres-uri> [--project <id> | --name <name>] [--yes] [--json]
+ *   bata import --source <postgres-uri> [--project <id> | --name <name>] [--pg <major>] [--yes] [--json]
  *
  * Agent-native: shells out to the standard `pg_dump` / `psql` client tools
  * (zero runtime deps) and streams a dump straight into a fresh BataDB project.
@@ -142,6 +142,21 @@ export declare const PLATFORM_SCAFFOLDING_TABLES: string[];
 export declare const PLATFORM_SCAFFOLDING_SEQUENCES: string[];
 /** Schemas whose ENTIRE contents are platform furniture (any `<schema>.*` object). */
 export declare const PLATFORM_SCAFFOLDING_SCHEMAS: string[];
+/**
+ * Merge the server-published scaffolding list (GET /v1/platform/import-scaffolding)
+ * into the baked-in defaults above. The server is the source of truth going
+ * forward — if provisioning grows new furniture, an already-installed CLI keeps
+ * verifying correctly instead of false-failing on it. Union (never replace): the
+ * baked defaults still apply against an older control plane, and a partial or
+ * malformed server response can only ever ADD exclusions it explicitly names.
+ * The exported const arrays are extended in place so every existing reference
+ * (the --yes guard, the created-target check, verify) sees the merged lists.
+ */
+export declare function applyServerScaffolding(server: {
+    tables?: unknown;
+    sequences?: unknown;
+    schemas?: unknown;
+}): void;
 /** Is this qualified name one of BataDB's seeded platform-scaffolding objects —
  *  either an exact named object, or anything inside a scaffolding schema? */
 export declare function isPlatformScaffolding(qualifiedName: string): boolean;
@@ -171,8 +186,12 @@ export declare function parseImportArgs(args: string[]): {
     source?: string;
     projectId?: string;
     name?: string;
+    pg?: string;
     help: boolean;
 } | {
     error: string;
 };
+/** Default target major for a new project: match the source so features survive,
+ *  capped at what BataDB ships (a PG18 source → 17, a PG16 or older source → 16). */
+export declare function defaultTargetPg(sourceMajor: number): string;
 export declare function importDb(args: string[]): Promise<void>;

package/dist/commands/import.js

@@ -1,7 +1,7 @@
 /**
  * bata import — Neon (or any Postgres) → BataDB migration.
  *
- *   bata import --source <postgres-uri> [--project <id> | --name <name>] [--yes] [--json]
+ *   bata import --source <postgres-uri> [--project <id> | --name <name>] [--pg <major>] [--yes] [--json]
  *
  * Agent-native: shells out to the standard `pg_dump` / `psql` client tools
  * (zero runtime deps) and streams a dump straight into a fresh BataDB project.
@@ -279,11 +279,39 @@ 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"];
-const PLATFORM_SCAFFOLDING_NAMES = new Set([
+let PLATFORM_SCAFFOLDING_NAMES = new Set([
     ...PLATFORM_SCAFFOLDING_TABLES,
     ...PLATFORM_SCAFFOLDING_SEQUENCES,
 ]);
-const PLATFORM_SCAFFOLDING_SCHEMA_PREFIXES = PLATFORM_SCAFFOLDING_SCHEMAS.map((s) => `${s}.`);
+let PLATFORM_SCAFFOLDING_SCHEMA_PREFIXES = PLATFORM_SCAFFOLDING_SCHEMAS.map((s) => `${s}.`);
+/**
+ * Merge the server-published scaffolding list (GET /v1/platform/import-scaffolding)
+ * into the baked-in defaults above. The server is the source of truth going
+ * forward — if provisioning grows new furniture, an already-installed CLI keeps
+ * verifying correctly instead of false-failing on it. Union (never replace): the
+ * baked defaults still apply against an older control plane, and a partial or
+ * malformed server response can only ever ADD exclusions it explicitly names.
+ * The exported const arrays are extended in place so every existing reference
+ * (the --yes guard, the created-target check, verify) sees the merged lists.
+ */
+export function applyServerScaffolding(server) {
+    const merge = (into, from) => {
+        if (!Array.isArray(from))
+            return;
+        for (const v of from) {
+            if (typeof v === "string" && v.length > 0 && !into.includes(v))
+                into.push(v);
+        }
+    };
+    merge(PLATFORM_SCAFFOLDING_TABLES, server.tables);
+    merge(PLATFORM_SCAFFOLDING_SEQUENCES, server.sequences);
+    merge(PLATFORM_SCAFFOLDING_SCHEMAS, server.schemas);
+    PLATFORM_SCAFFOLDING_NAMES = new Set([
+        ...PLATFORM_SCAFFOLDING_TABLES,
+        ...PLATFORM_SCAFFOLDING_SEQUENCES,
+    ]);
+    PLATFORM_SCAFFOLDING_SCHEMA_PREFIXES = PLATFORM_SCAFFOLDING_SCHEMAS.map((s) => `${s}.`);
+}
 /** Is this qualified name one of BataDB's seeded platform-scaffolding objects —
  *  either an exact named object, or anything inside a scaffolding schema? */
 export function isPlatformScaffolding(qualifiedName) {
@@ -610,6 +638,7 @@ export function parseImportArgs(args) {
     let source;
     let projectId;
     let name;
+    let pg;
     let help = false;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -646,8 +675,23 @@ export function parseImportArgs(args) {
         }
         else if (a.startsWith("--name="))
             name = a.slice("--name=".length);
+        else if (a === "--pg") {
+            const v = takeVal();
+            if (v === undefined)
+                return { error: "--pg requires a value (a PostgreSQL major, e.g. 17)." };
+            pg = v;
+        }
+        else if (a.startsWith("--pg="))
+            pg = a.slice("--pg=".length);
         // Unknown tokens / positionals are ignored — --source is the only input.
     }
+    if (pg !== undefined && !/^\d+$/.test(pg)) {
+        return { error: `--pg must be a PostgreSQL major version number (got "${pg}").` };
+    }
+    // --pg picks the version of a NEW project; an existing project's version is fixed.
+    if (pg !== undefined && projectId !== undefined && !help) {
+        return { error: "--pg only applies when creating a new project — it cannot change an existing --project's version." };
+    }
     // --project (import into an existing project) and --name (create a new one) are
     // opposite intents. Silently taking --project was the riskier read (mutating an
     // existing project while ignoring the requested name) — make it an explicit error.
@@ -656,11 +700,21 @@ export function parseImportArgs(args) {
             error: "--project and --name are mutually exclusive (import into an existing project OR create a new one).",
         };
     }
-    return { source, projectId, name, help };
+    return { source, projectId, name, pg, help };
+}
+/** Highest PostgreSQL major BataDB can create today — used only to pick the
+ *  DEFAULT version for a new import target (min(source major, this), floored at
+ *  16). An explicit --pg is passed through as-is and validated by the API's
+ *  allowlist, so a newer server accepts newer majors without a CLI release. */
+const HIGHEST_SUPPORTED_PG = 17;
+/** Default target major for a new project: match the source so features survive,
+ *  capped at what BataDB ships (a PG18 source → 17, a PG16 or older source → 16). */
+export function defaultTargetPg(sourceMajor) {
+    return String(Math.max(16, Math.min(sourceMajor, HIGHEST_SUPPORTED_PG)));
 }
 function printHelp() {
     log();
-    log(`  ${colors.bold("bata import")} ${colors.dim("--source <postgres-uri> [--project <id> | --name <name>]")}`);
+    log(`  ${colors.bold("bata import")} ${colors.dim("--source <postgres-uri> [--project <id> | --name <name>] [--pg <major>]")}`);
     log();
     log(`  Migrate a Neon (or any Postgres) database into BataDB via pg_dump | psql.`);
     log();
@@ -668,6 +722,7 @@ function printHelp() {
     log(`    ${colors.dim("--source <uri>")}    Source Postgres connection URI ${colors.dim("(required)")}`);
     log(`    ${colors.dim("--project <id>")}    Import into an existing BataDB project`);
     log(`    ${colors.dim("--name <name>")}     Create a new project with this name ${colors.dim("(default: source db name)")}`);
+    log(`    ${colors.dim("--pg <major>")}      PostgreSQL major for a NEW project ${colors.dim("(default: match the source, capped at 17)")}`);
     log(`    ${colors.dim("--yes, -y")}         Proceed even if the target already has tables`);
     log(`    ${colors.dim("--json")}            Machine-readable result`);
     log();
@@ -679,8 +734,9 @@ function printHelp() {
     log(`    ${colors.cyan('bata import --source "postgresql://…@ep-x.neon.tech/neondb"')}`);
     log(`    ${colors.cyan('bata import --source "$NEON_URL" --name my-app --yes --json')}`);
     log();
-    log(`  ${colors.dim("BataDB runs PostgreSQL 16. Standard PG17 schemas migrate cleanly;")}`);
-    log(`  ${colors.dim("PG17-only features fail loudly during restore (nothing is hidden).")}`);
+    log(`  ${colors.dim("BataDB runs PostgreSQL 16 and 17. A new target defaults to the source's")}`);
+    log(`  ${colors.dim("major (capped at 17); features newer than the target fail loudly during")}`);
+    log(`  ${colors.dim("restore (nothing is hidden).")}`);
     log();
 }
 export async function importDb(args) {
@@ -707,6 +763,22 @@ export async function importDb(args) {
     };
     if (!jsonMode)
         heading("Import into BataDB");
+    // Ask the control plane for the current platform-scaffolding list (tables/
+    // sequences/schemas provisioning seeds into every project) and merge it into
+    // the baked-in defaults, so every downstream consumer — the source-collision
+    // warning, the --yes non-empty guard, and verification — keeps excluding the
+    // platform's own furniture even when it grows after this CLI was installed.
+    // Best-effort: any failure — older server (404), network error, or a transport
+    // THROW (timeout/DNS) — silently keeps the defaults; it must never abort the run.
+    try {
+        const scaffRes = await api.get("/v1/platform/import-scaffolding", token);
+        if (scaffRes.ok && scaffRes.data && typeof scaffRes.data === "object") {
+            applyServerScaffolding(scaffRes.data);
+        }
+    }
+    catch {
+        // baked-in defaults stay in effect
+    }
     // The client tools are needed to even inspect the source, so verify they're on
     // PATH up front (the pg_dump-major-vs-source-major gate stays in phase 2, once
     // the source major is known).
@@ -793,6 +865,9 @@ export async function importDb(args) {
     const teamId = await resolveTeamId(token);
     let targetProjectId;
     let created = false;
+    // The target's PostgreSQL major (for messaging + the JSON result). For a new
+    // project this is what we asked for; for --project it's read from the record.
+    let targetPg;
     if (parsed.projectId) {
         phase(`Resolving target project ${parsed.projectId}`);
         const q = {};
@@ -807,27 +882,35 @@ export async function importDb(args) {
             return;
         }
         targetProjectId = parsed.projectId;
+        // Older control planes may omit pgVersion; fall back to the platform's
+        // historical default rather than guessing anything newer.
+        targetPg = projRes.data.pgVersion ?? "16";
     }
     else {
         const name = parsed.name ?? defaultProjectName(sourceSummary.database, source);
-        phase(`Creating project ${name} (serverless · PostgreSQL 16)`);
-        if (sourceMajor === 17 && !jsonMode) {
-            warn("source is PG17, BataDB target is PG16 — standard schemas migrate cleanly; " +
-                "PG17-only features will fail loudly during restore");
+        // An unparseable source version keeps the conservative historical default.
+        targetPg = parsed.pg ?? (sourceMajor === null ? "16" : defaultTargetPg(sourceMajor));
+        phase(`Creating project ${name} (serverless · PostgreSQL ${targetPg})`);
+        if (sourceMajor !== null && sourceMajor > Number(targetPg) && !jsonMode) {
+            warn(`source is PG${sourceMajor}, BataDB target is PG${targetPg} — standard schemas migrate cleanly; ` +
+                `PG${sourceMajor}-only features will fail loudly during restore`);
         }
         const body = {
             name,
             region: "us-east-1",
             compute: { tier: "serverless", size_cu: 1 },
-            pg_version: "16",
+            pg_version: targetPg,
         };
         if (teamId)
             body.team_id = teamId;
         const res = await api.post("/v1/projects", body, token);
         if (!res.ok) {
+            const explicitPg = parsed.pg !== undefined;
             emitError(res.status === 401 || res.status === 403 ? "INVALID_KEY"
                 : res.status >= 500 || res.status === 0 ? "API_UNAVAILABLE"
-                    : "CLI_ERROR", apiError(res, "Failed to create target project"), "");
+                    : "CLI_ERROR", apiError(res, "Failed to create target project"), 
+            // A 400 on an explicit --pg is almost always an unsupported major.
+            explicitPg && res.status === 400 ? "Try --pg 16 (or omit --pg for the default)." : "");
             return;
         }
         targetProjectId = res.data.id;
@@ -973,7 +1056,8 @@ export async function importDb(args) {
             json({
                 error: "Restore failed — the target rejected part of the dump.",
                 code: "RESTORE_FAILED",
-                hint: "PG17-only features aren't supported on the PG16 target. Review the errors below. " +
+                hint: `Schema features newer than the target's PostgreSQL ${targetPg} aren't supported there. ` +
+                    "Review the errors below. " +
                     strandedHintJson,
                 errors: migration.errors,
                 target: strandedTargetJson(),
@@ -1169,7 +1253,7 @@ export async function importDb(args) {
             target: {
                 project_id: targetProjectId,
                 created,
-                pg_version: "16",
+                pg_version: targetPg,
                 connection: targetUri,
             },
             verify: {
@@ -1202,7 +1286,7 @@ export async function importDb(args) {
     log();
     kvList([
         ["Project ID", colors.dim(targetProjectId)],
-        ["PostgreSQL", "16"],
+        ["PostgreSQL", targetPg],
         ["Connection", colors.dim(targetUri)],
     ]);
     log();
@@ -1218,7 +1302,7 @@ function emitErrorHuman(message, errors) {
             log(`    ${colors.dim(e)}`);
     }
     log();
-    log(`  ${colors.dim("PG17-only features aren't supported on the PG16 target.")}`);
+    log(`  ${colors.dim("Schema features newer than the target's PostgreSQL major aren't supported there.")}`);
     log();
 }
 function safeJsonArray(stdout) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batadata/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"
@@ -21,7 +21,7 @@
   "devDependencies": {
     "@types/node": "^22.10.0",
     "typescript": "^5.7.0",
-    "vitest": "^3.2.6"
+    "vitest": "^3.2.7"
   },
   "files": [
     "dist"