stitchdb 1.2.0 → 1.3.0

package/dist/index.d.mts

@@ -35,49 +35,42 @@ declare class StitchDBError extends Error {
 /**
  * StitchDB client.
  *
- * Uses HTTP/2 with persistent connections (via fetch keep-alive).
- * All requests share one TCP connection — no repeated TLS handshakes.
- * Batch API sends multiple queries in one request.
+ * Uses WebSocket for queries (1 connection, unlimited queries, $0.019/M cost).
+ * Falls back to HTTP if WebSocket unavailable.
  */
 declare class StitchDB {
     private url;
+    private wsUrl;
     private apiKey;
-    private headers;
+    private ws;
+    private pending;
+    private msgId;
+    private connecting;
+    private wsSupported;
+    private wsFailed;
     constructor(config: StitchDBConfig);
-    /** Run a SQL query with parameterized bindings. */
+    private connect;
+    private wsSend;
+    private httpPost;
+    private send;
     query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Run multiple queries in a single HTTP request.
-     * All queries execute atomically. One Worker invocation for N queries.
-     */
     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>;
-    /**
-     * Insert multiple rows in a single request using batch API.
-     * One Worker invocation regardless of how many rows.
-     */
     insertMany(table: string, rows: Record<string, unknown>[]): Promise<BatchResult>;
-    /** 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;
+    close(): void;
 }
-/** 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

@@ -35,49 +35,42 @@ declare class StitchDBError extends Error {
 /**
  * StitchDB client.
  *
- * Uses HTTP/2 with persistent connections (via fetch keep-alive).
- * All requests share one TCP connection — no repeated TLS handshakes.
- * Batch API sends multiple queries in one request.
+ * Uses WebSocket for queries (1 connection, unlimited queries, $0.019/M cost).
+ * Falls back to HTTP if WebSocket unavailable.
  */
 declare class StitchDB {
     private url;
+    private wsUrl;
     private apiKey;
-    private headers;
+    private ws;
+    private pending;
+    private msgId;
+    private connecting;
+    private wsSupported;
+    private wsFailed;
     constructor(config: StitchDBConfig);
-    /** Run a SQL query with parameterized bindings. */
+    private connect;
+    private wsSend;
+    private httpPost;
+    private send;
     query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
-    /**
-     * Run multiple queries in a single HTTP request.
-     * All queries execute atomically. One Worker invocation for N queries.
-     */
     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>;
-    /**
-     * Insert multiple rows in a single request using batch API.
-     * One Worker invocation regardless of how many rows.
-     */
     insertMany(table: string, rows: Record<string, unknown>[]): Promise<BatchResult>;
-    /** 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;
+    close(): void;
 }
-/** 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

@@ -35,59 +35,147 @@ var StitchDBError = class extends Error {
 };
 var StitchDB = class {
   constructor(config) {
+    this.ws = null;
+    this.pending = /* @__PURE__ */ new Map();
+    this.msgId = 0;
+    this.connecting = null;
+    this.wsFailed = false;
     this.url = (config.url || "https://db.stitchdb.com").replace(/\/$/, "");
+    this.wsUrl = this.url.replace("https://", "wss://").replace("http://", "ws://");
     this.apiKey = config.apiKey;
-    this.headers = {
-      "Authorization": `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json"
-    };
+    this.wsSupported = typeof WebSocket !== "undefined";
+  }
+  // ---- WebSocket ----
+  async connect() {
+    if (this.ws?.readyState === 1) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = new Promise((resolve, reject) => {
+      try {
+        const ws = new WebSocket(`${this.wsUrl}/ws/query?key=${this.apiKey}`);
+        ws.onopen = () => {
+          this.ws = ws;
+          this.connecting = null;
+          resolve();
+        };
+        ws.onmessage = (e) => {
+          try {
+            const data = JSON.parse(typeof e.data === "string" ? e.data : "");
+            const p = this.pending.get(data.id);
+            if (p) {
+              this.pending.delete(data.id);
+              data.error ? p.reject(new StitchDBError(data.error)) : p.resolve(data);
+            }
+          } catch {
+          }
+        };
+        ws.onclose = () => {
+          this.ws = null;
+          this.connecting = null;
+          for (const [, p] of this.pending) p.reject(new StitchDBError("Connection closed"));
+          this.pending.clear();
+        };
+        ws.onerror = () => {
+          this.ws = null;
+          this.connecting = null;
+          this.wsFailed = true;
+          resolve();
+        };
+      } catch {
+        this.connecting = null;
+        this.wsFailed = true;
+        resolve();
+      }
+    });
+    return this.connecting;
+  }
+  async wsSend(msg) {
+    if (this.wsFailed) return this.httpPost(msg);
+    await this.connect();
+    if (!this.ws || this.ws.readyState !== 1) {
+      this.wsFailed = true;
+      return this.httpPost(msg);
+    }
+    const id = String(++this.msgId);
+    msg.id = id;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new StitchDBError("Query timeout"));
+      }, 3e4);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timeout);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        }
+      });
+      try {
+        this.ws.send(JSON.stringify(msg));
+      } catch {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        this.wsFailed = true;
+        this.httpPost(msg).then(resolve, reject);
+      }
+    });
+  }
+  // ---- HTTP fallback ----
+  async httpPost(msg) {
+    let path = "/v1/query", body = { sql: msg.sql, params: msg.params };
+    if (msg.action === "batch") {
+      path = "/v1/batch";
+      body = { queries: msg.queries };
+    } else if (msg.action === "exec") {
+      path = "/v1/exec";
+      body = { sql: msg.sql };
+    }
+    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 || `HTTP ${res.status}`, res.status);
+    return data;
+  }
+  // ---- Public API ----
+  async send(action, data) {
+    const msg = { action, ...data };
+    if (this.wsSupported && !this.wsFailed) return this.wsSend(msg);
+    return this.httpPost(msg);
   }
-  /** Run a SQL query with parameterized bindings. */
   async query(sql, params) {
-    return this.post("/v1/query", { sql, params });
+    return this.send("query", { sql, params });
   }
-  /**
-   * Run multiple queries in a single HTTP request.
-   * All queries execute atomically. One Worker invocation for N queries.
-   */
   async batch(queries) {
-    return this.post("/v1/batch", { queries });
+    return this.send("batch", { queries });
   }
-  /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
   async run(sql) {
-    return this.post("/v1/exec", { sql });
+    return this.send("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));
+    return this.query(`INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`, Object.values(data));
   }
-  /**
-   * Insert multiple rows in a single request using batch API.
-   * One Worker invocation regardless of how many rows.
-   */
   async insertMany(table, rows) {
-    if (rows.length === 0) return { results: [], meta: { rows_read: 0, rows_written: 0, duration_ms: 0, queries_count: 0 } };
+    if (!rows.length) return { results: [], meta: { rows_read: 0, rows_written: 0, duration_ms: 0, queries_count: 0 } };
     const cols = Object.keys(rows[0]);
     const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
     return this.batch(rows.map((row) => ({ sql, params: cols.map((c) => row[c]) })));
   }
-  /** 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 || []]);
+    return this.query(`UPDATE "${table}" SET ${Object.keys(data).map((c) => `"${c}" = ?`).join(", ")} 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}`;
@@ -97,19 +185,11 @@ var StitchDB = class {
     const { results } = await this.query(sql, params);
     return results;
   }
-  async post(path, body) {
-    const res = await fetch(`${this.url}${path}`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body),
-      // @ts-ignore — keepalive hint for HTTP/2 connection reuse
-      keepalive: true
-    });
-    const data = await res.json();
-    if (!res.ok || data.error) {
-      throw new StitchDBError(data.error || `Request failed: ${res.status}`, res.status);
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
     }
-    return data;
   }
 };
 function createClient(config) {

package/dist/index.mjs

@@ -8,59 +8,147 @@ var StitchDBError = class extends Error {
 };
 var StitchDB = class {
   constructor(config) {
+    this.ws = null;
+    this.pending = /* @__PURE__ */ new Map();
+    this.msgId = 0;
+    this.connecting = null;
+    this.wsFailed = false;
     this.url = (config.url || "https://db.stitchdb.com").replace(/\/$/, "");
+    this.wsUrl = this.url.replace("https://", "wss://").replace("http://", "ws://");
     this.apiKey = config.apiKey;
-    this.headers = {
-      "Authorization": `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json"
-    };
+    this.wsSupported = typeof WebSocket !== "undefined";
+  }
+  // ---- WebSocket ----
+  async connect() {
+    if (this.ws?.readyState === 1) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = new Promise((resolve, reject) => {
+      try {
+        const ws = new WebSocket(`${this.wsUrl}/ws/query?key=${this.apiKey}`);
+        ws.onopen = () => {
+          this.ws = ws;
+          this.connecting = null;
+          resolve();
+        };
+        ws.onmessage = (e) => {
+          try {
+            const data = JSON.parse(typeof e.data === "string" ? e.data : "");
+            const p = this.pending.get(data.id);
+            if (p) {
+              this.pending.delete(data.id);
+              data.error ? p.reject(new StitchDBError(data.error)) : p.resolve(data);
+            }
+          } catch {
+          }
+        };
+        ws.onclose = () => {
+          this.ws = null;
+          this.connecting = null;
+          for (const [, p] of this.pending) p.reject(new StitchDBError("Connection closed"));
+          this.pending.clear();
+        };
+        ws.onerror = () => {
+          this.ws = null;
+          this.connecting = null;
+          this.wsFailed = true;
+          resolve();
+        };
+      } catch {
+        this.connecting = null;
+        this.wsFailed = true;
+        resolve();
+      }
+    });
+    return this.connecting;
+  }
+  async wsSend(msg) {
+    if (this.wsFailed) return this.httpPost(msg);
+    await this.connect();
+    if (!this.ws || this.ws.readyState !== 1) {
+      this.wsFailed = true;
+      return this.httpPost(msg);
+    }
+    const id = String(++this.msgId);
+    msg.id = id;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new StitchDBError("Query timeout"));
+      }, 3e4);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timeout);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        }
+      });
+      try {
+        this.ws.send(JSON.stringify(msg));
+      } catch {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        this.wsFailed = true;
+        this.httpPost(msg).then(resolve, reject);
+      }
+    });
+  }
+  // ---- HTTP fallback ----
+  async httpPost(msg) {
+    let path = "/v1/query", body = { sql: msg.sql, params: msg.params };
+    if (msg.action === "batch") {
+      path = "/v1/batch";
+      body = { queries: msg.queries };
+    } else if (msg.action === "exec") {
+      path = "/v1/exec";
+      body = { sql: msg.sql };
+    }
+    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 || `HTTP ${res.status}`, res.status);
+    return data;
+  }
+  // ---- Public API ----
+  async send(action, data) {
+    const msg = { action, ...data };
+    if (this.wsSupported && !this.wsFailed) return this.wsSend(msg);
+    return this.httpPost(msg);
   }
