@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/zero-cache/src/services/mutagen/pusher.js

@@ -1,379 +1,385 @@
 import { groupBy } from "../../../../shared/src/arrays.js";
 import { assert, unreachable } from "../../../../shared/src/asserts.js";
+import { getErrorMessage } from "../../../../shared/src/error.js";
 import { must } from "../../../../shared/src/must.js";
 import { Queue } from "../../../../shared/src/queue.js";
-import { ErrorKind } from "../../../../zero-protocol/src/error-kind.js";
-import { pushResponseSchema, } from "../../../../zero-protocol/src/push.js";
-import {} from "../../config/zero-config.js";
-import { fetchFromAPIServer, compileUrlPattern } from "../../custom/fetch.js";
+import { PushFailed } from "../../../../zero-protocol/src/error-kind-enum.js";
+import { ZeroCache, Server } from "../../../../zero-protocol/src/error-origin-enum.js";
+import { HTTP, UnsupportedPushVersion, Internal, OutOfOrderMutation } from "../../../../zero-protocol/src/error-reason-enum.js";
+import { isProtocolError } from "../../../../zero-protocol/src/error.js";
+import { pushResponseSchema } from "../../../../zero-protocol/src/push.js";
+import "../../config/zero-config.js";
+import { compileUrlPattern, fetchFromAPIServer } from "../../custom/fetch.js";
 import { getOrCreateCounter } from "../../observability/metrics.js";
 import { recordMutation } from "../../server/anonymous-otel-start.js";
+import { ProtocolErrorWithLevel } from "../../types/error-with-level.js";
 import { upstreamSchema } from "../../types/shards.js";
 import { Subscription } from "../../types/subscription.js";
