@kroombase/client 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# @kroombase/client
+
+Typed JavaScript and TypeScript client for **KroomBase** — a hosted PostgreSQL backend. It talks
+to the REST API, so anything that can make an HTTP request can use the same backend; this package
+is the ergonomic path for JS/TS.
+
+## Install
+
+```bash
+npm install @kroombase/client
+```
+
+## Quick start
+
+```ts
+import { KroomBase } from "@kroombase/client";
+
+const db = new KroomBase({ apiKey: "kb_your_api_key" });
+
+const rows = await db.from("orders").select(["id", "total"]).where("status", "=", "paid").limit(10);
+const [created] = await db.insert("orders", { customer_id: 1, total: 42 });
+await db.update("orders", created.id, { status: "shipped" });
+await db.delete("orders", created.id);
+```
+
+## Configuration
+
+```ts
+new KroomBase({
+  apiKey: "kb_...",            // data access — no raw SQL
+  // token: "eyJ...",          // session token — also enables sql()
+  url: "https://kroombase.kroombox.com",  // optional, this is the default
+  fetch: customFetch,          // optional, e.g. for tests or a proxy
+  timeoutMs: 30000,            // optional, 0 disables the timeout
+});
+```
+
+One of `apiKey` / `token` is required. The constructor throws if neither is given, rather than
+failing later with a 401.
+
+## Methods
+
+| Method | Needs | Returns |
+| --- | --- | --- |
+| `listTables()` | apiKey | table names |
+| `from(table).select(cols?)` | apiKey | rows; chainable with `.where()`, `.order()`, `.limit()`, `.offset()` |
+| `insert(table, data)` | apiKey | the inserted row(s) |
+| `update(table, id, data)` | apiKey | the updated row; throws if nothing matched |
+| `delete(table, id)` | apiKey | `{ message }` |
+| `sql(projectId, query)` | token | one entry per statement, each with `rows` and `rowCount` |
+| `createBucket(name)` | token | the new bucket |
+| `listBuckets()` | token | your buckets |
+| `uploadFile(bucketId, path, file)` | token | the stored object |
+| `listFiles(bucketId, path?)` | token | folder entries |
+| `deleteFile(bucketId, path)` | token | confirmation |
+
+The query builder is awaitable directly — `await db.from("t").limit(1)` works without calling
+`.run()`.
+
+## Errors
+
+Every non-2xx response throws `KroomBaseError` with `status`, `body`, and `message`:
+
+```ts
+import { KroomBaseError } from "@kroombase/client";
+
+try {
+  await db.update("orders", 999, { status: "x" });
+} catch (err) {
+  if (err instanceof KroomBaseError) console.error(err.status, err.message);
+}
+```
+
+## Honest limits
+
+These are properties of the REST API this client wraps, documented so you are not surprised:
+
+- **`delete()` cannot confirm a deletion.** `DELETE /rest/:table/:id` answers
+  `{message:"row deleted"}` whether or not a row matched. Read first, or use `sql()` with
+  `DELETE ... RETURNING`, when that matters.
+- **`update()` throws on a missing row.** The route itself answers `200 []`; this client turns
+  that into a 404 error, because a write that silently did nothing is worse than a failure.
+- **Raw SQL needs a session token.** API keys are refused by `/query`; that is deliberate, so a
+  leaked key cannot drop tables.
+
+## Other languages
+
+The SDK is a convenience, not a requirement. The REST API is one header and plain JSON:
+
+```bash
+curl "https://kroombase.kroombox.com/rest/orders?limit=5" -H "apikey: kb_your_api_key"
+```
+
+See the docs in the app for Python and raw `curl` equivalents.

