@electric-sql/client 1.5.3 → 1.5.5

package/dist/cjs/index.cjs

@@ -463,10 +463,10 @@ function snakeCamelMapper(schema) {
 
 // src/helpers.ts
 function isChangeMessage(message) {
-  return `key` in message;
+  return message != null && `key` in message;
 }
 function isControlMessage(message) {
-  return !isChangeMessage(message);
+  return message != null && !isChangeMessage(message);
 }
 function isUpToDateMessage(message) {
   return isControlMessage(message) && message.headers.control === `up-to-date`;
@@ -891,8 +891,202 @@ function compileOrderBy(clauses, columnMapper) {
   }).join(`, `);
 }
 
-// src/client.ts
-var import_fetch_event_source = require("@microsoft/fetch-event-source");
+// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1_patch_hash=46f4e76dd960e002a542732bb4323817a24fce1673cb71e2f458fe09776fa188/node_modules/@microsoft/fetch-event-source/lib/esm/parse.js
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+
+// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1_patch_hash=46f4e76dd960e002a542732bb4323817a24fce1673cb71e2f458fe09776fa188/node_modules/@microsoft/fetch-event-source/lib/esm/fetch.js
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1e3;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _a) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (typeof document !== "undefined" && !document.hidden) {
+        create();
+      }
+    }
+    if (typeof document !== "undefined" && !openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+      }
+      clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+    });
+    const fetch2 = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a2;
+      curRequestController = new AbortController();
+      const sig = inputSignal.aborted ? inputSignal : curRequestController.signal;
+      try {
+        const response = await fetch2(input, Object.assign(Object.assign({}, rest), { headers, signal: sig }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (sig.aborted) {
+          dispose();
+          reject(err);
+        } else if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a2 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a2 !== void 0 ? _a2 : retryInterval;
+            clearTimeout(retryTimer);
+            retryTimer = setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
 
 // src/expired-shapes-cache.ts
 var ExpiredShapesCache = class {
@@ -2127,7 +2321,8 @@ requestShape_fn = async function() {
       }
       const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER] || `${__privateGet(this, _syncState).handle}-next`;
       __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
-      await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, Array.isArray(e.json) ? e.json : [e.json]);
+      const messages409 = Array.isArray(e.json) ? e.json : e.json != null ? [e.json] : [];
+      await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, messages409);
       return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
     } else {
       throw e;
@@ -2310,6 +2505,12 @@ onInitialResponse_fn = async function(response) {
   return true;
 };
 onMessages_fn = async function(batch, isSseMessage = false) {
+  if (!Array.isArray(batch)) {
+    console.warn(
+      `[Electric] #onMessages called with non-array argument (${typeof batch}). This is a client bug \u2014 please report it.`
+    );
+    return;
+  }
   if (batch.length === 0) return;
   const lastMessage = batch[batch.length - 1];
   const hasUpToDateMessage = isUpToDateMessage(lastMessage);
@@ -2366,6 +2567,7 @@ fetchShape_fn = async function(opts) {
   return __privateMethod(this, _ShapeStream_instances, requestShapeLongPoll_fn).call(this, opts);
 };
 requestShapeLongPoll_fn = async function(opts) {
+  var _a;
   const { fetchUrl, requestAbortController, headers } = opts;
   const response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
     signal: requestAbortController.signal,
@@ -2378,6 +2580,16 @@ requestShapeLongPoll_fn = async function(opts) {
   const res = await response.text();
   const messages = res || `[]`;
   const batch = __privateGet(this, _messageParser).parse(messages, schema);
+  if (!Array.isArray(batch)) {
+    const preview = (_a = JSON.stringify(batch)) == null ? void 0 : _a.slice(0, 200);
+    throw new FetchError(
+      response.status,
+      `Received non-array response body from shape endpoint. This may indicate a proxy or CDN is returning an unexpected response. Expected a JSON array, got ${typeof batch}: ${preview}`,
+      void 0,
+      Object.fromEntries(response.headers.entries()),
+      fetchUrl.toString()
+    );
+  }
   await __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, batch);
 };
 requestShapeSSE_fn = async function(opts) {
@@ -2390,7 +2602,7 @@ requestShapeSSE_fn = async function(opts) {
   let ignoredStaleResponse = false;
   try {
     let buffer = [];
-    await (0, import_fetch_event_source.fetchEventSource)(fetchUrl.toString(), {
+    await fetchEventSource(fetchUrl.toString(), {
       headers: sseHeaders,
       fetch: fetch2,
       onopen: async (response) => {