-import { isProtocolError, } from "../../../../zero-protocol/src/error.js";
-import { ErrorOrigin } from "../../../../zero-protocol/src/error-origin.js";
-import { ErrorReason } from "../../../../zero-protocol/src/error-reason.js";
-import { ProtocolErrorWithLevel } from "../../types/error-with-level.js";
-/**
- * Receives push messages from zero-client and forwards
- * them the the user's API server.
- *
- * If the user's API server is taking too long to process
- * the push, the PusherService will add the push to a queue
- * and send pushes in bulk the next time the user's API server
- * is available.
- *
- * - One PusherService exists per client group.
- * - Mutations for a given client are always sent in-order
- * - Mutations for different clients in the same group may be interleaved
- */
-export class PusherService {
-    id;
-    #pusher;
-    #queue;
-    #pushConfig;
-    #upstream;
-    #config;
-    #stopped;
-    #refCount = 0;
-    #isStopped = false;
-    constructor(upstream, appConfig, pushConfig, lc, clientGroupID) {
-        this.#config = appConfig;
-        this.#upstream = upstream;
-        this.#queue = new Queue();
-        this.#pusher = new PushWorker(appConfig, lc, pushConfig.url, pushConfig.apiKey, this.#queue);
-        this.id = clientGroupID;
-        this.#pushConfig = pushConfig;
-    }
-    get pushURL() {
-        return this.#pusher.pushURL[0];
-    }
-    initConnection(clientID, wsID, userPushURL) {
-        return this.#pusher.initConnection(clientID, wsID, userPushURL);
-    }
-    enqueuePush(clientID, push, auth, httpCookie) {
-        if (!this.#pushConfig.forwardCookies) {
-            httpCookie = undefined; // remove cookies if not forwarded
-        }
-        this.#queue.enqueue({ push, auth, clientID, httpCookie });
-        return {
-            type: 'ok',
-        };
+class PusherService {
+  id;
+  #pusher;
+  #queue;
+  #pushConfig;
+  #upstream;
+  #config;
+  #stopped;
+  #refCount = 0;
+  #isStopped = false;
+  constructor(upstream, appConfig, pushConfig, lc, clientGroupID) {
+    this.#config = appConfig;
+    this.#upstream = upstream;
+    this.#queue = new Queue();
+    this.#pusher = new PushWorker(
+      appConfig,
+      lc,
+      pushConfig.url,
+      pushConfig.apiKey,
+      this.#queue
+    );
+    this.id = clientGroupID;
+    this.#pushConfig = pushConfig;
+  }
+  get pushURL() {
+    return this.#pusher.pushURL[0];
+  }
+  initConnection(clientID, wsID, userPushURL) {
+    return this.#pusher.initConnection(clientID, wsID, userPushURL);
+  }
+  enqueuePush(clientID, push, auth, httpCookie) {
+    if (!this.#pushConfig.forwardCookies) {
+      httpCookie = void 0;
     }
-    async ackMutationResponses(upToID) {
-        // delete the relevant rows from the `mutations` table
-        const sql = this.#upstream;
-        await sql `DELETE FROM ${sql(upstreamSchema({
-            appID: this.#config.app.id,
-            shardNum: this.#config.shard.num,
-        }))}.mutations WHERE "clientGroupID" = ${this.id} AND "clientID" = ${upToID.clientID} AND "mutationID" <= ${upToID.id}`;
+    this.#queue.enqueue({ push, auth, clientID, httpCookie });
+    return {
+      type: "ok"
+    };
+  }
+  async ackMutationResponses(upToID) {
+    const sql = this.#upstream;
+    await sql`DELETE FROM ${sql(
+      upstreamSchema({
+        appID: this.#config.app.id,
+        shardNum: this.#config.shard.num
+      })
+    )}.mutations WHERE "clientGroupID" = ${this.id} AND "clientID" = ${upToID.clientID} AND "mutationID" <= ${upToID.id}`;
+  }
+  ref() {
+    assert(!this.#isStopped, "PusherService is already stopped");
+    ++this.#refCount;
+  }
+  unref() {
+    assert(!this.#isStopped, "PusherService is already stopped");
+    --this.#refCount;
+    if (this.#refCount <= 0) {
+      void this.stop();
     }
-    ref() {
-        assert(!this.#isStopped, 'PusherService is already stopped');
-        ++this.#refCount;
-    }
-    unref() {
-        assert(!this.#isStopped, 'PusherService is already stopped');
-        --this.#refCount;
-        if (this.#refCount <= 0) {
-            void this.stop();
-        }
-    }
-    hasRefs() {
-        return this.#refCount > 0;
-    }
-    run() {
-        this.#stopped = this.#pusher.run();
-        return this.#stopped;
-    }
-    stop() {
-        if (this.#isStopped) {
-            return must(this.#stopped, 'Stop was called before `run`');
-        }
-        this.#isStopped = true;
-        this.#queue.enqueue('stop');
-        return must(this.#stopped, 'Stop was called before `run`');
+  }
+  hasRefs() {
+    return this.#refCount > 0;
+  }
+  run() {
+    this.#stopped = this.#pusher.run();
+    return this.#stopped;
+  }
+  stop() {
+    if (this.#isStopped) {
+      return must(this.#stopped, "Stop was called before `run`");
     }
+    this.#isStopped = true;
+    this.#queue.enqueue("stop");
+    return must(this.#stopped, "Stop was called before `run`");
+  }
 }
-/**
- * Awaits items in the queue then drains and sends them all
- * to the user's API server.
- */
 class PushWorker {
-    #pushURLs;
-    #pushURLPatterns;
-    #apiKey;
-    #queue;
-    #lc;
-    #config;
-    #clients;
-    #userPushURL;
-    #customMutations = getOrCreateCounter('mutation', 'custom', 'Number of custom mutations processed');
-    #pushes = getOrCreateCounter('mutation', 'pushes', 'Number of pushes processed by the pusher');
-    constructor(config, lc, pushURL, apiKey, queue) {
-        this.#pushURLs = pushURL;
-        this.#lc = lc.withContext('component', 'pusher');
-        this.#pushURLPatterns = pushURL.map(compileUrlPattern);
-        this.#apiKey = apiKey;
-        this.#queue = queue;
-        this.#config = config;
-        this.#clients = new Map();
+  #pushURLs;
+  #pushURLPatterns;
+  #apiKey;
+  #queue;
+  #lc;
+  #config;
+  #clients;
+  #userPushURL;
+  #customMutations = getOrCreateCounter(
+    "mutation",
+    "custom",
+    "Number of custom mutations processed"
+  );
+  #pushes = getOrCreateCounter(
+    "mutation",
+    "pushes",
+    "Number of pushes processed by the pusher"
+  );
+  constructor(config, lc, pushURL, apiKey, queue) {
+    this.#pushURLs = pushURL;
+    this.#lc = lc.withContext("component", "pusher");
+    this.#pushURLPatterns = pushURL.map(compileUrlPattern);
+    this.#apiKey = apiKey;
+    this.#queue = queue;
+    this.#config = config;
+    this.#clients = /* @__PURE__ */ new Map();
+  }
+  get pushURL() {
+    return this.#pushURLs;
+  }
+  /**
+   * Returns a new downstream stream if the clientID,wsID pair has not been seen before.
+   * If a clientID already exists with a different wsID, that client's downstream is cancelled.
+   */
+  initConnection(clientID, wsID, userPushURL) {
+    const existing = this.#clients.get(clientID);
+    if (existing && existing.wsID === wsID) {
+      throw new Error("Connection was already initialized");
     }
-    get pushURL() {
-        return this.#pushURLs;
+    if (existing) {
+      existing.downstream.cancel();
     }
-    /**
-     * Returns a new downstream stream if the clientID,wsID pair has not been seen before.
-     * If a clientID already exists with a different wsID, that client's downstream is cancelled.
-     */
-    initConnection(clientID, wsID, userPushURL) {
-        const existing = this.#clients.get(clientID);
-        if (existing && existing.wsID === wsID) {
-            // already initialized for this socket
-            throw new Error('Connection was already initialized');
-        }
-        // client is back on a new connection
-        if (existing) {
-            existing.downstream.cancel();
-        }
-        // Handle client group level URL parameters
-        if (this.#userPushURL === undefined) {
-            // First client in the group - store its URL
-            this.#userPushURL = userPushURL;
-        }
-        else {
-            // Validate that subsequent clients have compatible parameters
-            if (this.#userPushURL !== userPushURL) {
-                this.#lc.error?.('Client provided different mutate parameters than client group', {
-                    clientID,
-                    clientURL: userPushURL,
-                    clientGroupURL: this.#userPushURL,
-                });
-            }
-        }
-        const downstream = Subscription.create({
-            cleanup: () => {
-                this.#clients.delete(clientID);
-            },
-        });
-        this.#clients.set(clientID, { wsID, downstream });
-        return downstream;
+    if (this.#userPushURL === void 0) {
+      this.#userPushURL = userPushURL;
+    } else {
+      if (this.#userPushURL !== userPushURL) {
+        this.#lc.warn?.(
+          "Client provided different mutate parameters than client group",
+          {
+            clientID,
+            clientURL: userPushURL,
+            clientGroupURL: this.#userPushURL
+          }
+        );
+      }
     }
-    async run() {
-        for (;;) {
-            const task = await this.#queue.dequeue();
-            const rest = this.#queue.drain();
-            const [pushes, terminate] = combinePushes([task, ...rest]);
-            for (const push of pushes) {
-                const response = await this.#processPush(push);
-                await this.#fanOutResponses(response);
-            }
-            if (terminate) {
-                break;
-            }
-        }
+    const downstream = Subscription.create({
+      cleanup: () => {
+        this.#clients.delete(clientID);
+      }
+    });
+    this.#clients.set(clientID, { wsID, downstream });
+    return downstream;
+  }
+  async run() {
+    for (; ; ) {
+      const task = await this.#queue.dequeue();
+      const rest = this.#queue.drain();
+      const [pushes, terminate] = combinePushes([task, ...rest]);
+      for (const push of pushes) {
+        const response = await this.#processPush(push);
+        await this.#fanOutResponses(response);
+      }
+      if (terminate) {
+        break;
+      }
     }
-    /**
-     * 1. If the entire `push` fails, we send the error to relevant clients.
-     * 2. If the push succeeds, we look for any mutation failure that should cause the connection to terminate
-     *  and terminate the connection for those clients.
-     */
-    #fanOutResponses(response) {
-        const connectionTerminations = [];
-        // if the entire push failed, send that to the client.
-        if ('kind' in response || 'error' in response) {
-            this.#lc.warn?.('The server behind ZERO_PUSH_URL returned a push error.', response);
-            const groupedMutationIDs = groupBy(response.mutationIDs ?? [], m => m.clientID);
-            for (const [clientID, mutationIDs] of groupedMutationIDs) {
-                const client = this.#clients.get(clientID);
-                if (!client) {
-                    continue;
-                }
-                // We do not resolve mutations on the client if the push fails
-                // as those mutations will be retried.
-                if ('error' in response) {
-                    // This error code path will eventually be removed when we
-                    // no longer support the legacy push error format.
-                    const pushFailedBody = response.error === 'http'
-                        ? {
-                            kind: ErrorKind.PushFailed,
-                            origin: ErrorOrigin.ZeroCache,
-                            reason: ErrorReason.HTTP,
-                            status: response.status,
-                            bodyPreview: response.details,
-                            mutationIDs,
-                            message: `Fetch from API server returned non-OK status ${response.status}`,
-                        }
-                        : response.error === 'unsupportedPushVersion'
-                            ? {
-                                kind: ErrorKind.PushFailed,
-                                origin: ErrorOrigin.Server,
-                                reason: ErrorReason.UnsupportedPushVersion,
-                                mutationIDs,
-                                message: `Unsupported push version`,
-                            }
-                            : {
-                                kind: ErrorKind.PushFailed,
-                                origin: ErrorOrigin.Server,
-                                reason: ErrorReason.Internal,
-                                mutationIDs,
-                                message: response.error === 'zeroPusher'
-                                    ? response.details
-                                    : response.error === 'unsupportedSchemaVersion'
-                                        ? 'Unsupported schema version'
-                                        : 'An unknown error occurred while pushing to the API server',
-                            };
-                    this.#failDownstream(client.downstream, pushFailedBody);
-                }
-                else if ('kind' in response) {
-                    this.#failDownstream(client.downstream, response);
-                }
-                else {
-                    unreachable(response);
-                }
-            }
+  }
+  /**
+   * 1. If the entire `push` fails, we send the error to relevant clients.
+   * 2. If the push succeeds, we look for any mutation failure that should cause the connection to terminate
+   *  and terminate the connection for those clients.
+   */
+  #fanOutResponses(response) {
+    const connectionTerminations = [];
+    if ("kind" in response || "error" in response) {
+      this.#lc.warn?.(
+        "The server behind ZERO_MUTATE_URL returned a push error.",
+        response
+      );
+      const groupedMutationIDs = groupBy(
+        response.mutationIDs ?? [],
+        (m) => m.clientID
+      );
+      for (const [clientID, mutationIDs] of groupedMutationIDs) {
+        const client = this.#clients.get(clientID);
+        if (!client) {
+          continue;
         }
-        else {
-            // Look for mutations results that should cause us to terminate the connection
-            const groupedMutations = groupBy(response.mutations, m => m.id.clientID);
-            for (const [clientID, mutations] of groupedMutations) {
-                const client = this.#clients.get(clientID);
-                if (!client) {
-                    continue;
-                }
-                let failure;
-                let i = 0;
-                for (; i < mutations.length; i++) {
-                    const m = mutations[i];
-                    if ('error' in m.result) {
-                        this.#lc.warn?.('The server behind ZERO_PUSH_URL returned a mutation error.', m.result);
-                    }
-                    // This error code path will eventually be removed,
-                    // keeping this for backwards compatibility, but the server
-                    // should now return a PushFailedBody with the mutationIDs
-                    if ('error' in m.result && m.result.error === 'oooMutation') {
-                        failure = {
-                            kind: ErrorKind.PushFailed,
-                            origin: ErrorOrigin.Server,
-                            reason: ErrorReason.OutOfOrderMutation,
-                            message: 'mutation was out of order',
-                            details: m.result.details,
-                            mutationIDs: mutations.map(m => ({
-                                clientID: m.id.clientID,
-                                id: m.id.id,
-                            })),
-                        };
-                        break;
-                    }
-                }
-                if (failure && i < mutations.length - 1) {
-                    this.#lc.error?.('push-response contains mutations after a mutation which should fatal the connection');
-                }
-                if (failure) {
-                    connectionTerminations.push(() => this.#failDownstream(client.downstream, failure));
-                }
-            }
+        if ("error" in response) {
+          const pushFailedBody = response.error === "http" ? {
+            kind: PushFailed,
+            origin: ZeroCache,
+            reason: HTTP,
+            status: response.status,
+            bodyPreview: response.details,
+            mutationIDs,
+            message: `Fetch from API server returned non-OK status ${response.status}`
+          } : response.error === "unsupportedPushVersion" ? {
+            kind: PushFailed,
+            origin: Server,
+            reason: UnsupportedPushVersion,
+            mutationIDs,
+            message: `Unsupported push version`
+          } : {
+            kind: PushFailed,
+            origin: Server,
+            reason: Internal,
+            mutationIDs,
+            message: response.error === "zeroPusher" ? response.details : response.error === "unsupportedSchemaVersion" ? "Unsupported schema version" : "An unknown error occurred while pushing to the API server"
+          };
+          this.#failDownstream(client.downstream, pushFailedBody);
+        } else if ("kind" in response) {
+          this.#failDownstream(client.downstream, response);
+        } else {
+          unreachable();
         }
-        connectionTerminations.forEach(cb => cb());
-    }
-    async #processPush(entry) {
-        this.#customMutations.add(entry.push.mutations.length, {
-            clientGroupID: entry.push.clientGroupID,
-        });
-        this.#pushes.add(1, {
-            clientGroupID: entry.push.clientGroupID,
-        });
-        // Record custom mutations for telemetry
-        recordMutation('custom', entry.push.mutations.length);
-        const url = this.#userPushURL ??
-            must(this.#pushURLs[0], 'ZERO_MUTATE_URL is not set');
-        this.#lc.debug?.('pushing to', url, 'with', entry.push.mutations.length, 'mutations');
-        let mutationIDs = [];
-        try {
-            mutationIDs = entry.push.mutations.map(m => ({
-                id: m.id,
-                clientID: m.clientID,
-            }));
-            return await fetchFromAPIServer(pushResponseSchema, 'push', this.#lc, url, this.#pushURLPatterns, {
-                appID: this.#config.app.id,
-                shardNum: this.#config.shard.num,
-            }, {
-                apiKey: this.#apiKey,
-                token: entry.auth,
-                cookie: entry.httpCookie,
-            }, entry.push);
+      }
+    } else {
+      const groupedMutations = groupBy(response.mutations, (m) => m.id.clientID);
+      for (const [clientID, mutations] of groupedMutations) {
+        const client = this.#clients.get(clientID);
+        if (!client) {
+          continue;
         }
-        catch (e) {
-            this.#lc.error?.('failed to push', e);
-            if (isProtocolError(e) && e.errorBody.kind === ErrorKind.PushFailed) {
-                return {
-                    ...e.errorBody,
-                    mutationIDs,
-                };
-            }
-            return {
-                kind: ErrorKind.PushFailed,
-                origin: ErrorOrigin.ZeroCache,
-                reason: ErrorReason.Internal,
-                message: e instanceof Error
-                    ? e.message
-                    : 'An unknown error occurred while pushing to the API server',
-                mutationIDs,
+        let failure;
+        let i = 0;
+        for (; i < mutations.length; i++) {
+          const m = mutations[i];
+          if ("error" in m.result) {
+            this.#lc.warn?.(
+              "The server behind ZERO_MUTATE_URL returned a mutation error.",
+              m.result
+            );
+          }
+          if ("error" in m.result && m.result.error === "oooMutation") {
+            failure = {
+              kind: PushFailed,
+              origin: Server,
+              reason: OutOfOrderMutation,
+              message: "mutation was out of order",
+              details: m.result.details,
+              mutationIDs: mutations.map((m2) => ({
+                clientID: m2.id.clientID,
+                id: m2.id.id
+              }))
             };
+            break;
+          }
+        }
+        if (failure && i < mutations.length - 1) {
+          this.#lc.warn?.(
+            "push-response contains mutations after a mutation which should fatal the connection"
+          );
+        }
+        if (failure) {
+          connectionTerminations.push(
+            () => this.#failDownstream(client.downstream, failure)
+          );
         }
+      }
     }
-    #failDownstream(downstream, errorBody) {
-        const logLevel = errorBody.origin === ErrorOrigin.Server ? 'warn' : 'error';
-        downstream.fail(new ProtocolErrorWithLevel(errorBody, logLevel));
+    connectionTerminations.forEach((cb) => cb());
+  }
+  async #processPush(entry) {
+    this.#customMutations.add(entry.push.mutations.length, {
+      clientGroupID: entry.push.clientGroupID
+    });
+    this.#pushes.add(1, {
+      clientGroupID: entry.push.clientGroupID
+    });
+    recordMutation("custom", entry.push.mutations.length);
+    const url = this.#userPushURL ?? must(this.#pushURLs[0], "ZERO_MUTATE_URL is not set");
+    this.#lc.debug?.(
+      "pushing to",
+      url,
+      "with",
+      entry.push.mutations.length,
+      "mutations"
+    );
+    let mutationIDs = [];
+    try {
+      mutationIDs = entry.push.mutations.map((m) => ({
+        id: m.id,
+        clientID: m.clientID
+      }));
+      return await fetchFromAPIServer(
+        pushResponseSchema,
+        "push",
+        this.#lc,
+        url,
+        url === this.#userPushURL,
+        this.#pushURLPatterns,
+        {
+          appID: this.#config.app.id,
+          shardNum: this.#config.shard.num
+        },
+        {
+          apiKey: this.#apiKey,
+          token: entry.auth,
+          cookie: entry.httpCookie
+        },
+        entry.push
+      );
+    } catch (e) {
+      if (isProtocolError(e) && e.errorBody.kind === PushFailed) {
+        return {
+          ...e.errorBody,
+          mutationIDs
+        };
+      }
+      return {
+        kind: PushFailed,
+        origin: ZeroCache,
+        reason: Internal,
+        message: `Failed to push: ${getErrorMessage(e)}`,
+        mutationIDs
+      };
     }
+  }
+  #failDownstream(downstream, errorBody) {
+    const logLevel = errorBody.origin === Server ? "warn" : "error";
+    downstream.fail(new ProtocolErrorWithLevel(errorBody, logLevel));
+  }
 }
