on-zero 0.4.25 → 0.4.27

package/dist/cjs/httpPullTransport.cjs

@@ -0,0 +1,432 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var httpPullTransport_exports = {};
+__export(httpPullTransport_exports, {
+  ensureHttpPullTransport: () => ensureHttpPullTransport,
+  installHttpPullTransport: () => installHttpPullTransport
+});
+module.exports = __toCommonJS(httpPullTransport_exports);
+const COOKIE_WIDTH = 20;
+function installHttpPullTransport(opts) {
+  const previousWebSocket = globalThis.WebSocket;
+  const fetchImpl = opts.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("installHttpPullTransport requires a fetch implementation");
+  }
+  const state = {
+    origin: new URL(opts.origin),
+    originString: trimTrailingSlash(new URL(opts.origin).toString()),
+    fetch: fetchImpl,
+    nativeWebSocket: previousWebSocket,
+    sockets: /* @__PURE__ */new Set(),
+    pullIntervalMs: opts.pullIntervalMs,
+    nextPokeID: 0
+  };
+  const Shim = class {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+    constructor(url, protocols) {
+      if (shouldIntercept(state.origin, url)) {
+        return new ZeroHttpSocket(state, url, protocols);
+      }
+      if (!state.nativeWebSocket) {
+        throw new Error(`No native WebSocket available for ${String(url)}`);
+      }
+      return new state.nativeWebSocket(url, protocols);
+    }
+  };
+  globalThis.WebSocket = Shim;
+  return {
+    pull: async () => {
+      await Promise.all([...state.sockets].map(socket => socket.pull()));
+    },
+    get connections() {
+      return state.sockets.size;
+    },
+    uninstall: () => {
+      if (globalThis.WebSocket === Shim) {
+        globalThis.WebSocket = previousWebSocket;
+      }
+    }
+  };
+}
+const transportsByOrigin = /* @__PURE__ */new Map();
+function ensureHttpPullTransport(opts) {
+  const key = trimTrailingSlash(new URL(opts.origin).toString());
+  const existing = transportsByOrigin.get(key);
+  if (existing) return existing;
+  const transport = installHttpPullTransport(opts);
+  transportsByOrigin.set(key, transport);
+  return transport;
+}
+class ZeroHttpSocket {
+  constructor(state, url, protocols) {
+    this.state = state;
+    this.connectURL = toHttpURL(url);
+    this.url = String(url);
+    this.clientID = this.connectURL.searchParams.get("clientID") ?? "";
+    this.clientGroupID = this.connectURL.searchParams.get("clientGroupID") ?? "";
+    this.wsid = this.connectURL.searchParams.get("wsid") ?? `zero-http-${Date.now()}`;
+    const baseCookie = this.connectURL.searchParams.get("baseCookie");
+    this.cookie = baseCookie ? baseCookie : null;
+    const decoded = decodeSecProtocol(protocols);
+    this.authToken = decoded.authToken;
+    this.queueDesiredQueries(decoded.initConnectionMessage?.[1]);
+    this.state.sockets.add(this);
+    this.openTimer = setTimeout(() => this.open(), 0);
+  }
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  url;
+  readyState = this.CONNECTING;
+  connectURL;
+  authToken;
+  listeners = {
+    open: /* @__PURE__ */new Set(),
+    message: /* @__PURE__ */new Set(),
+    close: /* @__PURE__ */new Set(),
+    error: /* @__PURE__ */new Set()
+  };
+  clientID;
+  clientGroupID;
+  wsid;
+  cookie;
+  pendingGotQueriesPatch = [];
+  pullInFlight;
+  pullAfterCurrent = false;
+  pushChain = Promise.resolve();
+  nextLocalCookieID = 0;
+  openTimer;
+  pullTimer;
+  addEventListener(type, listener) {
+    if (listener) this.listeners[type]?.add(listener);
+  }
+  removeEventListener(type, listener) {
+    if (listener) this.listeners[type]?.delete(listener);
+  }
+  dispatchEvent(event) {
+    this.emit(event.type, event);
+    return true;
+  }
+  send(data) {
+    if (this.readyState !== this.OPEN) {
+      throw new Error("cannot send on a socket that is not open");
+    }
+    const message = JSON.parse(data);
+    switch (message[0]) {
+      case "initConnection":
+      case "changeDesiredQueries":
+        this.queueDesiredQueries(message[1]);
+        this.requestPullAfterCurrent();
+        return;
+      case "updateAuth":
+        this.authToken = message[1].auth;
+        return;
+      case "push":
+        this.enqueuePush(message[1]);
+        return;
+      case "ping":
+        this.emitMessage(["pong", {}]);
+        return;
+      case "pull":
+        this.run(this.answerMutationRecoveryPull(message[1]));
+        return;
+      case "deleteClients":
+      case "ackMutationResponses":
+        return;
+      default:
+        throw new Error(`unsupported zero-http upstream message ${message[0]}`);
+    }
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState === this.CLOSED) return;
+    if (this.openTimer) clearTimeout(this.openTimer);
+    if (this.pullTimer) clearInterval(this.pullTimer);
+    this.readyState = this.CLOSED;
+    this.state.sockets.delete(this);
+    this.emit("close", {
+      code,
+      reason,
+      wasClean: code <= 1001
+    });
+  }
+  pull() {
+    if (this.readyState === this.CLOSED) return Promise.resolve();
+    if (this.pullInFlight) return this.pullInFlight;
+    this.pullInFlight = this.fetchPull(this.clientGroupID, this.cookie).then(response => {
+      if (response.unchanged) {
+        this.emitGotQueriesPatch(response.cookie);
+        return;
+      }
+      this.emitPoke(response);
+    }).catch(error => {
+      this.fail(error);
+      throw error;
+    }).finally(async () => {
+      const pullAgain = this.pullAfterCurrent;
+      this.pullAfterCurrent = false;
+      this.pullInFlight = void 0;
+      if (pullAgain && this.readyState !== this.CLOSED) await this.pull();
+    });
+    return this.pullInFlight;
+  }
+  open() {
+    if (this.readyState !== this.CONNECTING) return;
+    this.readyState = this.OPEN;
+    this.emit("open", {});
+    this.emitMessage(["connected", {
+      wsid: this.wsid,
+      timestamp: Date.now()
+    }]);
+    setTimeout(() => this.run(this.pull()), 0);
+    if (this.state.pullIntervalMs) {
+      this.pullTimer = setInterval(() => {
+        this.run(this.pull());
+      }, this.state.pullIntervalMs);
+    }
+  }
+  queueDesiredQueries(body) {
+    const desiredQueriesPatch = body?.desiredQueriesPatch;
+    if (!Array.isArray(desiredQueriesPatch)) return;
+    this.pendingGotQueriesPatch.push(...gotQueriesPatch(desiredQueriesPatch));
+  }
+  async push(body) {
+    const response = await this.postJSON("/push", body);
+    this.emitMessage(["pushResponse", response.pushResponse]);
+    this.requestPullAfterCurrent();
+  }
+  enqueuePush(body) {
+    const nextPush = this.pushChain.then(async () => {
+      if (this.readyState === this.CLOSED) return;
+      await this.push(body);
+    });
+    this.pushChain = nextPush.catch(() => {});
+    this.run(nextPush);
+  }
+  requestPullAfterCurrent() {
+    if (this.pullInFlight) {
+      this.pullAfterCurrent = true;
+      return;
+    }
+    this.run(this.pull());
+  }
+  async answerMutationRecoveryPull(body) {
+    const response = await this.fetchPull(body.clientGroupID, body.cookie);
+    const cookie = toWebSocketCookie(response.cookie);
+    this.emitMessage(["pull", {
+      requestID: body.requestID,
+      cookie: cookie ?? this.cookie ?? "0",
+      lastMutationIDChanges: response.unchanged ? {} : response.lastMutationIDChanges
+    }]);
+  }
+  async fetchPull(clientGroupID, cookie) {
+    return await this.postJSON("/pull", {
+      clientID: this.clientID,
+      clientGroupID,
+      cookie: toHttpCookie(cookie)
+    });
+  }
+  async postJSON(path, body) {
+    const response = await this.state.fetch(`${this.state.originString}${path}`, {
+      method: "POST",
+      headers: {
+        authorization: this.authToken ? `Bearer ${this.authToken}` : "",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new ZeroHttpResponseError(path, response.status);
+    }
+    return response.json();
+  }
+  run(promise) {
+    void promise.catch(error => this.fail(error));
+  }
+  fail(error) {
+    if (this.readyState === this.CLOSED) return;
+    if (isAuthHTTPError(error)) {
+      this.emitMessage(["error", {
+        kind: "Unauthorized",
+        message: error.message,
+        origin: "server"
+      }]);
+      if (this.readyState !== this.CLOSED) this.close(1e3, error.message);
+      return;
+    }
+    this.emit("error", {
+      error
+    });
+    this.close(1011, errorMessage(error));
+  }
+  emitPoke(response) {
+    const nextCookie = toWebSocketCookie(response.cookie);
+    if (isStaleCookie(this.cookie, response.cookie)) {
+      throw new Error(`zero-http pull returned stale cookie ${response.cookie} for ${this.cookie}`);
+    }
+    const pokeID = `zero-http-${++this.state.nextPokeID}`;
+    const gotQueries = this.pendingGotQueriesPatch;
+    this.pendingGotQueriesPatch = [];
+    this.emitMessage(["pokeStart", {
+      pokeID,
+      baseCookie: this.cookie,
+      schemaVersions: {
+        minSupportedVersion: 1,
+        maxSupportedVersion: 1
+      },
+      timestamp: Date.now()
+    }]);
+    this.emitMessage(["pokePart", {
+      pokeID,
+      lastMutationIDChanges: response.lastMutationIDChanges,
+      rowsPatch: response.rowsPatch
+    }]);
+    if (gotQueries.length > 0) {
+      this.emitMessage(["pokePart", {
+        pokeID,
+        gotQueriesPatch: gotQueries
+      }]);
+    }
+    this.emitMessage(["pokeEnd", {
+      pokeID,
+      cookie: nextCookie
+    }]);
+    this.cookie = nextCookie;
+  }
+  emitGotQueriesPatch(cookie) {
+    if (this.pendingGotQueriesPatch.length === 0) return;
+    const serverCookie = cookie ?? toHttpCookie(this.cookie);
+    if (serverCookie === null) return;
+    const nextCookie = toLocalWebSocketCookie(serverCookie, ++this.nextLocalCookieID);
+    const pokeID = `zero-http-${++this.state.nextPokeID}`;
+    const gotQueries = this.pendingGotQueriesPatch;
+    this.pendingGotQueriesPatch = [];
+    this.emitMessage(["pokeStart", {
+      pokeID,
+      baseCookie: this.cookie,
+      schemaVersions: {
+        minSupportedVersion: 1,
+        maxSupportedVersion: 1
+      },
+      timestamp: Date.now()
+    }]);
+    this.emitMessage(["pokePart", {
+      pokeID,
+      gotQueriesPatch: gotQueries
+    }]);
+    this.emitMessage(["pokeEnd", {
+      pokeID,
+      cookie: nextCookie
+    }]);
+    this.cookie = nextCookie;
+  }
+  emitMessage(message) {
+    if (this.readyState !== this.OPEN) return;
+    this.emit("message", {
+      data: JSON.stringify(message)
+    });
+  }
+  emit(type, event) {
+    const handler = this[`on${type}`];
+    if (typeof handler === "function") handler.call(this, event);
+    for (const listener of this.listeners[type]) {
+      if (typeof listener === "function") listener(event);else listener.handleEvent(event);
+    }
+  }
+}
+function shouldIntercept(origin, url) {
+  const candidate = toHttpURL(url);
+  if (candidate.origin !== origin.origin) return false;
+  return candidate.pathname === `${trimTrailingSlash(origin.pathname)}/sync/v51/connect`;
+}
+function toHttpURL(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol === "ws:") parsed.protocol = "http:";
+  if (parsed.protocol === "wss:") parsed.protocol = "https:";
+  return parsed;
+}
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function decodeSecProtocol(protocols) {
+  const protocol = Array.isArray(protocols) ? protocols[0] : protocols;
+  if (!protocol) return {};
+  try {
+    const decoded = decodeURIComponent(protocol);
+    const json = new TextDecoder().decode(Uint8Array.from(globalThis.atob(decoded), char => char.charCodeAt(0)));
+    const parsed = JSON.parse(json);
+    return {
+      authToken: parsed.authToken,
+      initConnectionMessage: Array.isArray(parsed.initConnectionMessage) ? parsed.initConnectionMessage : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function gotQueriesPatch(patch) {
+  const got = [];
+  for (const op of patch) {
+    if (op.op === "clear") got.push({
+      op: "clear"
+    });else if (op.hash) got.push({
+      op: op.op,
+      hash: op.hash
+    });
+  }
+  return got;
+}
+function toHttpCookie(cookie) {
+  if (cookie === null || cookie === "") return null;
+  const parsed = Number(cookie.slice(0, COOKIE_WIDTH));
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`zero-http cookie is not numeric: ${cookie}`);
+  }
+  return parsed;
+}
+function toWebSocketCookie(cookie) {
+  return cookie === null ? null : String(cookie).padStart(COOKIE_WIDTH, "0");
+}
+function toLocalWebSocketCookie(cookie, localID) {
+  return `${String(cookie).padStart(COOKIE_WIDTH, "0")}#${String(localID).padStart(6, "0")}`;
+}
+function isStaleCookie(current, next) {
+  const currentNumber = toHttpCookie(current);
+  return currentNumber !== null && next <= currentNumber;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+class ZeroHttpResponseError extends Error {
+  constructor(path, status) {
+    super(`zero-http ${path} failed with ${status}`);
+    this.path = path;
+    this.status = status;
+  }
+}
+function isAuthHTTPError(error) {
+  return error instanceof ZeroHttpResponseError && (error.status === 401 || error.status === 403);
+}