@batadata/cli 0.1.4 → 0.1.6

package/dist/commands/dev.js

@@ -4,7 +4,7 @@ export async function dev() {
     log(`  Get started with BataDB in your project:`);
     log();
     log(`  ${colors.cyan("1.")} ${colors.bold("Install the ORM")}`);
-    log(`     ${colors.dim("npm install @batadata/turbine")}`);
+    log(`     ${colors.dim("npm install turbine-orm")}`);
     log();
     log(`  ${colors.cyan("2.")} ${colors.bold("Set your database URL")}`);
     log(`     ${colors.dim("Add DATABASE_URL to your .env file:")}`);
@@ -14,10 +14,16 @@ export async function dev() {
     log(`     ${colors.dim("bata generate")}`);
     log();
     log(`  ${colors.cyan("4.")} ${colors.bold("Import and query")}`);
-    log(`     ${colors.dim("import { turbine } from '@batadata/turbine'")}`);
-    log(`     ${colors.dim("const db = turbine('DATABASE_URL')")}`);
+    log(`     ${colors.dim("import { turbine } from './generated/turbine'")}`);
+    log(`     ${colors.dim("const db = turbine({ connectionString: process.env.DATABASE_URL })")}`);
     log(`     ${colors.dim("const users = await db.users.findMany()")}`);
     log();
+    log(`  ${colors.dim("On the edge? Bind BataDB's HTTP driver to Turbine with zero glue:")}`);
+    log(`     ${colors.dim("import { turbineHttp } from 'turbine-orm/serverless'")}`);
+    log(`     ${colors.dim("import { Pool } from '@batadata/serverless'")}`);
+    log(`     ${colors.dim("import { SCHEMA } from './generated/turbine/metadata.js'")}`);
+    log(`     ${colors.dim("const db = turbineHttp(new Pool({ connectionString: process.env.DATABASE_URL }), SCHEMA)")}`);
+    log();
     log(`  ${colors.bold("Useful commands:")}`);
     log(`    ${colors.cyan("bata db connect")}     Open psql shell`);
     log(`    ${colors.cyan("bata db studio")}      Open visual table browser`);

package/dist/commands/generate.js

@@ -4,21 +4,21 @@ function printHelp() {
     log();
     log(`  ${colors.bold("bata generate")} ${colors.dim("— generate types from your database schema")}`);
     log();
-    log(`  Runs the Turbine type generator (${colors.dim("@batadata/turbine")}) against your`);
+    log(`  Runs the Turbine type generator (${colors.dim("turbine-orm")}) against your`);
     log(`  database, producing typed query bindings.`);
     log();
     log(`  ${colors.bold("Options")}`);
     log(`    ${colors.dim("--watch, -w")}   Regenerate on schema changes`);
     log(`    ${colors.dim("--help, -h")}    Show this help`);
     log();
-    log(`  ${colors.dim("Requires @batadata/turbine. Install with:")} ${colors.cyan("npm install @batadata/turbine")}`);
+    log(`  ${colors.dim("Requires turbine-orm. Install with:")} ${colors.cyan("npm install turbine-orm")}`);
     log();
 }
 /**
  * Resolve a runnable Turbine binary without invoking the network.
- * Prefers a locally installed binary; falls back to none (we do NOT
- * silently shell out to `npx`, which would try to download an unpublished
- * package and hang/crash).
+ * Prefers a locally installed binary (the `turbine` bin shipped by the
+ * `turbine-orm` package); falls back to a global install on PATH. We do NOT
+ * silently shell out to `npx`, which would trigger a download/prompt.
  */
 function resolveTurbine() {
     // 1. Local node_modules binary
@@ -46,10 +46,11 @@ export async function generate(args) {
     if (!turbine) {
         error("Turbine is not installed.");
         log();
-        log(`  ${colors.dim("`bata generate` uses the Turbine type generator, which is not")}`);
-        log(`  ${colors.dim("bundled with the CLI. Install it in your project first:")}`);
+        log(`  ${colors.dim("`bata generate` uses the Turbine type generator (the `turbine` bin")}`);
+        log(`  ${colors.dim("from turbine-orm), which is not bundled with the CLI. Install it")}`);
+        log(`  ${colors.dim("in your project first:")}`);
         log();
-        log(`    ${colors.cyan("npm install @batadata/turbine")}`);
+        log(`    ${colors.cyan("npm install turbine-orm")}`);
         log();
         log(`  ${colors.dim("Then run")} ${colors.cyan("bata generate")} ${colors.dim("again.")}`);
         log();
@@ -71,7 +72,7 @@ export async function generate(args) {
     });
     child.on("error", (err) => {
         warn(`Failed to run turbine generate: ${err.message}`);
-        error("Make sure @batadata/turbine is installed and on your PATH.");
+        error("Make sure turbine-orm is installed and its `turbine` bin is on your PATH.");
         process.exit(1);
     });
     child.on("exit", (code) => {

package/dist/commands/projects.d.ts

@@ -2,4 +2,10 @@ export declare function list(): Promise<void>;
 export declare function create(): Promise<void>;
 export declare function info(projectId?: string): Promise<void>;
 export declare function deleteProject(projectId?: string): Promise<void>;
+/**
+ * Resolve the target project from subcommand args: `--project <id>` /
+ * `--project=<id>` wins, otherwise the first non-flag positional. Flags like
+ * `--yes` / `--json` are never mistaken for a project ID.
+ */
+export declare function resolveProjectArg(args: string[]): string | undefined;
 export declare function handleProjects(args: string[]): Promise<void>;

package/dist/commands/projects.js

@@ -242,15 +242,29 @@ export async function deleteProject(projectId) {
     success(`Project ${id} deleted.`);
     log();
 }
+/**
+ * Resolve the target project from subcommand args: `--project <id>` /
+ * `--project=<id>` wins, otherwise the first non-flag positional. Flags like
+ * `--yes` / `--json` are never mistaken for a project ID.
+ */
+export function resolveProjectArg(args) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--project" && args[i + 1])
+            return args[i + 1];
+        if (args[i].startsWith("--project="))
+            return args[i].slice("--project=".length);
+    }
+    return args.find((a) => !a.startsWith("-"));
+}
 export async function handleProjects(args) {
     const sub = args[0];
     switch (sub) {
         case "create":
             return create();
         case "info":
-            return info(args[1]);
+            return info(resolveProjectArg(args.slice(1)));
         case "delete":
-            return deleteProject(args[1]);
+            return deleteProject(resolveProjectArg(args.slice(1)));
         case "list":
         case undefined:
             return list();

package/dist/config.js

@@ -1,7 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-const CONFIG_PATH = path.join(os.homedir(), ".batarc");
+/**
+ * Resolve the `~/.batarc` path at CALL time, not import time. Reading
+ * `os.homedir()` once into a top-level const freezes the home directory before
+ * anything can override HOME — which silently breaks (a) users who set a custom
+ * HOME and (b) tests that redirect HOME to a temp dir (the redirect would be
+ * ignored and the suite would read the developer's REAL ~/.batarc). Preferring
+ * the env vars makes the override deterministic across platforms.
+ */
+function configPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, ".batarc");
+}
 const DEFAULT_API_URL = "https://api.batadata.com";
 const runtime = { json: false, yes: false };
 export function setRuntime(ctx) {
@@ -23,7 +34,7 @@ export function isYes() {
 }
 export function loadConfig() {
     try {
-        const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+        const raw = fs.readFileSync(configPath(), "utf-8");
         return JSON.parse(raw);
     }
     catch {
@@ -33,11 +44,11 @@ export function loadConfig() {
 export function saveConfig(config) {
     const existing = loadConfig();
     const merged = { ...existing, ...config };
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    fs.writeFileSync(configPath(), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 export function clearConfig() {
     try {
-        fs.unlinkSync(CONFIG_PATH);
+        fs.unlinkSync(configPath());
     }
     catch {
         // File doesn't exist, that's fine

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@batadata/cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"
   },
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "vitest run"
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test \"test/*.test.mjs\"",
+    "pretest": "npm run build"
   },
   "engines": {
     "node": ">=20.0.0"

package/dist/commands/db.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/db.test.js

@@ -1,193 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const { get, post } = vi.hoisted(() => ({
-    get: vi.fn(async () => ({
-        ok: true,
-        status: 200,
-        // Shape matches GET /v1/projects/:id: camelCase branch fields enriched
-        // with computeStatus + ready. `feature` is a second, non-primary branch
-        // so name/id resolution has something to match.
-        data: {
-            id: "proj_1",
-            name: "demo",
-            branches: [
-                { id: "br_primary", name: "main", isPrimary: true, computeStatus: "active", ready: true },
-                { id: "br_feature", name: "feature", isPrimary: false, computeStatus: "idle", ready: false },
-            ],
-        },
-    })),
-    post: vi.fn(async () => ({ ok: true, status: 200, data: { columns: ["n"], rows: [{ n: "1" }], rowCount: 1 } })),
-}));
-vi.mock("../api.js", () => ({
-    api: { get, post, del: vi.fn() },
-    resolveTeamId: vi.fn(async () => "team_test"),
-    // Mirror the real apiError so retryable mapping (which reads the server code)
-    // gets a realistic message; we don't need its exact format here.
-    apiError: (res, fallback) => {
-        const msg = res?.data?.error ?? fallback;
-        const code = res?.data?.code ? ` (${res.data.code})` : "";
-        return `${msg}${code}`;
-    },
-    asList: (data) => (Array.isArray(data) ? data : []),
-}));
-import { query, handleDb } from "./db.js";
-import { setRuntime } from "../config.js";
-let tmpHome;
-let logSpy;
-// process.exit must NOT actually exit the test runner. Throw a tagged error so
-// the handler unwinds at the exit point; tests catch it and read the code.
-class ExitError extends Error {
-    code;
-    constructor(code) {
-        super(`exit ${code}`);
-        this.code = code;
-    }
-}
-beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "bata-cli-db-test-"));
-    vi.stubEnv("HOME", tmpHome);
-    vi.stubEnv("USERPROFILE", tmpHome);
-    // A real credential + a default project so query() reaches the network seam.
-    fs.writeFileSync(path.join(tmpHome, ".batarc"), JSON.stringify({ defaultProject: "proj_1" }));
-    setRuntime({ apiKey: "test-token", apiUrl: "https://api.test.local", json: true, yes: false });
-    get.mockClear();
-    post.mockClear();
-    vi.spyOn(process, "exit").mockImplementation(((code) => {
-        throw new ExitError(code ?? 0);
-    }));
-    // Silence the JSON/decorative output so test logs stay clean.
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-    vi.spyOn(console, "error").mockImplementation(() => { });
-});
-afterEach(() => {
-    vi.unstubAllEnvs();
-    vi.restoreAllMocks();
-    setRuntime({ json: false, yes: false });
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-/** Run a handler that's expected to call process.exit; return the exit code. */
-async function exitCodeOf(run) {
-    try {
-        await run();
-    }
-    catch (e) {
-        if (e instanceof ExitError)
-            return e.code;
-        throw e;
-    }
-    return 0; // handler returned without exiting (success path)
-}
-describe("db query — --help short-circuits before any network call", () => {
-    it("`db query --help` prints help and makes NO api call (exit 0)", async () => {
-        const code = await exitCodeOf(() => handleDb(["query", "--help"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-        // It actually printed usage, not a row result.
-        const printed = logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-        expect(printed).toContain("bata db query");
-        expect(printed).toContain("--branch");
-    });
-    it("`db query -h` (short flag) also short-circuits with no api call", async () => {
-        const code = await exitCodeOf(() => handleDb(["query", "-h"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-    });
-    it("`db --help` prints general db help with no api call", async () => {
-        const code = await exitCodeOf(() => handleDb(["--help"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-    });
-});
-describe("db query — branch targeting", () => {
-    it("--branch <id> resolves to that branch and sets branch_id", async () => {
-        await exitCodeOf(() => query(["SELECT 1", "--branch", "br_feature"]));
-        expect(post).toHaveBeenCalledTimes(1);
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_feature", query: "SELECT 1" }), "test-token");
-    });
-    it("--branch <name> resolves the NAME to the branch id (was 'Branch not found')", async () => {
-        await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(post).toHaveBeenCalledTimes(1);
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", 
-        // Resolved the NAME "feature" → its id "br_feature".
-        expect.objectContaining({ branch_id: "br_feature", query: "SELECT 1" }), "test-token");
-    });
-    it("--branch=<name> (equals form) is also resolved", async () => {
-        await exitCodeOf(() => query(["--branch=feature", "SELECT 2"]));
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_feature", query: "SELECT 2" }), "test-token");
-    });
-    it("--branch <unknown> exits 5 (not-found) and never runs a query", async () => {
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "does-not-exist"]));
-        expect(code).toBe(5);
-        expect(post).not.toHaveBeenCalled();
-    });
-    it("without --branch, resolves the project's primary branch (default behavior)", async () => {
-        await exitCodeOf(() => query(["SELECT 1"]));
-        expect(get).toHaveBeenCalledTimes(1); // resolved primary
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_primary", query: "SELECT 1" }), "test-token");
-    });
-});
-describe("db query — retryable cold-start mapping (exit 6)", () => {
-    it("503 + { code: COMPUTE_STARTING } maps to exit 6 (retryable), not 1", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 503,
-            data: { error: "compute is starting", code: "COMPUTE_STARTING" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(code).toBe(6);
-    });
-    it("REGRESSION GUARD: a non-5xx status carrying { code: COMPUTE_STARTING } still maps to exit 6", async () => {
-        // The pre-fix code only looked at the HTTP status (>=500 || 0), so a
-        // COMPUTE_STARTING surfaced on, say, a 425 would have been CLI_ERROR (exit
-        // 1). This is the exact guard for the body-code inspection.
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 425,
-            data: { error: "compute is starting", code: "COMPUTE_STARTING" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(code).toBe(6);
-    });
-    it("a connection-refused error body maps to exit 6", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 0,
-            data: { error: "connect ECONNREFUSED 127.0.0.1:5432" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(code).toBe(6);
-    });
-    it("a generic 5xx maps to exit 6", async () => {
-        post.mockResolvedValueOnce({ ok: false, status: 502, data: { error: "bad gateway" } });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(code).toBe(6);
-    });
-    it("a genuine SQL syntax error (200 with error field) stays exit 1, NOT retryable", async () => {
-        post.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            data: { error: 'syntax error at or near "SELCT"' },
-        });
-        const code = await exitCodeOf(() => query(["SELCT 1", "--branch", "feature"]));
-        expect(code).toBe(1);
-    });
-    it("a 400 bad-input SQL error stays exit 1, NOT retryable", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 400,
-            data: { error: "relation does not exist" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT * FROM nope", "--branch", "feature"]));
-        expect(code).toBe(1);
-    });
-    it("a 401 stays auth (exit 4), not retryable", async () => {
-        post.mockResolvedValueOnce({ ok: false, status: 401, data: { error: "invalid key" } });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "feature"]));
-        expect(code).toBe(4);
-    });
-});

package/dist/commands/projects.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/projects.test.js

@@ -1,104 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// --- Mock the network layer so no real HTTP happens and we can assert that the
-// --- DELETE call is (or isn't) invoked. This is the seam: deleteProject() calls
-// --- `api.del(...)`, so a spy here proves whether the delete actually proceeds.
-// `vi.hoisted` so the spy exists before the hoisted vi.mock factory runs.
-const { del, readlineQuestion } = vi.hoisted(() => ({
-    del: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-    // The interactive prompt seam: confirm() -> prompt() -> readline.question().
-    // Default answer is empty; a TTY test sets it to "n" to decline.
-    readlineQuestion: vi.fn((_q, cb) => cb("")),
-}));
-vi.mock("../api.js", () => ({
-    api: {
-        get: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-        post: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-        del,
-    },
-    // No real /v1/teams round-trip; deleteProject only needs an optional team id.
-    resolveTeamId: vi.fn(async () => "team_test"),
-    apiError: (_res, fallback) => fallback,
-    asList: (data) => (Array.isArray(data) ? data : []),
-}));
-// Mock readline so the interactive confirm() branch never blocks on real stdin.
-vi.mock("node:readline", () => ({
-    default: { createInterface: () => ({ question: readlineQuestion, close: () => { } }) },
-    createInterface: () => ({ question: readlineQuestion, close: () => { } }),
-}));
-// We deliberately do NOT mock ../config.js or ../utils/prompts.js — the whole
-// point of this test is to exercise the REAL confirmDestructive() + the REAL
-// runtime flag plumbing (setRuntime/isYes/isJsonMode), since that branch is the
-// destructive-headless contract under test.
-import { deleteProject } from "./projects.js";
-import { setRuntime } from "../config.js";
-let tmpHome;
-let realIsTTY;
-beforeEach(() => {
-    // Point ~/.batarc at a throwaway HOME so loadConfig/saveConfig never touch the
-    // developer's real config. os.homedir() reads HOME at call time (verified).
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "bata-cli-test-"));
-    vi.stubEnv("HOME", tmpHome);
-    vi.stubEnv("USERPROFILE", tmpHome); // Windows parity
-    // requireToken() resolves the --api-key runtime value first, so a real
-    // credential exists without writing a config file.
-    setRuntime({ apiKey: "test-token", apiUrl: "https://api.test.local", json: false, yes: false });
-    del.mockClear();
-    readlineQuestion.mockClear();
-    readlineQuestion.mockImplementation((_q, cb) => cb(""));
-    // Snapshot isTTY so individual tests can override it and we restore after.
-    realIsTTY = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
-});
-afterEach(() => {
-    vi.unstubAllEnvs();
-    vi.restoreAllMocks();
-    setRuntime({ json: false, yes: false });
-    if (realIsTTY) {
-        Object.defineProperty(process.stdin, "isTTY", realIsTTY);
-    }
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-function setTTY(value) {
-    Object.defineProperty(process.stdin, "isTTY", { value, configurable: true });
-}
-describe("projects delete — destructive headless contract", () => {
-    it("REGRESSION GUARD: with --yes, does NOT prompt and the DELETE actually proceeds", async () => {
-        // The original bug: headless `--yes` exited 0 having deleted NOTHING.
-        // This is the exact guard — if deleteProject silently skipped the delete,
-        // `del` would never be called and this expectation would fail.
-        setTTY(true); // even on a TTY, --yes must skip the prompt and proceed
-        setRuntime({ yes: true });
-        await deleteProject("proj_123");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_123", "test-token", expect.objectContaining({ team_id: "team_test" }));
-    });
-    it("in --json mode, proceeds without prompting and deletes", async () => {
-        setTTY(true);
-        setRuntime({ json: true });
-        await deleteProject("proj_json");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_json", "test-token", expect.anything());
-    });
-    it("when stdin is not a TTY (agent / piped / CI), proceeds and deletes without --yes", async () => {
-        // This is the CLI's whole purpose: unattended deletes must go through.
-        setTTY(false);
-        setRuntime({ yes: false, json: false });
-        await deleteProject("proj_pipe");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_pipe", "test-token", expect.anything());
-    });
-    it("interactive TTY without --yes WOULD prompt; answering no aborts (no DELETE)", async () => {
-        // Covers the interactive branch of confirmDestructive(): it must ask, and a
-        // "no" answer must NOT call the delete API. The mocked readline (above) is
-        // the seam confirm() -> prompt() uses; we answer "n" to decline.
-        setTTY(true);
-        setRuntime({ yes: false, json: false });
-        readlineQuestion.mockImplementation((_q, cb) => cb("n"));
-        await deleteProject("proj_keep");
-        expect(readlineQuestion).toHaveBeenCalledTimes(1); // it DID prompt
-        expect(readlineQuestion.mock.calls[0][0]).toContain("Delete project");
-        expect(del).not.toHaveBeenCalled(); // declined → no destructive call
-    });
-});