-/**
- * Pushes for different clientIDs could theoretically be interleaved.
- *
- * In order to do efficient batching to the user's API server,
- * we collect all pushes for the same clientID into a single push.
- */
-export function combinePushes(entries) {
-    const pushesByClientID = new Map();
-    function collect() {
-        const ret = [];
-        for (const entries of pushesByClientID.values()) {
-            const composite = {
-                ...entries[0],
-                push: {
-                    ...entries[0].push,
-                    mutations: [],
-                },
-            };
-            ret.push(composite);
-            for (const entry of entries) {
-                assertAreCompatiblePushes(composite, entry);
-                composite.push.mutations.push(...entry.push.mutations);
-            }
+function combinePushes(entries) {
+  const pushesByClientID = /* @__PURE__ */ new Map();
+  function collect() {
+    const ret = [];
+    for (const entries2 of pushesByClientID.values()) {
+      const composite = {
+        ...entries2[0],
+        push: {
+          ...entries2[0].push,
+          mutations: []
         }
-        return ret;
+      };
+      ret.push(composite);
+      for (const entry of entries2) {
+        assertAreCompatiblePushes(composite, entry);
+        composite.push.mutations.push(...entry.push.mutations);
+      }
     }
-    for (const entry of entries) {
-        if (entry === 'stop' || entry === undefined) {
-            return [collect(), true];
-        }
-        const { clientID } = entry;
-        const existing = pushesByClientID.get(clientID);
-        if (existing) {
-            existing.push(entry);
-        }
-        else {
-            pushesByClientID.set(clientID, [entry]);
-        }
+    return ret;
+  }
+  for (const entry of entries) {
+    if (entry === "stop" || entry === void 0) {
+      return [collect(), true];
+    }
+    const { clientID } = entry;
+    const existing = pushesByClientID.get(clientID);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      pushesByClientID.set(clientID, [entry]);
     }
-    return [collect(), false];
+  }
+  return [collect(), false];
 }
-// These invariants should always be true for a given clientID.
-// If they are not, we have a bug in the code somewhere.
 function assertAreCompatiblePushes(left, right) {
-    assert(left.clientID === right.clientID, 'clientID must be the same for all pushes');
-    assert(left.auth === right.auth, 'auth must be the same for all pushes with the same clientID');
-    assert(left.push.schemaVersion === right.push.schemaVersion, 'schemaVersion must be the same for all pushes with the same clientID');
-    assert(left.push.pushVersion === right.push.pushVersion, 'pushVersion must be the same for all pushes with the same clientID');
+  assert(
+    left.clientID === right.clientID,
+    "clientID must be the same for all pushes"
+  );
+  assert(
+    left.auth === right.auth,
+    "auth must be the same for all pushes with the same clientID"
+  );
+  assert(
+    left.push.schemaVersion === right.push.schemaVersion,
+    "schemaVersion must be the same for all pushes with the same clientID"
+  );
+  assert(
+    left.push.pushVersion === right.push.pushVersion,
+    "pushVersion must be the same for all pushes with the same clientID"
+  );
 }
-//# sourceMappingURL=pusher.js.map
+export {
+  PusherService,
+  combinePushes
+};
+//# sourceMappingURL=pusher.js.map