@batadata/cli 0.2.9 → 0.2.11

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,8 +848,17 @@ 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 ` +
+    // 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 the target. The restore will likely fail with "relation already ' +
             'exists" — rename or exclude it on the source to migrate cleanly.');
     }
@@ -1083,7 +1107,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 +1153,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/powdb.d.ts

@@ -45,7 +45,7 @@ export interface TableSchema {
     constraints: ConstraintInfo[];
 }
 /** The Stage-A PowDB types a static PowQL artifact can carry. */
-export type PowType = "int" | "float" | "str" | "bool" | "datetime";
+export type PowType = "int" | "float" | "str" | "bool" | "datetime" | "json";
 export interface TypeMapping {
     /** null → PowDB has no Stage-A representation; the column is DROPPED. */
     powType: PowType | null;
@@ -133,8 +133,16 @@ export interface TablePlan {
     pgName: string;
     powName: string;
     columns: ColumnPlan[];
+    /** powNames of carried single-column secondary (non-unique) indexes. */
+    secondaryIndexes: string[];
     warnings: string[];
 }
+/**
+ * Extract the single plain column of a non-unique btree index definition, or
+ * null when the index can't be carried (multi-column, expression, partial,
+ * non-btree). Exported for unit testing.
+ */
+export declare function parseSingleColumnIndex(definition: string): string | null;
 /**
  * Build the per-table PowQL `type` plan from a Postgres table's schema,
  * accumulating an honesty note for every column/constraint that can't be
@@ -143,6 +151,12 @@ export interface TablePlan {
 export declare function planTable(t: TableSchema): TablePlan;
 /** Render a table plan as a PowQL `type` DDL block. */
 export declare function renderTypeDdl(plan: TablePlan): string;
+/**
+ * Render a plan's carried secondary indexes as `alter T add index .col;`
+ * statements (PowQL DDL, valid since 0.1.1; keyword columns backtick-quote
+ * inside the path, e.g. `alter Post add index .\`order\``).
+ */
+export declare function renderIndexDdl(plan: TablePlan): string[];
 export interface InsertResult {
     statements: string[];
     warnings: string[];

package/dist/commands/powdb.js

@@ -8,7 +8,7 @@ import { emitError, isRetryable } from "../utils/errors.js";
 import { resolveProjectId, resolveBranchId } from "../link.js";
 // PowQL reserved words a column/table name must not collide with. Mirrors the
 // FULL engine lexer keyword set (crates/query/src/lexer.rs POWQL_KEYWORDS as
-// of PowDB 0.10.0 — which added `schema`/`describe`). A colliding name is
+// of PowDB 0.13.0 — which added `raw`, `json_type`, `json_text`). A colliding name is
 // emitted backtick-quoted (0.10+ syntax) rather than renamed, so the exported
 // column keeps its source name. Keep this list in sync on PowDB upgrades: a
 // missing word here means a bare identifier that fails to parse on load.
@@ -21,7 +21,8 @@ const POWQL_KEYWORDS = new Set([
     "having", "in", "index", "inner", "insert", "is", "join", "left", "length",
     "let", "like", "limit", "link", "lower", "match", "materialize",
     "materialized", "max", "min", "multi", "not", "now", "null", "offset", "on",
-    "or", "order", "outer", "over", "partition", "pow", "rank", "refresh",
+    "json_text", "json_type", "or", "order", "outer", "over", "partition",
+    "pow", "rank", "raw", "refresh",
     "required", "returning", "right", "rollback", "round", "row_number",
     "schema", "select", "sqrt", "substring", "sum", "then", "transaction",
     "trim", "true", "type", "union", "unique", "update", "upper", "upsert",
@@ -75,9 +76,14 @@ export function mapPgType(dataType) {
     if (t === "bytea") {
         return { powType: "str", note: "bytea carried as hex text (str) — PowDB has no static bytes literal for a script load" };
     }
-    // json/jsonb — carried as text; no JSON operators.
+    // json/jsonb → native PowDB `json` (0.12+): canonical binary (PJ1), `->`
+    // path querying. Canonicalization is honest-but-lossy for exact text: object
+    // keys re-sort bytewise and duplicate keys collapse last-wins (same as pg jsonb).
     if (t === "json" || t === "jsonb") {
-        return { powType: "str", note: `${t} carried as text (str) — no JSON operators in PowDB Stage A` };
+        return {
+            powType: "json",
+            note: `${t} stored as native PowDB json (requires PowDB 0.12+; canonical form — key order normalized${t === "json" ? ", duplicate keys last-wins" : ""})`,
+        };
     }
     // Everything else (arrays, enums, ranges, geometry, network, tsvector,
     // composite/user-defined) has no honest Stage-A representation.
@@ -183,6 +189,16 @@ export function powqlLiteral(value, powType) {
             const raw = typeof value === "string" ? value : JSON.stringify(value);
             return { literal: `"${escapePowqlString(raw)}"`, risky: isLoadRiskyString(raw) };
         }
+        case "json": {
+            // PowQL inserts JSON as a string literal (validated + canonicalized by
+            // the engine). Rows arrive as parsed JSON over SQL-over-HTTP, so
+            // re-stringify the VALUE — a JS string here is a JSON string scalar
+            // document and must be emitted quoted-inside-the-document.
+            const doc = JSON.stringify(value);
+            if (doc === undefined)
+                return { skip: true, reason: `value has no JSON representation` };
+            return { literal: `"${escapePowqlString(doc)}"`, risky: isLoadRiskyString(doc) };
+        }
     }
 }
 /**
@@ -229,9 +245,49 @@ export function parsePgDefault(defaultValue, powType) {
             return { kind: "literal", text: `"${escapePowqlString(m[1].replace(/''/g, "'"))}"` };
         return { kind: "drop", note: `expression default dropped (${raw})` };
     }
+    // json: a quoted literal default ('{}'::jsonb) carries as a string-literal
+    // default only if its content is valid JSON — the engine would reject the
+    // whole type DDL otherwise.
+    if (powType === "json") {
+        const m = /^'([\s\S]*)'$/.exec(noCast);
+        if (m) {
+            const text = m[1].replace(/''/g, "'");
+            try {
+                JSON.parse(text);
+                return { kind: "literal", text: `"${escapePowqlString(text)}"` };
+            }
+            catch {
+                return { kind: "drop", note: `non-JSON default on json column dropped (${raw})` };
+            }
+        }
+        return { kind: "drop", note: `expression default dropped (${raw})` };
+    }
     // datetime defaults are expressions (now(), CURRENT_TIMESTAMP) — never scalar.
     return { kind: "drop", note: `expression default dropped (${raw})` };
 }
+/**
+ * Extract the single plain column of a non-unique btree index definition, or
+ * null when the index can't be carried (multi-column, expression, partial,
+ * non-btree). Exported for unit testing.
+ */
+export function parseSingleColumnIndex(definition) {
+    if (/\bWHERE\b/i.test(definition))
+        return null; // partial
+    if (/\bINCLUDE\b/i.test(definition))
+        return null; // covering — the trailing parens are the INCLUDE list, not the key
+    if (/\bUSING\s+(?!btree\b)/i.test(definition))
+        return null; // gin/gist/hash/...
+    const m = /\(([^()]*)\)\s*$/.exec(definition);
+    if (!m)
+        return null; // expression index
+    const cols = m[1].split(",");
+    if (cols.length !== 1)
+        return null; // multi-column
+    const col = /^\s*(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_$]*))\s*(?:ASC|DESC)?\s*(?:NULLS\s+(?:FIRST|LAST))?\s*$/i.exec(cols[0]);
+    if (!col)
+        return null;
+    return col[1] ?? col[2];
+}
 /**
  * Build the per-table PowQL `type` plan from a Postgres table's schema,
  * accumulating an honesty note for every column/constraint that can't be
@@ -264,14 +320,30 @@ export function planTable(t) {
             warnings.push(`foreign key ${c.name} → ${c.foreignTableName ?? "?"} dropped — PowDB Stage A has no foreign keys`);
         }
         else if (type.includes("CHECK")) {
+            // PG17+ surfaces NOT NULL as synthetic check constraints named
+            // <reloid>_<attnum>_..._not_null (all-numeric prefix). Those ARE carried
+            // (as `required`), so warning about them would be noise — but a
+            // USER-named check that merely ends in _not_null must still warn.
+            if (/^\d+(_\d+)*_not_null$/.test(c.name))
+                continue;
             warnings.push(`check constraint ${c.name} dropped — PowDB Stage A has no check constraints`);
         }
     }
-    // Secondary (non-unique) indexes aren't carried — the type definition only
-    // expresses uniqueness, not standalone indexes.
+    // Single-column plain btree indexes carry as `alter T add index .col`
+    // statements (resolved against carried columns after the column loop below);
+    // anything else (multi-column, expression, partial, non-btree) is warned.
+    const pendingIndexCols = [];
     for (const idx of t.indexes ?? []) {
-        if (!/unique/i.test(idx.definition)) {
-            warnings.push(`index ${idx.name} not carried — PowDB Stage A expresses only unique constraints, not secondary indexes`);
+        // Only a leading CREATE UNIQUE INDEX is a unique index — a bare substring
+        // match would silently skip an index whose NAME merely contains "unique".
+        if (/^\s*CREATE\s+UNIQUE\s+INDEX\b/i.test(idx.definition))
+            continue;
+        const pgCol = parseSingleColumnIndex(idx.definition);
+        if (pgCol) {
+            pendingIndexCols.push({ idxName: idx.name, pgCol });
+        }
+        else {
+            warnings.push(`index ${idx.name} not carried — only single-column plain btree indexes map to PowDB \`add index\``);
         }
     }
     const columns = [];
@@ -312,12 +384,27 @@ export function planTable(t) {
             defaultLiteral: auto ? null : defaultLiteral,
         });
     }
+    // Resolve carried secondary indexes against the columns that survived the
+    // mapping; an index on a dropped column is warned, not silently lost.
+    const byPgName = new Map(columns.map((c) => [c.pgName, c]));
+    const secondaryIndexes = [];
+    for (const { idxName, pgCol } of pendingIndexCols) {
+        const col = byPgName.get(pgCol);
+        if (!col) {
+            warnings.push(`index ${idxName} not carried — its column ${pgCol} was not representable`);
+            continue;
+        }
+        if (col.unique)
+            continue; // already an index via the unique modifier
+        secondaryIndexes.push(col.powName);
+    }
     return {
         pgQualified: `"${t.schema}"."${t.name}"`,
         pgSchema: t.schema,
         pgName: t.name,
         powName: tPowName,
         columns,
+        secondaryIndexes,
         warnings,
     };
 }
@@ -340,6 +427,14 @@ export function renderTypeDdl(plan) {
     lines.push("}");
     return lines.join("\n");
 }
+/**
+ * Render a plan's carried secondary indexes as `alter T add index .col;`
+ * statements (PowQL DDL, valid since 0.1.1; keyword columns backtick-quote
+ * inside the path, e.g. `alter Post add index .\`order\``).
+ */
+export function renderIndexDdl(plan) {
+    return plan.secondaryIndexes.map((powName) => `alter ${renderPowqlIdent(plan.powName)} add index .${renderPowqlIdent(powName)};`);
+}
 /**
  * Render rows for one table as PowQL `insert` statements against its plan.
  * Values that can't be represented are omitted (the field falls back to
@@ -499,6 +594,7 @@ async function powdbPull(args) {
     const reports = [];
     let totalRows = 0;
     let anyLoadRisk = false;
+    let anyJson = false;
     for (const t of tables) {
         s?.update(`Exporting ${t.schema}.${t.name}`);
         const plan = planTable(t);
@@ -522,6 +618,8 @@ async function powdbPull(args) {
         }
         if (inserts.loadRisk)
             anyLoadRisk = true;
+        if (plan.columns.some((c) => c.powType === "json"))
+            anyJson = true;
         // Emit the type DDL, its honesty notes, and the inserts for this table.
         // Comments are `;`/newline-sanitized so they survive the `--exec` split.
         parts.push(commentSafe(`# ── ${t.schema}.${t.name} → ${plan.powName} (${inserts.statements.length} row(s)) ──`));
@@ -533,6 +631,9 @@ async function powdbPull(args) {
         }
         else {
             parts.push(ddl + ";");
+            const indexDdl = renderIndexDdl(plan);
+            if (indexDdl.length)
+                parts.push(indexDdl.join("\n"));
             parts.push("");
             if (inserts.statements.length) {
                 parts.push(inserts.statements.join("\n"));
@@ -557,6 +658,7 @@ async function powdbPull(args) {
         tableCount: tables.length,
         rowCount: totalRows,
         loadRisk: anyLoadRisk,
+        usesJson: anyJson,
         limit,
     });
     const artifact = header + "\n" + parts.join("\n") + "\n";
@@ -629,7 +731,9 @@ function buildArtifactHeader(o) {
     // which lexes as two minus signs and fails to parse).
     const lines = [
         "# PowDB Stage A export — generated by `bata powdb pull`",
-        "# Target: PowDB 0.10+ (reserved identifiers are backtick-quoted)",
+        o.usesJson
+            ? "# Target: PowDB 0.12+ (native json columns; reserved identifiers are backtick-quoted)"
+            : "# Target: PowDB 0.10+ (reserved identifiers are backtick-quoted)",
         "#",
         `# Source project : ${o.projectName} (${o.projectId})`,
         `# Source branch  : ${o.branchName} (${o.branchId})`,
@@ -642,7 +746,8 @@ function buildArtifactHeader(o) {
         "#",
         "# COMPAT-HONEST: `# WARN:` lines below name every Postgres feature that",
         "# PowDB Stage A cannot carry faithfully (foreign keys, check constraints,",
-        "# secondary indexes, unmapped types, expression defaults, lossy numerics).",
+        "# multi-column/expression/partial indexes, unmapped types, expression",
+        "# defaults, lossy numerics).",
         "# PowDB is NOT Postgres-compatible beyond this mapping; nothing here claims",
         "# otherwise, and no engine-speed comparison is implied.",
     ];

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.9",
+  "version": "0.2.11",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"