stitchdb 1.0.0

package/README.md

@@ -0,0 +1,42 @@
+# StitchDB
+
+## Install
+
+```bash
+npm install stitchdb
+```
+
+## Setup
+
+```ts
+import { createClient } from 'stitchdb'
+
+const db = createClient({
+  apiKey: process.env.STITCHDB_API_KEY,
+})
+```
+
+## Query
+
+```ts
+// Raw SQL with parameters
+const { results } = await db.query('SELECT * FROM users WHERE active = ?', [1])
+
+// Shorthands
+await db.insert('users', { name: 'Alice', email: 'alice@example.com' })
+await db.update('users', { active: false }, 'id = ?', [5])
+await db.remove('users', 'id = ?', [5])
+const user = await db.find('users', 1)
+const users = await db.select('users', 'active = ?', [1], { orderBy: 'created_at DESC', limit: 20 })
+
+// DDL
+await db.run('CREATE TABLE IF NOT EXISTS posts (id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT)')
+
+// Batch (atomic)
+await db.batch([
+  { sql: 'INSERT INTO users (name) VALUES (?)', params: ['Alice'] },
+  { sql: 'INSERT INTO users (name) VALUES (?)', params: ['Bob'] },
+])
+```
+
+Works with Node.js, Bun, Deno, Next.js, Nuxt, SvelteKit, Remix, Astro, and any runtime that supports `fetch`.

package/dist/index.d.mts

@@ -0,0 +1,67 @@
+interface StitchDBConfig {
+    url?: string;
+    apiKey: string;
+}
+interface QueryResult<T = Record<string, unknown>> {
+    results: T[];
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        last_row_id?: number | null;
+        duration_ms: number;
+        cached?: boolean;
+    };
+}
+interface BatchResult {
+    results: Record<string, unknown>[][];
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        duration_ms: number;
+        queries_count: number;
+    };
+}
+interface ExecResult {
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        duration_ms: number;
+    };
+}
+declare class StitchDBError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+declare class StitchDB {
+    private url;
+    private apiKey;
+    constructor(config: StitchDBConfig);
+    /** Run a SQL query with parameterized bindings. */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /** Run multiple queries atomically in a single batch. */
+    batch(queries: {
+        sql: string;
+        params?: unknown[];
+    }[]): Promise<BatchResult>;
+    /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
+    run(sql: string): Promise<ExecResult>;
+    /** Insert a row. */
+    insert(table: string, data: Record<string, unknown>): Promise<QueryResult>;
+    /** Update rows matching a WHERE clause. */
+    update(table: string, data: Record<string, unknown>, where: string, whereParams?: unknown[]): Promise<QueryResult>;
+    /** Delete rows matching a WHERE clause. */
+    remove(table: string, where: string, whereParams?: unknown[]): Promise<QueryResult>;
+    /** Find one row by ID. */
+    find<T = Record<string, unknown>>(table: string, id: unknown, idColumn?: string): Promise<T | null>;
+    /** Select rows with optional WHERE, ORDER BY, LIMIT, OFFSET. */
+    select<T = Record<string, unknown>>(table: string, where?: string, params?: unknown[], opts?: {
+        orderBy?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<T[]>;
+    private post;
+}
+/** Create a StitchDB client. */
+declare function createClient(config: StitchDBConfig): StitchDB;
+
+export { type BatchResult, type ExecResult, type QueryResult, StitchDB, type StitchDBConfig, StitchDBError, createClient, StitchDB as default };

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+interface StitchDBConfig {
+    url?: string;
+    apiKey: string;
+}
+interface QueryResult<T = Record<string, unknown>> {
+    results: T[];
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        last_row_id?: number | null;
+        duration_ms: number;
+        cached?: boolean;
+    };
+}
+interface BatchResult {
+    results: Record<string, unknown>[][];
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        duration_ms: number;
+        queries_count: number;
+    };
+}
+interface ExecResult {
+    meta: {
+        rows_read: number;
+        rows_written: number;
+        duration_ms: number;
+    };
+}
+declare class StitchDBError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+declare class StitchDB {
+    private url;
+    private apiKey;
+    constructor(config: StitchDBConfig);
+    /** Run a SQL query with parameterized bindings. */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /** Run multiple queries atomically in a single batch. */
+    batch(queries: {
+        sql: string;
+        params?: unknown[];
+    }[]): Promise<BatchResult>;
+    /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
+    run(sql: string): Promise<ExecResult>;
+    /** Insert a row. */
+    insert(table: string, data: Record<string, unknown>): Promise<QueryResult>;
+    /** Update rows matching a WHERE clause. */
+    update(table: string, data: Record<string, unknown>, where: string, whereParams?: unknown[]): Promise<QueryResult>;
+    /** Delete rows matching a WHERE clause. */
+    remove(table: string, where: string, whereParams?: unknown[]): Promise<QueryResult>;
+    /** Find one row by ID. */
+    find<T = Record<string, unknown>>(table: string, id: unknown, idColumn?: string): Promise<T | null>;
+    /** Select rows with optional WHERE, ORDER BY, LIMIT, OFFSET. */
+    select<T = Record<string, unknown>>(table: string, where?: string, params?: unknown[], opts?: {
+        orderBy?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<T[]>;
+    private post;
+}
+/** Create a StitchDB client. */
+declare function createClient(config: StitchDBConfig): StitchDB;
+
+export { type BatchResult, type ExecResult, type QueryResult, StitchDB, type StitchDBConfig, StitchDBError, createClient, StitchDB as default };

package/dist/index.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StitchDB: () => StitchDB,
+  StitchDBError: () => StitchDBError,
+  createClient: () => createClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var StitchDBError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "StitchDBError";
+    this.status = status;
+  }
+};
+var StitchDB = class {
+  constructor(config) {
+    this.url = (config.url || "https://db.stitchdb.com").replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+  }
+  /** Run a SQL query with parameterized bindings. */
+  async query(sql, params) {
+    return this.post("/v1/query", { sql, params });
+  }
+  /** Run multiple queries atomically in a single batch. */
+  async batch(queries) {
+    return this.post("/v1/batch", { queries });
+  }
+  /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
+  async run(sql) {
+    return this.post("/v1/exec", { sql });
+  }
+  /** Insert a row. */
+  async insert(table, data) {
+    const cols = Object.keys(data);
+    const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
+    return this.query(sql, Object.values(data));
+  }
+  /** Update rows matching a WHERE clause. */
+  async update(table, data, where, whereParams) {
+    const set = Object.keys(data).map((c) => `"${c}" = ?`).join(", ");
+    return this.query(`UPDATE "${table}" SET ${set} WHERE ${where}`, [...Object.values(data), ...whereParams || []]);
+  }
+  /** Delete rows matching a WHERE clause. */
+  async remove(table, where, whereParams) {
+    return this.query(`DELETE FROM "${table}" WHERE ${where}`, whereParams);
+  }
+  /** Find one row by ID. */
+  async find(table, id, idColumn = "id") {
+    const { results } = await this.query(`SELECT * FROM "${table}" WHERE "${idColumn}" = ? LIMIT 1`, [id]);
+    return results[0] || null;
+  }
+  /** Select rows with optional WHERE, ORDER BY, LIMIT, OFFSET. */
+  async select(table, where, params, opts) {
+    let sql = `SELECT * FROM "${table}"`;
+    if (where) sql += ` WHERE ${where}`;
+    if (opts?.orderBy) sql += ` ORDER BY ${opts.orderBy}`;
+    if (opts?.limit) sql += ` LIMIT ${opts.limit}`;
+    if (opts?.offset) sql += ` OFFSET ${opts.offset}`;
+    const { results } = await this.query(sql, params);
+    return results;
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.url}${path}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    if (!res.ok || data.error) {
+      throw new StitchDBError(data.error || `Request failed: ${res.status}`, res.status);
+    }
+    return data;
+  }
+};
+function createClient(config) {
+  return new StitchDB(config);
+}
+var index_default = StitchDB;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StitchDB,
+  StitchDBError,
+  createClient
+});

