@delali/sirannon-db 0.1.1

package/dist/client/index.mjs

@@ -0,0 +1,479 @@
+// src/client/subscription.ts
+var RemoteSubscriptionBuilderImpl = class {
+  constructor(table, transport) {
+    this.table = table;
+    this.transport = transport;
+  }
+  conditions = {};
+  filter(conditions) {
+    this.conditions = { ...this.conditions, ...conditions };
+    return this;
+  }
+  subscribe(callback) {
+    const filter = Object.keys(this.conditions).length > 0 ? this.conditions : void 0;
+    return this.transport.subscribe(this.table, filter, callback);
+  }
+};
+
+// src/client/database-proxy.ts
+var RemoteDatabase = class {
+  constructor(id, transport, onDispose) {
+    this.id = id;
+    this.transport = transport;
+    this.onDispose = onDispose;
+  }
+  /**
+   * Execute a SELECT and return all matching rows.
+   *
+   * ```ts
+   * const users = await db.query<{ id: number; name: string }>(
+   *   'SELECT * FROM users WHERE age > ?',
+   *   [21],
+   * )
+   * ```
+   */
+  async query(sql, params) {
+    const response = await this.transport.query(sql, params);
+    return response.rows;
+  }
+  /**
+   * Execute a mutation (INSERT, UPDATE, DELETE) and return
+   * the number of affected rows and last insert row ID.
+   */
+  async execute(sql, params) {
+    return this.transport.execute(sql, params);
+  }
+  /**
+   * Execute multiple statements as a single atomic transaction.
+   * Returns an array of results, one per statement.
+   *
+   * Requires HTTP transport. WebSocket transport does not
+   * support server-side transactions.
+   */
+  async transaction(statements) {
+    const response = await this.transport.transaction(statements);
+    return response.results;
+  }
+  /**
+   * Start building a CDC subscription for the given table.
+   * Chain `.filter()` to narrow the events, then call `.subscribe()`
+   * with a callback to begin receiving real-time change events.
+   *
+   * ```ts
+   * const sub = await db
+   *   .on('orders')
+   *   .filter({ status: 'pending' })
+   *   .subscribe(event => console.log(event))
+   *
+   * // Later:
+   * sub.unsubscribe()
+   * ```
+   */
+  on(table) {
+    return new RemoteSubscriptionBuilderImpl(table, this.transport);
+  }
+  /**
+   * Close the transport for this database. After calling `close()`,
+   * all pending requests are rejected and new calls will throw.
+   */
+  close() {
+    this.transport.close();
+    this.onDispose?.();
+  }
+};
+
+// src/client/types.ts
+var RemoteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RemoteError";
+    this.code = code;
+  }
+};
+
+// src/client/transport/http.ts
+var HttpTransport = class {
+  baseUrl;
+  headers;
+  closed = false;
+  constructor(baseUrl, headers) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.headers = {
+      "content-type": "application/json",
+      ...headers
+    };
+  }
+  async query(sql, params) {
+    return this.post("/query", { sql, params });
+  }
+  async execute(sql, params) {
+    return this.post("/execute", { sql, params });
+  }
+  async transaction(statements) {
+    return this.post("/transaction", { statements });
+  }
+  async subscribe(_table, _filter, _callback) {
+    throw new RemoteError(
+      "TRANSPORT_ERROR",
+      'Subscriptions require WebSocket transport. Create the client with { transport: "websocket" } to use real-time subscriptions.'
+    );
+  }
+  close() {
+    this.closed = true;
+  }
+  async post(path, body) {
+    if (this.closed) {
+      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+    }
+    const url = `${this.baseUrl}${path}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new RemoteError(
+        "CONNECTION_ERROR",
+        `Failed to connect to ${url}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new RemoteError("INVALID_RESPONSE", `Server returned non-JSON response (HTTP ${response.status})`);
+    }
+    if (!response.ok) {
+      const errorData = data;
+      throw new RemoteError(
+        errorData.error?.code ?? "UNKNOWN_ERROR",
+        errorData.error?.message ?? `HTTP ${response.status}`
+      );
+    }
+    return data;
+  }
+};
+
+// src/client/transport/ws.ts
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var WebSocketTransport = class {
+  ws = null;
+  url;
+  autoReconnect;
+  reconnectInterval;
+  requestTimeout;
+  pendingRequests = /* @__PURE__ */ new Map();
+  activeSubscriptions = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  closed = false;
+  connectPromise = null;
+  reconnectTimer = null;
+  constructor(url, options) {
+    this.url = url;
+    this.autoReconnect = options?.autoReconnect ?? true;
+    this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+    this.requestTimeout = options?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+  }
+  async query(sql, params) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({ type: "query", id, sql, params });
+  }
+  async execute(sql, params) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({ type: "execute", id, sql, params });
+  }
+  async transaction(_statements) {
+    throw new RemoteError(
+      "TRANSPORT_ERROR",
+      "Transactions are not supported over WebSocket. Use HTTP transport for batch transactions."
+    );
+  }
+  async subscribe(table, filter, callback) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    this.activeSubscriptions.set(id, { table, filter, callback });
+    try {
+      const msg = {
+        type: "subscribe",
+        id,
+        table,
+        ...filter ? { filter } : {}
+      };
+      await this.request(msg);
+    } catch (err) {
+      this.activeSubscriptions.delete(id);
+      throw err;
+    }
+    return {
+      unsubscribe: () => {
+        this.activeSubscriptions.delete(id);
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify({ type: "unsubscribe", id }));
+        }
+      }
+    };
+  }
+  close() {
+    this.closed = true;
+    this.cancelReconnect();
+    this.rejectAllPending(new RemoteError("TRANSPORT_ERROR", "Transport closed"));
+    this.activeSubscriptions.clear();
+    if (this.ws) {
+      this.ws.close(1e3, "Client closed");
+      this.ws = null;
+    }
+    this.connectPromise = null;
+  }
+  nextId() {
+    return `c_${++this.idCounter}_${Date.now()}`;
+  }
+  async ensureConnected() {
+    if (this.closed) {
+      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+    }
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    if (!this.connectPromise) {
+      this.connectPromise = this.connect().finally(() => {
+        this.connectPromise = null;
+      });
+    }
+    return this.connectPromise;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const ws = new WebSocket(this.url);
+      const onOpen = () => {
+        settled = true;
+        this.ws = ws;
+        resolve();
+      };
+      const onError = () => {
+        if (!settled) {
+          settled = true;
+          reject(new RemoteError("CONNECTION_ERROR", `Failed to connect to ${this.url}`));
+        }
+      };
+      const onClose = (event) => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        if (!settled) {
+          settled = true;
+          reject(
+            new RemoteError("CONNECTION_ERROR", `Connection closed during handshake: ${event.code} ${event.reason}`)
+          );
+          return;
+        }
+        this.ws = null;
+        this.handleDisconnect();
+      };
+      const onMessage = (event) => {
+        this.handleMessage(String(event.data));
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("close", onClose);
+      ws.addEventListener("message", onMessage);
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "result": {
+        const pending = this.pendingRequests.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(msg.id);
+          pending.resolve(msg.data);
+        }
+        break;
+      }
+      case "subscribed": {
+        const pending = this.pendingRequests.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(msg.id);
+          pending.resolve(void 0);
+        }
+        break;
+      }
+      case "error": {
+        const pending = this.pendingRequests.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(msg.id);
+          pending.reject(new RemoteError(msg.error.code, msg.error.message));
+        }
+        break;
+      }
+      case "change": {
+        const sub = this.activeSubscriptions.get(msg.id);
+        if (sub) {
+          try {
+            const event = {
+              type: msg.event.type,
+              table: msg.event.table,
+              row: msg.event.row,
+              oldRow: msg.event.oldRow,
+              seq: BigInt(msg.event.seq),
+              timestamp: msg.event.timestamp
+            };
+            sub.callback(event);
+          } catch {
+          }
+        }
+        break;
+      }
+    }
+  }
+  handleDisconnect() {
+    this.rejectAllPending(new RemoteError("CONNECTION_ERROR", "WebSocket disconnected"));
+    if (this.autoReconnect && !this.closed && this.activeSubscriptions.size > 0) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer !== null || this.closed) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.closed) return;
+      try {
+        await this.ensureConnected();
+        await this.resubscribeAll();
+      } catch {
+        if (!this.closed && this.activeSubscriptions.size > 0) {
+          this.scheduleReconnect();
+        }
+      }
+    }, this.reconnectInterval);
+  }
+  async resubscribeAll() {
+    const entries = [...this.activeSubscriptions.entries()];
+    for (const [id, sub] of entries) {
+      if (this.closed) break;
+      try {
+        const msg = {
+          type: "subscribe",
+          id,
+          table: sub.table,
+          ...sub.filter ? { filter: sub.filter } : {}
+        };
+        await this.request(msg);
+      } catch {
+        this.activeSubscriptions.delete(id);
+      }
+    }
+  }
+  request(msg) {
+    return new Promise((resolve, reject) => {
+      const { id } = msg;
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new RemoteError("CONNECTION_ERROR", "WebSocket is not connected"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new RemoteError("TIMEOUT", `Request timed out after ${this.requestTimeout}ms`));
+      }, this.requestTimeout);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.ws.send(JSON.stringify(msg));
+    });
+  }
+  rejectAllPending(error) {
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  cancelReconnect() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/client/client.ts
+var SirannonClient = class {
+  baseUrl;
+  wsBaseUrl;
+  transport;
+  headers;
+  autoReconnect;
+  reconnectInterval;
+  databases = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(url, options) {
+    this.baseUrl = url.replace(/\/$/, "");
+    this.wsBaseUrl = this.baseUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://");
+    this.transport = options?.transport ?? "websocket";
+    this.headers = options?.headers;
+    this.autoReconnect = options?.autoReconnect ?? true;
+    this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+  }
+  /**
+   * Get a {@link RemoteDatabase} proxy for the given database ID.
+   * Returns a cached instance if one already exists for this ID.
+   *
+   * The underlying transport connection is established lazily on
+   * the first operation (query, execute, or subscribe).
+   */
+  database(id) {
+    if (this.closed) {
+      throw new Error("Client is closed");
+    }
+    const existing = this.databases.get(id);
+    if (existing) {
+      return existing;
+    }
+    const transport = this.createTransport(id);
+    const db = new RemoteDatabase(id, transport, () => {
+      this.databases.delete(id);
+    });
+    this.databases.set(id, db);
+    return db;
+  }
+  /**
+   * Close all database connections and release resources.
+   * After calling `close()`, new calls to `database()` will throw.
+   */
+  close() {
+    this.closed = true;
+    const openDatabases = [...this.databases.values()];
+    this.databases.clear();
+    for (const db of openDatabases) {
+      db.close();
+    }
+  }
+  createTransport(databaseId) {
+    const encodedId = encodeURIComponent(databaseId);
+    if (this.transport === "http") {
+      return new HttpTransport(`${this.baseUrl}/db/${encodedId}`, this.headers);
+    }
+    return new WebSocketTransport(`${this.wsBaseUrl}/db/${encodedId}`, {
+      autoReconnect: this.autoReconnect,
+      reconnectInterval: this.reconnectInterval
+    });
+  }
+};
+
+export { HttpTransport, RemoteDatabase, RemoteError, RemoteSubscriptionBuilderImpl, SirannonClient, WebSocketTransport };