-  /** Run a SQL query with parameterized bindings. */
   async query(sql, params) {
-    return this.post("/v1/query", { sql, params });
+    return this.send("query", { sql, params });
   }
-  /**
-   * Run multiple queries in a single HTTP request.
-   * All queries execute atomically. One Worker invocation for N queries.
-   */
   async batch(queries) {
-    return this.post("/v1/batch", { queries });
+    return this.send("batch", { queries });
   }
-  /** Run a DDL statement (CREATE TABLE, ALTER TABLE, DROP TABLE, etc.) */
   async run(sql) {
-    return this.post("/v1/exec", { sql });
+    return this.send("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));
+    return this.query(`INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`, Object.values(data));
   }
-  /**
-   * Insert multiple rows in a single request using batch API.
-   * One Worker invocation regardless of how many rows.
-   */
   async insertMany(table, rows) {
-    if (rows.length === 0) return { results: [], meta: { rows_read: 0, rows_written: 0, duration_ms: 0, queries_count: 0 } };
+    if (!rows.length) return { results: [], meta: { rows_read: 0, rows_written: 0, duration_ms: 0, queries_count: 0 } };
     const cols = Object.keys(rows[0]);
     const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
     return this.batch(rows.map((row) => ({ sql, params: cols.map((c) => row[c]) })));
   }
-  /** 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 || []]);
+    return this.query(`UPDATE "${table}" SET ${Object.keys(data).map((c) => `"${c}" = ?`).join(", ")} 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}`;
@@ -70,19 +158,11 @@ var StitchDB = class {
     const { results } = await this.query(sql, params);
     return results;
   }
-  async post(path, body) {
-    const res = await fetch(`${this.url}${path}`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body),
-      // @ts-ignore — keepalive hint for HTTP/2 connection reuse
-      keepalive: true
-    });
-    const data = await res.json();
-    if (!res.ok || data.error) {
-      throw new StitchDBError(data.error || `Request failed: ${res.status}`, res.status);
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
     }
-    return data;
   }
 };
 function createClient(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchdb",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "StitchDB client for JavaScript and TypeScript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",