package/dist/index.cjs

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * KroomBase client for JavaScript and TypeScript.
+ *
+ * A thin, typed wrapper over the REST API: one method per operation, no hidden state, no
+ * retries you did not ask for. The query builder only exposes what the server actually
+ * accepts — a single filter per request, row ids as integers — so a call that compiles is a
+ * call the API will answer.
+ *
+ *   import { KroomBase } from "@kroombase/client";
+ *   const db = new KroomBase({ apiKey: "kbase_..." });
+ *   const users = await db.from("users").select().where("age", "gt", 21).limit(10);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = exports.KroomBase = exports.KroomBaseError = void 0;
+/** Thrown for any non-2xx answer, carrying the status and the server's own error body. */
+class KroomBaseError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message || `KroomBase request failed with status ${status}`);
+        this.name = "KroomBaseError";
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.KroomBaseError = KroomBaseError;
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        search.set(key, String(value));
+    }
+    const s = search.toString();
+    return s ? `?${s}` : "";
+}
+class KroomBase {
+    baseUrl;
+    headers;
+    timeoutMs;
+    onRequest;
+    constructor(options) {
+        if (!options?.apiKey && !options?.token) {
+            throw new Error("KroomBase: pass either apiKey (REST + MCP database tools) or token (SQL + storage).");
+        }
+        this.baseUrl = (options.url || "https://kroombase.kroombox.com").replace(/\/+$/, "");
+        this.headers = options.apiKey
+            ? { apikey: options.apiKey }
+            : { Authorization: `Bearer ${options.token}` };
+        this.timeoutMs = options.timeoutMs ?? 30000;
+        this.onRequest = options.onRequest;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        this.onRequest?.({ method, url });
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers: body === undefined
+                    ? this.headers
+                    : { ...this.headers, "Content-Type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            const parsed = text ? safeJson(text) : null;
+            if (!res.ok) {
+                const detail = parsed && typeof parsed === "object" && "error" in parsed
+                    ? String(parsed.error)
+                    : undefined;
+                throw new KroomBaseError(res.status, parsed ?? text, detail);
+            }
+            return parsed;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Start a query against one table. */
+    from(table) {
+        return new QueryBuilder(this, table);
+    }
+    /** List every table in the project's schema. */
+    listTables() {
+        return this.request("GET", "/rest").then((rows) => rows.map((r) => r.table_name));
+    }
+    /** Insert one row and get it back. */
+    insert(table, data) {
+        return this.request("POST", `/rest/${encodeURIComponent(table)}`, data);
+    }
+    /**
+     * Update one row by integer id and return it.
+     *
+     * Throws when nothing matched: the REST route answers `200 []` for an id that does not exist,
+     * and a write that silently did nothing is worse than an error.
+     */
+    async update(table, id, data) {
+        const rows = await this.request("PUT", `/rest/${encodeURIComponent(table)}/${id}`, data);
+        if (!Array.isArray(rows) || rows.length === 0) {
+            throw new KroomBaseError(404, null, `no row with id ${id} in ${table} — nothing was updated`);
+        }
+        return rows;
+    }
+    /**
+     * Delete one row by integer id.
+     *
+     * The REST route always answers `{message:"row deleted"}`, whether or not a row matched, so
+     * this cannot tell you if anything was removed. When that matters, read the row first or use
+     * `sql()` with `DELETE ... RETURNING`.
+     */
+    delete(table, id) {
+        return this.request("DELETE", `/rest/${encodeURIComponent(table)}/${id}`);
+    }
+    /**
+     * Run raw SQL. Requires a session token: the API key is refused by this endpoint, by design.
+     * `projectId` is the full 32-character project id.
+     */
+    sql(projectId, query) {
+        return this.request("POST", "/query", {
+            projectId,
+            query,
+        }).then((r) => 
+        // `/query` answers one entry per statement under `results`, each keyed by the statement
+        // text it ran — not by an index, so the shape is normalised here.
+        (r.results || []).map((s) => ({ statement: s.query, rows: s.rows, rowCount: s.rowCount })));
+    }
+    /** List the buckets you own. Requires a session token. */
+    listBuckets() {
+        return this.request("GET", "/storage/buckets").then((r) => r.buckets);
+    }
+    /** Create a bucket. Requires a session token. */
+    createBucket(name) {
+        return this.request("POST", "/storage/buckets", { name });
+    }
+    /** List files and folders in a bucket folder. Requires a session token. */
+    listObjects(bucketId, path = "") {
+        return this.request("GET", `/storage/buckets/${bucketId}/object${encodeQuery({ path })}`);
+    }
+    /** Upload a file. Requires a session token. */
+    async upload(bucketId, fileName, content, path) {
+        const form = new FormData();
+        const blob = content instanceof Blob ? content : new Blob([content]);
+        form.append("file", blob, fileName);
+        if (path)
+            form.append("path", path);
+        const res = await fetch(`${this.baseUrl}/storage/buckets/${bucketId}/object`, {
+            method: "POST",
+            headers: this.headers,
+            body: form,
+        });
+        const text = await res.text();
+        const parsed = text ? safeJson(text) : null;
+        if (!res.ok)
+            throw new KroomBaseError(res.status, parsed ?? text);
+        return parsed;
+    }
+    /** Delete an object or folder. Requires a session token. */
+    removeObject(bucketId, path) {
+        return this.request("DELETE", `/storage/buckets/${bucketId}/object${encodeQuery({ path })}`);
+    }
+    /**
+     * Fetch a file's bytes. Storage has no public URLs on purpose, so this goes through the
+     * authenticated route and hands back the bytes.
+     */
+    async download(bucketId, path) {
+        const url = `${this.baseUrl}/storage/buckets/${bucketId}/download/${path
+            .split("/")
+            .map(encodeURIComponent)
+            .join("/")}`;
+        this.onRequest?.({ method: "GET", url });
+        const res = await fetch(url, { headers: this.headers });
+        if (!res.ok)
+            throw new KroomBaseError(res.status, await res.text().catch(() => ""));
+        return res.blob();
+    }
+}
+exports.KroomBase = KroomBase;
+/**
+ * A read query. The server accepts exactly one filter per request, so chaining `where` twice
+ * keeps the last one rather than silently building something the API would reject.
+ */
+class QueryBuilder {
+    client;
+    table;
+    _columns = "*";
+    _column;
+    _op = "=";
+    _value;
+    _order;
+    _limit = 50;
+    _offset = 0;
+    constructor(client, table) {
+        this.client = client;
+        this.table = table;
+    }
+    select(columns = "*") {
+        this._columns = Array.isArray(columns) ? columns.join(",") : columns;
+        return this;
+    }
+    where(column, op, value) {
+        this._column = column;
+        this._op = op;
+        this._value = typeof value === "string" ? value.replace(/\0/g, "") : value;
+        return this;
+    }
+    order(column, direction = "asc") {
+        this._order = `${column}.${direction}`;
+        return this;
+    }
+    limit(n) {
+        this._limit = n;
+        return this;
+    }
+    offset(n) {
+        this._offset = n;
+        return this;
+    }
+    /** Run the query. */
+    async run() {
+        const path = `/rest/${encodeURIComponent(this.table)}${encodeQuery({
+            select: this._columns === "*" ? undefined : this._columns,
+            column: this._column,
+            op: this._column ? this._op : undefined,
+            value: this._value,
+            order: this._order,
+            limit: this._limit,
+            offset: this._offset,
+        })}`;
+        return this.client.request("GET", path);
+    }
+    /** So `await db.from("users").select()` works without calling `.run()`. */
+    then(onfulfilled, onrejected) {
+        return this.run().then(onfulfilled, onrejected);
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+exports.default = KroomBase;

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * KroomBase client for JavaScript and TypeScript.
+ *
+ * A thin, typed wrapper over the REST API: one method per operation, no hidden state, no
+ * retries you did not ask for. The query builder only exposes what the server actually
+ * accepts — a single filter per request, row ids as integers — so a call that compiles is a
+ * call the API will answer.
+ *
+ *   import { KroomBase } from "@kroombase/client";
+ *   const db = new KroomBase({ apiKey: "kbase_..." });
+ *   const users = await db.from("users").select().where("age", "gt", 21).limit(10);
+ */
+export interface KroomBaseOptions {
+    /** Project API key. Takes precedence over `token` when both are set. */
+    apiKey?: string;
+    /** Session token (JWT) for the SQL and storage surfaces. */
+    token?: string;
+    /** Defaults to https://kroombase.kroombox.com */
+    url?: string;
+    /** Per-request timeout in milliseconds. Defaults to 30000. */
+    timeoutMs?: number;
+    /** Receives every request and response — wire up your logger here. */
+    onRequest?: (info: {
+        method: string;
+        url: string;
+    }) => void;
+}
+export type FilterOp = "=" | "gt" | "lt" | "gte" | "lte" | "like";
+export type Row = Record<string, unknown>;
+/** Thrown for any non-2xx answer, carrying the status and the server's own error body. */
+export declare class KroomBaseError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message?: string);
+}
+export declare class KroomBase {
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly timeoutMs;
+    private readonly onRequest?;
+    constructor(options: KroomBaseOptions);
+    private request;
+    /** Start a query against one table. */
+    from(table: string): QueryBuilder;
+    /** List every table in the project's schema. */
+    listTables(): Promise<string[]>;
+    /** Insert one row and get it back. */
+    insert(table: string, data: Row): Promise<Row[]>;
+    /**
+     * Update one row by integer id and return it.
+     *
+     * Throws when nothing matched: the REST route answers `200 []` for an id that does not exist,
+     * and a write that silently did nothing is worse than an error.
+     */
+    update(table: string, id: number, data: Row): Promise<Row[]>;
+    /**
+     * Delete one row by integer id.
+     *
+     * The REST route always answers `{message:"row deleted"}`, whether or not a row matched, so
+     * this cannot tell you if anything was removed. When that matters, read the row first or use
+     * `sql()` with `DELETE ... RETURNING`.
+     */
+    delete(table: string, id: number): Promise<{
+        message: string;
+    }>;
+    /**
+     * Run raw SQL. Requires a session token: the API key is refused by this endpoint, by design.
+     * `projectId` is the full 32-character project id.
+     */
+    sql<T = Row>(projectId: string, query: string): Promise<{
+        statement: string;
+        rows?: T[];
+        rowCount: number;
+    }[]>;
+    /** List the buckets you own. Requires a session token. */
+    listBuckets(): Promise<Bucket[]>;
+    /** Create a bucket. Requires a session token. */
+    createBucket(name: string): Promise<Bucket>;
+    /** List files and folders in a bucket folder. Requires a session token. */
+    listObjects(bucketId: string, path?: string): Promise<unknown>;
+    /** Upload a file. Requires a session token. */
+    upload(bucketId: string, fileName: string, content: Blob | Uint8Array, path?: string): Promise<unknown>;
+    /** Delete an object or folder. Requires a session token. */
+    removeObject(bucketId: string, path: string): Promise<unknown>;
+    /**
+     * Fetch a file's bytes. Storage has no public URLs on purpose, so this goes through the
+     * authenticated route and hands back the bytes.
+     */
+    download(bucketId: string, path: string): Promise<Blob>;
+}
+export interface Bucket {
+    _id: string;
+    name: string;
+    files?: number;
+    folders?: number;
+    bytes?: number;
+}
+/**
+ * A read query. The server accepts exactly one filter per request, so chaining `where` twice
+ * keeps the last one rather than silently building something the API would reject.
+ */
+export declare class QueryBuilder implements PromiseLike<Row[]> {
+    private readonly client;
+    private readonly table;
+    private _columns;
+    private _column?;
+    private _op;
+    private _value?;
+    private _order?;
+    private _limit;
+    private _offset;
+    constructor(client: KroomBase, table: string);
+    select(columns?: string[] | string): this;
+    where(column: string, op: FilterOp, value: string | number): this;
+    order(column: string, direction?: "asc" | "desc"): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    /** Run the query. */
+    run(): Promise<Row[]>;
+    /** So `await db.from("users").select()` works without calling `.run()`. */
+    then<TResult1 = Row[], TResult2 = never>(onfulfilled?: ((value: Row[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+export default KroomBase;

package/dist/index.js

@@ -0,0 +1,242 @@
+/**
+ * KroomBase client for JavaScript and TypeScript.
+ *
+ * A thin, typed wrapper over the REST API: one method per operation, no hidden state, no
+ * retries you did not ask for. The query builder only exposes what the server actually
+ * accepts — a single filter per request, row ids as integers — so a call that compiles is a
+ * call the API will answer.
+ *
+ *   import { KroomBase } from "@kroombase/client";
+ *   const db = new KroomBase({ apiKey: "kbase_..." });
+ *   const users = await db.from("users").select().where("age", "gt", 21).limit(10);
+ */
+/** Thrown for any non-2xx answer, carrying the status and the server's own error body. */
+export class KroomBaseError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message || `KroomBase request failed with status ${status}`);
+        this.name = "KroomBaseError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function encodeQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        search.set(key, String(value));
+    }
+    const s = search.toString();
+    return s ? `?${s}` : "";
+}
+export class KroomBase {
+    baseUrl;
+    headers;
+    timeoutMs;
+    onRequest;
+    constructor(options) {
+        if (!options?.apiKey && !options?.token) {
+            throw new Error("KroomBase: pass either apiKey (REST + MCP database tools) or token (SQL + storage).");
+        }
+        this.baseUrl = (options.url || "https://kroombase.kroombox.com").replace(/\/+$/, "");
+        this.headers = options.apiKey
+            ? { apikey: options.apiKey }
+            : { Authorization: `Bearer ${options.token}` };
+        this.timeoutMs = options.timeoutMs ?? 30000;
+        this.onRequest = options.onRequest;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        this.onRequest?.({ method, url });
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers: body === undefined
+                    ? this.headers
+                    : { ...this.headers, "Content-Type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            const parsed = text ? safeJson(text) : null;
+            if (!res.ok) {
+                const detail = parsed && typeof parsed === "object" && "error" in parsed
+                    ? String(parsed.error)
+                    : undefined;
+                throw new KroomBaseError(res.status, parsed ?? text, detail);
+            }
+            return parsed;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Start a query against one table. */
+    from(table) {
+        return new QueryBuilder(this, table);
+    }
+    /** List every table in the project's schema. */
+    listTables() {
+        return this.request("GET", "/rest").then((rows) => rows.map((r) => r.table_name));
+    }
+    /** Insert one row and get it back. */
+    insert(table, data) {
+        return this.request("POST", `/rest/${encodeURIComponent(table)}`, data);
+    }
+    /**
+     * Update one row by integer id and return it.
+     *
+     * Throws when nothing matched: the REST route answers `200 []` for an id that does not exist,
+     * and a write that silently did nothing is worse than an error.
+     */
+    async update(table, id, data) {
+        const rows = await this.request("PUT", `/rest/${encodeURIComponent(table)}/${id}`, data);
+        if (!Array.isArray(rows) || rows.length === 0) {
+            throw new KroomBaseError(404, null, `no row with id ${id} in ${table} — nothing was updated`);
+        }
+        return rows;
+    }
+    /**
+     * Delete one row by integer id.
+     *
+     * The REST route always answers `{message:"row deleted"}`, whether or not a row matched, so
+     * this cannot tell you if anything was removed. When that matters, read the row first or use
+     * `sql()` with `DELETE ... RETURNING`.
+     */
+    delete(table, id) {
+        return this.request("DELETE", `/rest/${encodeURIComponent(table)}/${id}`);
+    }
+    /**
+     * Run raw SQL. Requires a session token: the API key is refused by this endpoint, by design.
+     * `projectId` is the full 32-character project id.
+     */
+    sql(projectId, query) {
+        return this.request("POST", "/query", {
+            projectId,
+            query,
+        }).then((r) => 
+        // `/query` answers one entry per statement under `results`, each keyed by the statement
+        // text it ran — not by an index, so the shape is normalised here.
+        (r.results || []).map((s) => ({ statement: s.query, rows: s.rows, rowCount: s.rowCount })));
+    }
+    /** List the buckets you own. Requires a session token. */
+    listBuckets() {
+        return this.request("GET", "/storage/buckets").then((r) => r.buckets);
+    }
+    /** Create a bucket. Requires a session token. */
+    createBucket(name) {
+        return this.request("POST", "/storage/buckets", { name });
+    }
+    /** List files and folders in a bucket folder. Requires a session token. */
+    listObjects(bucketId, path = "") {
+        return this.request("GET", `/storage/buckets/${bucketId}/object${encodeQuery({ path })}`);
+    }
+    /** Upload a file. Requires a session token. */
+    async upload(bucketId, fileName, content, path) {
+        const form = new FormData();
+        const blob = content instanceof Blob ? content : new Blob([content]);
+        form.append("file", blob, fileName);
+        if (path)
+            form.append("path", path);
+        const res = await fetch(`${this.baseUrl}/storage/buckets/${bucketId}/object`, {
+            method: "POST",
+            headers: this.headers,
+            body: form,
+        });
+        const text = await res.text();
+        const parsed = text ? safeJson(text) : null;
+        if (!res.ok)
+            throw new KroomBaseError(res.status, parsed ?? text);
+        return parsed;
+    }
+    /** Delete an object or folder. Requires a session token. */
+    removeObject(bucketId, path) {
+        return this.request("DELETE", `/storage/buckets/${bucketId}/object${encodeQuery({ path })}`);
+    }
+    /**
+     * Fetch a file's bytes. Storage has no public URLs on purpose, so this goes through the
+     * authenticated route and hands back the bytes.
+     */
+    async download(bucketId, path) {
+        const url = `${this.baseUrl}/storage/buckets/${bucketId}/download/${path
+            .split("/")
+            .map(encodeURIComponent)
+            .join("/")}`;
+        this.onRequest?.({ method: "GET", url });
+        const res = await fetch(url, { headers: this.headers });
+        if (!res.ok)
+            throw new KroomBaseError(res.status, await res.text().catch(() => ""));
+        return res.blob();
+    }
+}
+/**
+ * A read query. The server accepts exactly one filter per request, so chaining `where` twice
+ * keeps the last one rather than silently building something the API would reject.
+ */
+export class QueryBuilder {
+    client;
+    table;
+    _columns = "*";
+    _column;
+    _op = "=";
+    _value;
+    _order;
+    _limit = 50;
+    _offset = 0;
+    constructor(client, table) {
+        this.client = client;
+        this.table = table;
+    }
+    select(columns = "*") {
+        this._columns = Array.isArray(columns) ? columns.join(",") : columns;
+        return this;
+    }
+    where(column, op, value) {
+        this._column = column;
+        this._op = op;
+        this._value = typeof value === "string" ? value.replace(/\0/g, "") : value;
+        return this;
+    }
+    order(column, direction = "asc") {
+        this._order = `${column}.${direction}`;
+        return this;
+    }
+    limit(n) {
+        this._limit = n;
+        return this;
+    }
+    offset(n) {
+        this._offset = n;
+        return this;
+    }
+    /** Run the query. */
+    async run() {
+        const path = `/rest/${encodeURIComponent(this.table)}${encodeQuery({
+            select: this._columns === "*" ? undefined : this._columns,
+            column: this._column,
+            op: this._column ? this._op : undefined,
+            value: this._value,
+            order: this._order,
+            limit: this._limit,
+            offset: this._offset,
+        })}`;
+        return this.client.request("GET", path);
+    }
+    /** So `await db.from("users").select()` works without calling `.run()`. */
+    then(onfulfilled, onrejected) {
+        return this.run().then(onfulfilled, onrejected);
+    }
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export default KroomBase;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@kroombase/client",
+  "version": "1.0.0",
+  "description": "KroomBase client for JavaScript and TypeScript — typed access to your hosted PostgreSQL backend over REST.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "kroombase",
+    "postgres",
+    "backend",
+    "rest",
+    "database",
+    "sdk"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node build-cjs.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kroombase/kroombase-sdk.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://kroombase.kroombox.com/docs",
+  "publishConfig": {
+    "access": "public"
+  }
+}