@electric-sql/client 1.0.4 → 1.0.6

package/dist/index.legacy-esm.js

@@ -245,6 +245,13 @@ function isControlMessage(message) {
 function isUpToDateMessage(message) {
   return isControlMessage(message) && message.headers.control === `up-to-date`;
 }
+function getOffset(message) {
+  const lsn = message.headers.global_last_seen_lsn;
+  if (!lsn) {
+    return;
+  }
+  return `${lsn}_0`;
+}
 
 // src/constants.ts
 var LIVE_CACHE_BUSTER_HEADER = `electric-cursor`;
@@ -261,6 +268,7 @@ var TABLE_QUERY_PARAM = `table`;
 var WHERE_QUERY_PARAM = `where`;
 var REPLICA_PARAM = `replica`;
 var WHERE_PARAMS_PARAM = `params`;
+var EXPERIMENTAL_LIVE_SSE_QUERY_PARAM = `experimental_live_sse`;
 var FORCE_DISCONNECT_AND_REFRESH = `force-disconnect-and-refresh`;
 var PAUSE_STREAM = `pause-stream`;
 
@@ -289,7 +297,8 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
       try {
         const result = await fetchClient(...args);
         if (result.ok) return result;
-        else throw await FetchError.fromResponse(result, url.toString());
+        const err = await FetchError.fromResponse(result, url.toString());
+        throw err;
       } catch (e) {
         onFailedAttempt == null ? void 0 : onFailedAttempt();
         if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
@@ -487,6 +496,9 @@ function noop() {
 }
 
 // src/client.ts
+import {
+  fetchEventSource
+} from "@microsoft/fetch-event-source";
 var RESERVED_PARAMS = /* @__PURE__ */ new Set([
   LIVE_CACHE_BUSTER_QUERY_PARAM,
   SHAPE_HANDLE_QUERY_PARAM,
@@ -523,12 +535,14 @@ async function resolveHeaders(headers) {
   );
   return Object.fromEntries(resolvedEntries);
 }
-var _error, _fetchClient2, _messageParser, _subscribers, _started, _state, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _connected, _shapeHandle, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _ShapeStream_instances, start_fn, requestShape_fn, pause_fn, resume_fn, nextTick_fn, publish_fn, sendErrorToSubscribers_fn, subscribeToVisibilityChanges_fn, reset_fn;
+var _error, _fetchClient2, _sseFetchClient, _messageParser, _subscribers, _started, _state, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _connected, _shapeHandle, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _messageChain, _ShapeStream_instances, start_fn, requestShape_fn, constructUrl_fn, createAbortListener_fn, onInitialResponse_fn, onMessages_fn, fetchShape_fn, requestShapeLongPoll_fn, requestShapeSSE_fn, pause_fn, resume_fn, nextTick_fn, publish_fn, sendErrorToSubscribers_fn, subscribeToVisibilityChanges_fn, reset_fn;
 var ShapeStream = class {
+  // promise chain for incoming messages
   constructor(options) {
     __privateAdd(this, _ShapeStream_instances);
     __privateAdd(this, _error, null);
     __privateAdd(this, _fetchClient2);
+    __privateAdd(this, _sseFetchClient);
     __privateAdd(this, _messageParser);
     __privateAdd(this, _subscribers, /* @__PURE__ */ new Map());
     __privateAdd(this, _started, false);
@@ -548,6 +562,7 @@ var ShapeStream = class {
     __privateAdd(this, _tickPromise);
     __privateAdd(this, _tickPromiseResolver);
     __privateAdd(this, _tickPromiseRejecter);
+    __privateAdd(this, _messageChain, Promise.resolve([]));
     var _a, _b, _c;
     this.options = __spreadValues({ subscribe: true }, options);
     validateOptions(this.options);
@@ -557,18 +572,21 @@ var ShapeStream = class {
     __privateSet(this, _messageParser, new MessageParser(options.parser));
     __privateSet(this, _onError, this.options.onError);
     const baseFetchClient = (_b = options.fetchClient) != null ? _b : (...args) => fetch(...args);
-    const fetchWithBackoffClient = createFetchWithBackoff(baseFetchClient, __spreadProps(__spreadValues({}, (_c = options.backoffOptions) != null ? _c : BackoffDefaults), {
+    const backOffOpts = __spreadProps(__spreadValues({}, (_c = options.backoffOptions) != null ? _c : BackoffDefaults), {
       onFailedAttempt: () => {
         var _a2, _b2;
         __privateSet(this, _connected, false);
         (_b2 = (_a2 = options.backoffOptions) == null ? void 0 : _a2.onFailedAttempt) == null ? void 0 : _b2.call(_a2);
       }
-    }));
-    __privateSet(this, _fetchClient2, createFetchWithConsumedMessages(
-      createFetchWithResponseHeadersCheck(
-        createFetchWithChunkBuffer(fetchWithBackoffClient)
-      )
+    });
+    const fetchWithBackoffClient = createFetchWithBackoff(
+      baseFetchClient,
+      backOffOpts
+    );
+    __privateSet(this, _sseFetchClient, createFetchWithResponseHeadersCheck(
+      createFetchWithChunkBuffer(fetchWithBackoffClient)
     ));
+    __privateSet(this, _fetchClient2, createFetchWithConsumedMessages(__privateGet(this, _sseFetchClient)));
     __privateMethod(this, _ShapeStream_instances, subscribeToVisibilityChanges_fn).call(this);
   }
   get shapeHandle() {
@@ -636,6 +654,7 @@ var ShapeStream = class {
 };
 _error = new WeakMap();
 _fetchClient2 = new WeakMap();
+_sseFetchClient = new WeakMap();
 _messageParser = new WeakMap();
 _subscribers = new WeakMap();
 _started = new WeakMap();
@@ -653,6 +672,7 @@ _isRefreshing = new WeakMap();
 _tickPromise = new WeakMap();
 _tickPromiseResolver = new WeakMap();
 _tickPromiseRejecter = new WeakMap();
+_messageChain = new WeakMap();
 _ShapeStream_instances = new WeakSet();
 start_fn = async function() {
   var _a;
@@ -683,7 +703,7 @@ start_fn = async function() {
   }
 };
 requestShape_fn = async function() {
-  var _a, _b, _c, _d;
+  var _a, _b;
   if (__privateGet(this, _state) === `pause-requested`) {
     __privateSet(this, _state, `paused`);
     return;
@@ -694,6 +714,46 @@ requestShape_fn = async function() {
   const resumingFromPause = __privateGet(this, _state) === `paused`;
   __privateSet(this, _state, `active`);
   const { url, signal } = this.options;
+  const { fetchUrl, requestHeaders } = await __privateMethod(this, _ShapeStream_instances, constructUrl_fn).call(this, url, resumingFromPause);
+  const abortListener = await __privateMethod(this, _ShapeStream_instances, createAbortListener_fn).call(this, signal);
+  const requestAbortController = __privateGet(this, _requestAbortController);
+  try {
+    await __privateMethod(this, _ShapeStream_instances, fetchShape_fn).call(this, {
+      fetchUrl,
+      requestAbortController,
+      headers: requestHeaders,
+      resumingFromPause
+    });
+  } catch (e) {
+    if ((e instanceof FetchError || e instanceof FetchBackoffAbortError) && requestAbortController.signal.aborted && requestAbortController.signal.reason === FORCE_DISCONNECT_AND_REFRESH) {
+      return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+    }
+    if (e instanceof FetchBackoffAbortError) {
+      if (requestAbortController.signal.aborted && requestAbortController.signal.reason === PAUSE_STREAM) {
+        __privateSet(this, _state, `paused`);
+      }
+      return;
+    }
+    if (!(e instanceof FetchError)) throw e;
+    if (e.status == 409) {
+      const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER];
+      __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
+      await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
+      return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+    } else {
+      __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
+      throw e;
+    }
+  } finally {
+    if (abortListener && signal) {
+      signal.removeEventListener(`abort`, abortListener);
+    }
+    __privateSet(this, _requestAbortController, void 0);
+  }
+  (_b = __privateGet(this, _tickPromiseResolver)) == null ? void 0 : _b.call(this);
+  return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+};
+constructUrl_fn = async function(url, resumingFromPause) {
   const [requestHeaders, params] = await Promise.all([
     resolveHeaders(this.options.headers),
     this.options.params ? toInternalParams(convertWhereParamsToObj(this.options.params)) : void 0
@@ -734,51 +794,28 @@ requestShape_fn = async function() {
     fetchUrl.searchParams.set(SHAPE_HANDLE_QUERY_PARAM, __privateGet(this, _shapeHandle));
   }
   fetchUrl.searchParams.sort();
+  return {
+    fetchUrl,
+    requestHeaders
+  };
+};
+createAbortListener_fn = async function(signal) {
+  var _a;
   __privateSet(this, _requestAbortController, new AbortController());
-  let abortListener;
   if (signal) {
-    abortListener = () => {
+    const abortListener = () => {
       var _a2;
       (_a2 = __privateGet(this, _requestAbortController)) == null ? void 0 : _a2.abort(signal.reason);
     };
     signal.addEventListener(`abort`, abortListener, { once: true });
     if (signal.aborted) {
-      (_b = __privateGet(this, _requestAbortController)) == null ? void 0 : _b.abort(signal.reason);
+      (_a = __privateGet(this, _requestAbortController)) == null ? void 0 : _a.abort(signal.reason);
     }
+    return abortListener;
   }
-  let response;
-  try {
-    response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
-      signal: __privateGet(this, _requestAbortController).signal,
-      headers: requestHeaders
-    });
-    __privateSet(this, _connected, true);
-  } catch (e) {
-    if ((e instanceof FetchError || e instanceof FetchBackoffAbortError) && __privateGet(this, _requestAbortController).signal.aborted && __privateGet(this, _requestAbortController).signal.reason === FORCE_DISCONNECT_AND_REFRESH) {
-      return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
-    }
-    if (e instanceof FetchBackoffAbortError) {
-      if (__privateGet(this, _requestAbortController).signal.aborted && __privateGet(this, _requestAbortController).signal.reason === PAUSE_STREAM) {
-        __privateSet(this, _state, `paused`);
-      }
-      return;
-    }
-    if (!(e instanceof FetchError)) throw e;
-    if (e.status == 409) {
-      const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER];
-      __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
-      await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
-      return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
-    } else {
-      __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
-      throw e;
-    }
-  } finally {
-    if (abortListener && signal) {
-      signal.removeEventListener(`abort`, abortListener);
-    }
-    __privateSet(this, _requestAbortController, void 0);
-  }
+};
+onInitialResponse_fn = async function(response) {
+  var _a;
   const { headers, status } = response;
   const shapeHandle = headers.get(SHAPE_HANDLE_HEADER);
   if (shapeHandle) {
@@ -796,22 +833,85 @@ requestShape_fn = async function() {
     const schemaHeader = headers.get(SHAPE_SCHEMA_HEADER);
     return schemaHeader ? JSON.parse(schemaHeader) : {};
   };
-  __privateSet(this, _schema, (_c = __privateGet(this, _schema)) != null ? _c : getSchema());
+  __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchema());
   if (status === 204) {
     __privateSet(this, _lastSyncedAt, Date.now());
   }
-  const messages = await response.text() || `[]`;
-  const batch = __privateGet(this, _messageParser).parse(messages, __privateGet(this, _schema));
+};
+onMessages_fn = async function(batch, isSseMessage = false) {
   if (batch.length > 0) {
     const lastMessage = batch[batch.length - 1];
     if (isUpToDateMessage(lastMessage)) {
+      if (isSseMessage) {
+        const offset = getOffset(lastMessage);
+        if (offset) {
+          __privateSet(this, _lastOffset, offset);
+        }
+      }
       __privateSet(this, _lastSyncedAt, Date.now());
       __privateSet(this, _isUpToDate, true);
     }
     await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, batch);
   }
-  (_d = __privateGet(this, _tickPromiseResolver)) == null ? void 0 : _d.call(this);
-  return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+};
+fetchShape_fn = async function(opts) {
+  if (__privateGet(this, _isUpToDate) && this.options.experimentalLiveSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause) {
+    opts.fetchUrl.searchParams.set(EXPERIMENTAL_LIVE_SSE_QUERY_PARAM, `true`);
+    return __privateMethod(this, _ShapeStream_instances, requestShapeSSE_fn).call(this, opts);
+  }
+  return __privateMethod(this, _ShapeStream_instances, requestShapeLongPoll_fn).call(this, opts);
+};
+requestShapeLongPoll_fn = async function(opts) {
+  const { fetchUrl, requestAbortController, headers } = opts;
+  const response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
+    signal: requestAbortController.signal,
+    headers
+  });
+  __privateSet(this, _connected, true);
+  await __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+  const schema = __privateGet(this, _schema);
+  const res = await response.text();
+  const messages = res || `[]`;
+  const batch = __privateGet(this, _messageParser).parse(messages, schema);
+  await __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, batch);
+};
+requestShapeSSE_fn = async function(opts) {
+  const { fetchUrl, requestAbortController, headers } = opts;
+  const fetch2 = __privateGet(this, _sseFetchClient);
+  try {
+    let buffer = [];
+    await fetchEventSource(fetchUrl.toString(), {
+      headers,
+      fetch: fetch2,
+      onopen: async (response) => {
+        __privateSet(this, _connected, true);
+        await __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+      },
+      onmessage: (event) => {
+        if (event.data) {
+          const schema = __privateGet(this, _schema);
+          const message = __privateGet(this, _messageParser).parse(
+            event.data,
+            schema
+          );
+          buffer.push(message);
+          if (isUpToDateMessage(message)) {
+            __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, buffer, true);
+            buffer = [];
+          }
+        }
+      },
+      onerror: (error) => {
+        throw error;
+      },
+      signal: requestAbortController.signal
+    });
+  } catch (error) {
+    if (requestAbortController.signal.aborted) {
+      throw new FetchBackoffAbortError();
+    }
+    throw error;
+  }
 };
 pause_fn = function() {
   var _a;
@@ -841,17 +941,20 @@ nextTick_fn = async function() {
   return __privateGet(this, _tickPromise);
 };
 publish_fn = async function(messages) {
-  await Promise.all(
-    Array.from(__privateGet(this, _subscribers).values()).map(async ([callback, __]) => {
-      try {
-        await callback(messages);
-      } catch (err) {
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-    })
-  );
+  __privateSet(this, _messageChain, __privateGet(this, _messageChain).then(
+    () => Promise.all(
+      Array.from(__privateGet(this, _subscribers).values()).map(async ([callback, __]) => {
+        try {
+          await callback(messages);
+        } catch (err) {
+          queueMicrotask(() => {
+            throw err;
+          });
+        }
+      })
+    )
+  ));
+  return __privateGet(this, _messageChain);
 };
 sendErrorToSubscribers_fn = function(error) {
   __privateGet(this, _subscribers).forEach(([_, errorFn]) => {