package/dist/index.mjs

@@ -0,0 +1,81 @@
+// src/index.ts
+var StitchDBError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "StitchDBError";
+    this.status = status;
+  }
+};
+var StitchDB = class {
+  constructor(config) {
+    this.url = (config.url || "https://db.stitchdb.com").replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+  }
+  /** Run a SQL query with parameterized bindings. */
+  async query(sql, params) {
+    return this.post("/v1/query", { sql, params });
+  }
+  /** Run multiple queries atomically in a single batch. */
+  async batch(queries) {
+    return this.post("/v1/batch", { queries });
+  }
+  /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
+  async run(sql) {
+    return this.post("/v1/exec", { sql });
+  }
+  /** Insert a row. */
+  async insert(table, data) {
+    const cols = Object.keys(data);
+    const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
+    return this.query(sql, Object.values(data));
+  }
+  /** Update rows matching a WHERE clause. */
+  async update(table, data, where, whereParams) {
+    const set = Object.keys(data).map((c) => `"${c}" = ?`).join(", ");
+    return this.query(`UPDATE "${table}" SET ${set} WHERE ${where}`, [...Object.values(data), ...whereParams || []]);
+  }
+  /** Delete rows matching a WHERE clause. */
+  async remove(table, where, whereParams) {
+    return this.query(`DELETE FROM "${table}" WHERE ${where}`, whereParams);
+  }
+  /** Find one row by ID. */
+  async find(table, id, idColumn = "id") {
+    const { results } = await this.query(`SELECT * FROM "${table}" WHERE "${idColumn}" = ? LIMIT 1`, [id]);
+    return results[0] || null;
+  }
+  /** Select rows with optional WHERE, ORDER BY, LIMIT, OFFSET. */
+  async select(table, where, params, opts) {
+    let sql = `SELECT * FROM "${table}"`;
+    if (where) sql += ` WHERE ${where}`;
+    if (opts?.orderBy) sql += ` ORDER BY ${opts.orderBy}`;
+    if (opts?.limit) sql += ` LIMIT ${opts.limit}`;
+    if (opts?.offset) sql += ` OFFSET ${opts.offset}`;
+    const { results } = await this.query(sql, params);
+    return results;
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.url}${path}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await res.json();
+    if (!res.ok || data.error) {
+      throw new StitchDBError(data.error || `Request failed: ${res.status}`, res.status);
+    }
+    return data;
+  }
+};
+function createClient(config) {
+  return new StitchDB(config);
+}
+var index_default = StitchDB;
+export {
+  StitchDB,
+  StitchDBError,
+  createClient,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "stitchdb",
+  "version": "1.0.0",
+  "description": "StitchDB client for JavaScript and TypeScript",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["stitchdb", "database", "sql", "edge", "serverless"],
+  "license": "MIT",
+  "author": {
+    "name": "StitchDB",
+    "email": "support@stitchdb.com",
+    "url": "https://stitchdb.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stitchdb/js.git"
+  },
+  "homepage": "https://stitchdb.com/docs",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}