reflectdb 0.1.2 → 0.2.0

package/dist/shared/{esm-z1xse19c.js → esm-5ahpq25j.js}

@@ -1,5 +1,6 @@
-// src/server/drizzle.ts
-import { createRequire } from "node:module";
+import {
+  nodeRequire
+} from "./esm-f11s9zpb.js";
 
 // src/server/factory.ts
 function getByDottedPath(root, path) {
@@ -226,12 +227,11 @@ function defineTable(adapter, opts = {}) {
 }
 
 // src/server/drizzle.ts
-var requireFn = createRequire(import.meta.url);
 var cachedDrizzle;
 function loadDrizzleSync() {
   if (cachedDrizzle === undefined) {
     try {
-      const mod = requireFn("drizzle-orm");
+      const mod = nodeRequire("drizzle-orm");
       cachedDrizzle = { eq: mod.eq, sql: mod.sql, getTableName: mod.getTableName };
     } catch {
       cachedDrizzle = null;

package/dist/shared/esm-dcs8qa5n.js

@@ -0,0 +1,263 @@
+import {
+  SyncClient,
+  pushSafely
+} from "./esm-8qbr4y0d.js";
+
+// src/vanilla/sync.ts
+function createBrowserWsTransport(url) {
+  let ws = null;
+  let handler = null;
+  let intentionalClose = false;
+  const sendQueue = [];
+  function ensureConnected() {
+    if (ws && ws.readyState !== WebSocket.CLOSED && ws.readyState !== WebSocket.CLOSING) {
+      return ws;
+    }
+    const socket = new WebSocket(url);
+    socket.onopen = () => {
+      for (const msg of sendQueue) {
+        socket.send(JSON.stringify(msg));
+      }
+      sendQueue.length = 0;
+    };
+    socket.onmessage = (event) => {
+      handler?.(JSON.parse(event.data));
+    };
+    socket.onclose = () => {
+      ws = null;
+      if (!intentionalClose) {
+        handler?.({ type: "disconnect", reason: "transport_closed" });
+      }
+    };
+    ws = socket;
+    return socket;
+  }
+  return {
+    async send(message) {
+      const socket = ensureConnected();
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify(message));
+      } else {
+        sendQueue.push(message);
+      }
+    },
+    subscribe(h) {
+      handler = h;
+    },
+    async close() {
+      intentionalClose = true;
+      if (ws) {
+        ws.close();
+        ws = null;
+      }
+    }
+  };
+}
+function createSync(config) {
+  const clientId = config.clientId ?? `browser-${crypto.randomUUID().slice(0, 8)}`;
+  const transport = createBrowserWsTransport(config.url);
+  const managedTables = new Set(config.tables ?? []);
+  const unmanagedRefCounts = new Map;
+  const unmanagedParamKeys = new Map;
+  function stableKey(obj) {
+    if (!obj)
+      return "";
+    const keys = Object.keys(obj).sort();
+    return keys.map((k) => `${k}:${JSON.stringify(obj[k])}`).join("|");
+  }
+  const client = new SyncClient({
+    clientId,
+    transport,
+    token: config.token,
+    storage: config.storage,
+    onReauth: () => config.onReauth?.() ?? Promise.reject(new Error("No onReauth handler")),
+    onError: (err) => config.onError?.(err)
+  });
+  async function connect() {
+    if (config.storage) {
+      await client.init();
+    }
+    await client.connect();
+    for (const table of managedTables) {
+      await client.sync(table);
+    }
+    await client.resume();
+  }
+  async function close() {
+    await client.close();
+  }
+  function getState() {
+    return client.getState();
+  }
+  function onStateChange(cb) {
+    let lastState = client.getState();
+    return client.subscribe(() => {
+      const current = client.getState();
+      if (current !== lastState) {
+        lastState = current;
+        cb(current);
+      }
+    });
+  }
+  function getPendingCount() {
+    return client.getPendingCount();
+  }
+  function onPendingChange(cb) {
+    let lastCount = client.getPendingCount();
+    return client.subscribe(() => {
+      const current = client.getPendingCount();
+      if (current !== lastCount) {
+        lastCount = current;
+        cb(current);
+      }
+    });
+  }
+  function sync(table, options) {
+    const isManaged = managedTables.has(table);
+    const paramKey = stableKey(options?.params);
+    if (!isManaged) {
+      const currentParamKey = unmanagedParamKeys.get(table);
+      const count = unmanagedRefCounts.get(table) ?? 0;
+      if (count === 0 || currentParamKey !== paramKey) {
+        if (currentParamKey !== undefined && currentParamKey !== paramKey) {
+          client.unsync(table);
+        }
+        client.sync(table, options?.params, options?.window ? { window: options.window } : undefined);
+        client.scheduleBootstrap();
+        unmanagedParamKeys.set(table, paramKey);
+      }
+      unmanagedRefCounts.set(table, count + 1);
+    }
+    return {
+      getRows(getOptions) {
+        return client.getRows(table, {
+          includeDeleted: getOptions?.includeDeleted ?? options?.includeDeleted
+        });
+      },
+      insert(rowId, payload) {
+        client.insert(table, rowId, payload);
+        pushSafely(client);
+      },
+      update(rowId, payload) {
+        client.update(table, rowId, payload);
+        pushSafely(client);
+      },
+      remove(rowId) {
+        client.delete(table, rowId);
+        pushSafely(client);
+      },
+      onChange(cb) {
+        return client.subscribeTable(table, cb);
+      },
+      destroy() {
+        if (isManaged)
+          return;
+        const count = (unmanagedRefCounts.get(table) ?? 1) - 1;
+        if (count <= 0) {
+          unmanagedRefCounts.delete(table);
+          unmanagedParamKeys.delete(table);
+          client.unsync(table);
+        } else {
+          unmanagedRefCounts.set(table, count);
+        }
+      }
+    };
+  }
+  function getRow(table, rowId) {
+    return client.getRow(table, rowId);
+  }
+  function onRowChange(table, rowId, cb) {
+    return client.subscribeTable(table, () => {
+      cb(client.getRow(table, rowId));
+    });
+  }
+  function ephemeral(ephConfig) {
+    let events = {};
+    const timers = new Map;
+    const changeListeners = new Set;
+    function notifyChange() {
+      for (const listener of changeListeners) {
+        listener(events);
+      }
+    }
+    const unsub = client.subscribeEphemeral(ephConfig.key, (event) => {
+      events = { ...events, [event.clientId]: event.data };
+      if (ephConfig.ttlMs) {
+        const existing = timers.get(event.clientId);
+        if (existing) {
+          clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+          const next = { ...events };
+          delete next[event.clientId];
+          events = next;
+          timers.delete(event.clientId);
+          notifyChange();
+        }, ephConfig.ttlMs);
+        timers.set(event.clientId, timer);
+      }
+      notifyChange();
+    });
+    return {
+      getEvents() {
+        return events;
+      },
+      broadcast(data) {
+        return client.sendEphemeral({
+          key: ephConfig.key,
+          userId: ephConfig.userId,
+          data,
+          ttlMs: ephConfig.ttlMs
+        });
+      },
+      onChange(cb) {
+        changeListeners.add(cb);
+        return () => {
+          changeListeners.delete(cb);
+        };
+      },
+      destroy() {
+        unsub();
+        for (const timer of timers.values()) {
+          clearTimeout(timer);
+        }
+        timers.clear();
+        changeListeners.clear();
+      }
+    };
+  }
+  function getTotalCount(table) {
+    return client.getTotalCount(table);
+  }
+  function onTotalCountChange(table, cb) {
+    let lastCount = client.getTotalCount(table);
+    return client.subscribeTable(table, () => {
+      const current = client.getTotalCount(table);
+      if (current !== lastCount) {
+        lastCount = current;
+        cb(current);
+      }
+    });
+  }
+  function loadMore(table, count) {
+    client.loadMore(table, count);
+  }
+  return {
+    client,
+    connect,
+    close,
+    getState,
+    onStateChange,
+    getPendingCount,
+    onPendingChange,
+    sync,
+    getRow,
+    onRowChange,
+    ephemeral,
+    getTotalCount,
+    onTotalCountChange,
+    loadMore
+  };
+}
+
+export { createBrowserWsTransport, createSync };

package/dist/shared/esm-f11s9zpb.js

@@ -0,0 +1,15 @@
+// src/server/node-require.ts
+var cached;
+function nodeRequire(id) {
+  if (!cached) {
+    const proc = globalThis.process;
+    const mod = proc?.getBuiltinModule?.("node:module");
+    if (!mod?.createRequire) {
+      throw new Error(`Cannot resolve "${id}": this runtime has no CommonJS resolver (process.getBuiltinModule is unavailable). reflectdb requires Node >= 22.3 or Bun >= 1.1.30 on the server.`);
+    }
+    cached = mod.createRequire(import.meta.url);
+  }
+  return cached(id);
+}
+
+export { nodeRequire };

package/dist/shared/esm-g5h4a88j.js

@@ -0,0 +1,9 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export { __require };

package/dist/shared/{esm-ck88h30s.js → esm-xtkhzxg2.js}

@@ -10,7 +10,7 @@ import {
   isErrorReason,
   reasonFromError
 } from "./esm-3tkwvysa.js";
-import"./esm-k7kedp3y.js";
+import"./esm-g5h4a88j.js";
 export {
   MAX_BATCH_SIZE,
   MAX_CLOCK_DRIFT_MS,

package/dist/svelte/index.js

@@ -4,7 +4,7 @@ import {
 } from "../shared/esm-8qbr4y0d.js";
 import"../shared/esm-rw7jjtrv.js";
 import"../shared/esm-3tkwvysa.js";
-import"../shared/esm-k7kedp3y.js";
+import"../shared/esm-g5h4a88j.js";
 
 // src/svelte/stores.ts
 function createBrowserWsTransport(url) {

package/dist/transport/bun-ws.js

@@ -1,7 +1,7 @@
 import {
   TransportSendError
 } from "../shared/esm-3tkwvysa.js";
-import"../shared/esm-k7kedp3y.js";
+import"../shared/esm-g5h4a88j.js";
 
 // src/transport/bun-ws.ts
 function trySend(clientId, ws, data, maxBufferedBytes) {

package/dist/transport/polling.js

@@ -1,7 +1,7 @@
 import {
   TransportSendError
 } from "../shared/esm-3tkwvysa.js";
-import"../shared/esm-k7kedp3y.js";
+import"../shared/esm-g5h4a88j.js";
 
 // src/transport/polling.ts
 function pollingBodyTooLarge(body, limit = 1e6) {

package/dist/transport/sse.d.ts

@@ -189,17 +189,51 @@ interface SseServerConfig {
 	* Default: 1 MB.
 	*/
 	maxMessageBytes?: number;
+	/**
+	* Return replies from the POST that produced them instead of assuming they
+	* can be streamed.
+	*
+	* Normally SSE is server→client only: a client POSTs a message and every
+	* reply — `hello_ack`, snapshots, op acks — comes back down the held stream.
+	* That works only while the POST and the stream are handled by the SAME
+	* process. On a serverless platform (Vercel, Lambda, Workers) they are two
+	* separate invocations, so those replies would be enqueued onto a stream the
+	* POST's process does not have, and the client would hang at the handshake.
+	*
+	* With this set, `collectReplies` runs a message and hands back what it
+	* produced so the HTTP handler can put it in the POST response body. The
+	* stream is then only used for what it is actually good at: pushing OTHER
+	* clients' changes. Pair it with `serverless: true` on the client transport.
+	*
+	* Off by default — a single-process server should keep streaming everything,
+	* and turning this on there would deliver each reply twice.
+	*/
+	serverless?: boolean;
 }
 declare function createSseServerTransport(cfg?: SseServerConfig): ServerTransport & {
 	handleSubscribe(clientId: string, controller: ReadableStreamDefaultController, lastEventId?: string): void;
 	handleMessage(clientId: string, message: ClientMessage): void;
 	handleDisconnect(clientId: string): void;
 	createEventStream(clientId: string, lastEventId?: string): ReadableStream;
+	collectReplies(clientId: string, message: ClientMessage, settle?: () => Promise<void>): Promise<ServerMessage[]>;
 };
 interface SseClientConfig {
 	eventUrl: string;
 	messageUrl: string;
 	headers?: Record<string, string>;
+	/**
+	* Read replies out of the POST response instead of waiting for them on the
+	* stream. Must match `serverless: true` on the server transport.
+	*
+	* Needed wherever the POST and the event stream are handled by different
+	* processes — Vercel, Lambda, Workers. There, replies to a POST are produced
+	* by a process that does not own this client's stream, so they can never be
+	* streamed and the handshake never completes.
+	*
+	* Leave it off for a single-process server: replies stream normally there,
+	* and turning it on would deliver every one of them twice.
+	*/
+	serverless?: boolean;
 }
 declare function createSseClientTransport(config: SseClientConfig): ClientTransport;
 export { SseClientConfig, SseServerConfig, createSseClientTransport, createSseServerTransport };

package/dist/transport/sse.js

@@ -1,14 +1,19 @@
 import {
   TransportSendError
 } from "../shared/esm-3tkwvysa.js";
-import"../shared/esm-k7kedp3y.js";
+import"../shared/esm-g5h4a88j.js";
 
 // src/transport/sse.ts
+var COLLECT_STABLE_TICKS = 3;
+var MAX_COLLECT_TICKS = 60;
 function createSseServerTransport(cfg = {}) {
   const controllers = new Map;
   const buffers = new Map;
   const counters = new Map;
   const replayBufferSize = cfg.replayBufferSize ?? 256;
+  const serverless = cfg.serverless ?? false;
+  const collecting = new Map;
+  const connected = new Set;
   const maxMessageBytes = cfg.maxMessageBytes ?? 1e6;
   let messageHandler = null;
   let connectHandler = null;
@@ -56,7 +61,10 @@ data: ${data}
           }
         }
       }
-      connectHandler?.(clientId, new Request("https://sse-connect"));
+      if (!connected.has(clientId)) {
+        connected.add(clientId);
+        connectHandler?.(clientId, new Request("https://sse-connect"));
+      }
     },
     handleMessage(clientId, message) {
       let byteLen;
@@ -74,6 +82,7 @@ data: ${data}
     },
     handleDisconnect(clientId) {
       controllers.delete(clientId);
+      connected.delete(clientId);
       disconnectHandler?.(clientId);
     },
     createEventStream(clientId, lastEventId) {
@@ -87,6 +96,11 @@ data: ${data}
       });
     },
     async send(clientId, message) {
+      const sink = collecting.get(clientId);
+      if (sink) {
+        sink.push(message);
+        return;
+      }
       const id = nextId(clientId);
       const encoded = encode(id, message);
       const controller = controllers.get(clientId);
@@ -108,6 +122,31 @@ data: ${data}
         throw new TransportSendError(clientId, `sse replay buffer overflow (size ${replayBufferSize}); undelivered frames dropped`);
       }
     },
+    async collectReplies(clientId, message, settle) {
+      if (!serverless) {
+        this.handleMessage(clientId, message);
+        return [];
+      }
+      if (!connected.has(clientId)) {
+        connected.add(clientId);
+        connectHandler?.(clientId, new Request("https://sse-connect"));
+      }
+      const sink = [];
+      collecting.set(clientId, sink);
+      try {
+        this.handleMessage(clientId, message);
+        await (settle?.() ?? Promise.resolve());
+        let stable = 0;
+        for (let i = 0;i < MAX_COLLECT_TICKS && stable < COLLECT_STABLE_TICKS; i++) {
+          const before = sink.length;
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          stable = sink.length === before ? stable + 1 : 0;
+        }
+      } finally {
+        collecting.delete(clientId);
+      }
+      return sink;
+    },
     async broadcast(_roomId, message, exclude) {
       for (const [clientId, controller] of controllers) {
         if (clientId === exclude)
@@ -173,6 +212,18 @@ function createSseClientTransport(config) {
       if (!res.ok) {
         throw new Error(`SSE send failed: ${res.status} ${res.statusText}`);
       }
+      if (!config.serverless)
+        return;
+      let replies;
+      try {
+        const body = await res.json();
+        replies = Array.isArray(body) ? body : body.messages ?? [];
+      } catch {
+        console.warn("[reflectdb] SSE: serverless mode is on but the POST returned no JSON replies. " + "Set `serverless: true` on createSseServerTransport and return " + "`collectReplies(...)` from the message endpoint.");
+        return;
+      }
+      for (const reply of replies)
+        handler?.(reply);
     },
     subscribe(h) {
       handler = h;

package/dist/transport/ws.js

@@ -1,7 +1,7 @@
 import {
   TransportSendError
 } from "../shared/esm-3tkwvysa.js";
-import"../shared/esm-k7kedp3y.js";
+import"../shared/esm-g5h4a88j.js";
 
 // src/transport/ws.ts
 function trySend(clientId, ws, data, maxBufferedBytes) {