@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/zero-client/src/client/mutation-tracker.js

@@ -0,0 +1,363 @@
+import { resolver } from "@rocicorp/resolver";
+import { assert, unreachable } from "../../../shared/src/asserts.js";
+import { getErrorDetails } from "../../../shared/src/error.js";
+import { must } from "../../../shared/src/must.js";
+import { emptyObject } from "../../../shared/src/sentinels.js";
+import { parse } from "../../../shared/src/valita.js";
+import { wrapWithApplicationError, ApplicationError, isApplicationError } from "../../../zero-protocol/src/application-error.js";
+import { PushFailed, InvalidPush } from "../../../zero-protocol/src/error-kind-enum.js";
+import { ZeroCache, Server } from "../../../zero-protocol/src/error-origin-enum.js";
+import { Internal, HTTP } from "../../../zero-protocol/src/error-reason-enum.js";
+import { ProtocolError } from "../../../zero-protocol/src/error.js";
+import { mutationResultSchema } from "../../../zero-protocol/src/push.js";
+import { isZeroError } from "./error.js";
+import { MUTATIONS_KEY_PREFIX } from "./keys.js";
+let currentEphemeralID = 0;
+function nextEphemeralID() {
+  return ++currentEphemeralID;
+}
+const successResultDetails = { type: "success" };
+class MutationTracker {
+  #outstandingMutations;
+  #ephemeralIDsByMutationID;
+  #allMutationsAppliedListeners;
+  #lc;
+  #ackMutations;
+  #onFatalError;
+  #clientID;
+  #largestOutstandingMutationID;
+  #currentMutationID;
+  constructor(lc, ackMutations, onFatalError) {
+    this.#lc = lc.withContext("MutationTracker");
+    this.#outstandingMutations = /* @__PURE__ */ new Map();
+    this.#ephemeralIDsByMutationID = /* @__PURE__ */ new Map();
+    this.#allMutationsAppliedListeners = /* @__PURE__ */ new Set();
+    this.#largestOutstandingMutationID = 0;
+    this.#currentMutationID = 0;
+    this.#ackMutations = ackMutations;
+    this.#onFatalError = onFatalError;
+  }
+  setClientIDAndWatch(clientID, experimentalWatch) {
+    assert(this.#clientID === void 0, "clientID already set");
+    this.#clientID = clientID;
+    experimentalWatch(
+      (diffs) => {
+        this.#processMutationResponses(diffs);
+      },
+      {
+        prefix: MUTATIONS_KEY_PREFIX + clientID + "/",
+        initialValuesInFirstDiff: true
+      }
+    );
+  }
+  trackMutation() {
+    const id = nextEphemeralID();
+    const mutationResolver = resolver();
+    this.#outstandingMutations.set(id, {
+      resolver: mutationResolver
+    });
+    return { ephemeralID: id, serverPromise: mutationResolver.promise };
+  }
+  mutationIDAssigned(id, mutationID) {
+    const entry = this.#outstandingMutations.get(id);
+    if (entry) {
+      entry.mutationID = mutationID;
+      this.#ephemeralIDsByMutationID.set(mutationID, id);
+      this.#largestOutstandingMutationID = Math.max(
+        this.#largestOutstandingMutationID,
+        mutationID
+      );
+    }
+  }
+  /**
+   * Reject the mutation due to an unhandled exception on the client.
+   * The mutation must not have been persisted to the client store.
+   */
+  rejectMutation(id, e) {
+    const entry = this.#outstandingMutations.get(id);
+    if (entry) {
+      this.#settleMutation(id, entry, wrapWithApplicationError(e));
+    }
+  }
+  /**
+   * Reject all outstanding mutations. Called when the client is in a state
+   * that prevents mutations from being applied, such as offline or closed.
+   */
+  rejectAllOutstandingMutations(error) {
+    if (this.#outstandingMutations.size === 0) {
+      return;
+    }
+    for (const [id, entry] of this.#outstandingMutations) {
+      this.#settleMutation(id, entry, error);
+    }
+    this.#largestOutstandingMutationID = this.#currentMutationID;
+    this.#notifyAllMutationsAppliedListeners();
+  }
+  /**
+   * Used when zero-cache pokes down mutation results.
+   */
+  #processMutationResponses(diffs) {
+    const clientID = must(this.#clientID);
+    let largestLmid = 0;
+    for (const diff of diffs) {
+      const mutationID = Number(
+        diff.key.slice(MUTATIONS_KEY_PREFIX.length + clientID.length + 1)
+      );
+      assert(
+        !isNaN(mutationID),
+        `MutationTracker received a diff with an invalid mutation ID: ${diff.key}`
+      );
+      largestLmid = Math.max(largestLmid, mutationID);
+      switch (diff.op) {
+        case "add": {
+          const result = parse(diff.newValue, mutationResultSchema);
+          if ("error" in result) {
+            this.#processMutationError(clientID, mutationID, result);
+          } else {
+            this.#processMutationOk(clientID, mutationID, result);
+          }
+          break;
+        }
+        case "del":
+          break;
+        case "change":
+          throw new Error("MutationTracker does not expect change operations");
+      }
+    }
+    if (largestLmid > 0) {
+      this.#ackMutations({
+        clientID: must(this.#clientID),
+        id: largestLmid
+      });
+    }
+  }
+  processPushResponse(response) {
+    if ("error" in response) {
+      this.#lc.error?.(
+        "Received an error response when pushing mutations",
+        response
+      );
+      const fatalError = this.#fatalErrorFromPushError(response);
+      if (fatalError) {
+        this.#onFatalError(fatalError);
+      }
+    } else {
+      this.#processPushOk(response);
+    }
+  }
+  #fatalErrorFromPushError(error) {
+    switch (error.error) {
+      case "unsupportedPushVersion":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `Unsupported push version`,
+          mutationIDs: []
+        });
+      case "unsupportedSchemaVersion":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `Unsupported schema version`,
+          mutationIDs: []
+        });
+      case "http":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: HTTP,
+          status: error.status,
+          message: `Fetch from API server returned non-OK status ${error.status}: ${error.details ?? "unknown"}`,
+          mutationIDs: []
+        });
+      case "zeroPusher":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `ZeroPusher error: ${error.details ?? "unknown"}`,
+          mutationIDs: []
+        });
+      default:
+        unreachable();
+    }
+  }
+  /**
+   * DEPRECATED: to be removed when we switch to fully driving
+   * mutation resolution via poke.
+   *
+   * When we reconnect to zero-cache, we resolve all outstanding mutations
+   * whose ID is less than or equal to the lastMutationID.
+   *
+   * The reason is that any responses the API server sent
+   * to those mutations have been lost.
+   *
+   * An example case: the API server responds while the connection
+   * is down. Those responses are lost.
+   *
+   * Mutations whose LMID is > the lastMutationID are not resolved
+   * since they will be retried by the client, giving us another chance
+   * at getting a response.
+   *
+   * The only way to ensure that all API server responses are
+   * received would be to have the API server write them
+   * to the DB while writing the LMID.
+   */
+  onConnected(lastMutationID) {
+    this.lmidAdvanced(lastMutationID);
+  }
+  /**
+   * lmid advance will:
+   * 1. notify "allMutationsApplied" listeners if the lastMutationID
+   *    is greater than or equal to the largest outstanding mutation ID.
+   * 2. resolve all mutations whose mutation ID is less than or equal to
+   *    the lastMutationID.
+   */
+  lmidAdvanced(lastMutationID) {
+    assert(
+      lastMutationID >= this.#currentMutationID,
+      "lmid must be greater than or equal to current lmid"
+    );
+    if (lastMutationID === this.#currentMutationID) {
+      return;
+    }
+    try {
+      this.#currentMutationID = lastMutationID;
+      this.#resolveMutations(lastMutationID);
+    } finally {
+      if (lastMutationID >= this.#largestOutstandingMutationID) {
+        this.#notifyAllMutationsAppliedListeners();
+      }
+    }
+  }
+  get size() {
+    return this.#outstandingMutations.size;
+  }
+  #resolveMutations(upTo) {
+    for (const [id, entry] of this.#outstandingMutations) {
+      if (entry.mutationID && entry.mutationID <= upTo) {
+        this.#settleMutation(id, entry, emptyObject);
+      } else {
+        break;
+      }
+    }
+  }
+  #processPushOk(ok) {
+    for (const mutation of ok.mutations) {
+      if ("error" in mutation.result) {
+        this.#processMutationError(
+          mutation.id.clientID,
+          mutation.id.id,
+          mutation.result
+        );
+      } else {
+        this.#processMutationOk(
+          mutation.id.clientID,
+          mutation.id.id,
+          mutation.result
+        );
+      }
+    }
+  }
+  #processMutationError(clientID, mid, error) {
+    assert(
+      clientID === this.#clientID,
+      "received mutation for the wrong client"
+    );
+    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);
+    if (!ephemeralID) {
+      this.#lc.debug?.(
+        "Mutation already resolved or rejected (e.g. due to disconnect); ignore late reject."
+      );
+      return;
+    }
+    const entry = this.#outstandingMutations.get(ephemeralID);
+    assert(
+      entry && entry.mutationID === mid,
+      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`
+    );
+    if (error.error === "alreadyProcessed") {
+      this.#settleMutation(ephemeralID, entry, emptyObject);
+      return;
+    }
+    this.#settleMutation(
+      ephemeralID,
+      entry,
+      error.error === "app" ? new ApplicationError(
+        error.message ?? `Unknown application error: ${error.error}`,
+        error.details ? { details: error.details } : void 0
+      ) : new ProtocolError({
+        kind: InvalidPush,
+        origin: Server,
+        reason: Internal,
+        message: error.error === "oooMutation" ? "Server reported an out-of-order mutation" : `Unknown fallback error with mutation ID ${mid}: ${error.error}`,
+        details: getErrorDetails(error)
+      })
+    );
+    if (error.error === "oooMutation") {
+      this.#onFatalError(
+        new ProtocolError({
+          kind: InvalidPush,
+          origin: Server,
+          reason: Internal,
+          message: "Server reported an out-of-order mutation",
+          details: error.details
+        })
+      );
+    }
+  }
+  #processMutationOk(clientID, mid, result) {
+    assert(
+      clientID === this.#clientID,
+      "received mutation for the wrong client"
+    );
+    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);
+    if (!ephemeralID) {
+      this.#lc.debug?.(
+        "Mutation already resolved or rejected (e.g. due to disconnect); ignore late resolve."
+      );
+      return;
+    }
+    const entry = this.#outstandingMutations.get(ephemeralID);
+    assert(
+      entry && entry.mutationID === mid,
+      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`
+    );
+    this.#settleMutation(ephemeralID, entry, result);
+  }
+  #settleMutation(ephemeralID, entry, result) {
+    if (isApplicationError(result) || isZeroError(result)) {
+      entry.resolver.reject(result);
+    } else {
+      entry.resolver.resolve(successResultDetails);
+    }
+    this.#outstandingMutations.delete(ephemeralID);
+    if (entry.mutationID) {
+      this.#ephemeralIDsByMutationID.delete(entry.mutationID);
+    }
+  }
+  /**
+   * Be notified when all mutations have been included in the server snapshot.
+   *
+   * The query manager will not de-register queries from the server until there
+   * are no pending mutations.
+   *
+   * The reason is that a mutation may need to be rebased. We do not want
+   * data that was available the first time it was run to not be available
+   * on a rebase.
+   */
+  onAllMutationsApplied(listener) {
+    this.#allMutationsAppliedListeners.add(listener);
+  }
+  #notifyAllMutationsAppliedListeners() {
+    for (const listener of this.#allMutationsAppliedListeners) {
+      listener();
+    }
+  }
+}
+export {
+  MutationTracker
+};
+//# sourceMappingURL=mutation-tracker.js.map

package/out/zero-client/src/client/mutation-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-tracker.js","sources":["../../../../../zero-client/src/client/mutation-tracker.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport type {NoIndexDiff} from '../../../replicache/src/btree/node.ts';\nimport type {ReplicacheImpl} from '../../../replicache/src/impl.ts';\nimport type {\n  EphemeralID,\n  MutationTrackingData,\n} from '../../../replicache/src/replicache-options.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {getErrorDetails} from '../../../shared/src/error.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyObject} from '../../../shared/src/sentinels.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport {\n  ApplicationError,\n  isApplicationError,\n  wrapWithApplicationError,\n} from '../../../zero-protocol/src/application-error.ts';\nimport {ErrorKind} from '../../../zero-protocol/src/error-kind.ts';\nimport {ErrorOrigin} from '../../../zero-protocol/src/error-origin.ts';\nimport {ErrorReason} from '../../../zero-protocol/src/error-reason.ts';\nimport {ProtocolError} from '../../../zero-protocol/src/error.ts';\nimport {\n  mutationResultSchema,\n  type MutationError,\n  type MutationID,\n  type MutationOk,\n  type PushError,\n  type PushOk,\n  type PushResponseBody,\n} from '../../../zero-protocol/src/push.ts';\nimport type {MutatorResultSuccessDetails} from './custom.ts';\nimport {isZeroError, type ZeroError} from './error.ts';\nimport {MUTATIONS_KEY_PREFIX} from './keys.ts';\n\ntype MutationSuccessType = MutatorResultSuccessDetails;\ntype MutationErrorType = ApplicationError | ZeroError;\n\nlet currentEphemeralID = 0;\nfunction nextEphemeralID(): EphemeralID {\n  return ++currentEphemeralID as EphemeralID;\n}\n\nconst successResultDetails: MutationSuccessType = {type: 'success'};\n\n/**\n * Tracks what pushes are in-flight and resolves promises when they're acked.\n */\nexport class MutationTracker {\n  readonly #outstandingMutations: Map<\n    EphemeralID,\n    {\n      mutationID?: number | undefined;\n      resolver: Resolver<MutationSuccessType, MutationErrorType>;\n    }\n  >;\n  readonly #ephemeralIDsByMutationID: Map<number, EphemeralID>;\n  readonly #allMutationsAppliedListeners: Set<() => void>;\n  readonly #lc: LogContext;\n\n  readonly #ackMutations: (upTo: MutationID) => void;\n  readonly #onFatalError: (error: ZeroError) => void;\n\n  #clientID: string | undefined;\n  #largestOutstandingMutationID: number;\n  #currentMutationID: number;\n\n  constructor(\n    lc: LogContext,\n    ackMutations: (upTo: MutationID) => void,\n    onFatalError: (error: ZeroError) => void,\n  ) {\n    this.#lc = lc.withContext('MutationTracker');\n    this.#outstandingMutations = new Map();\n    this.#ephemeralIDsByMutationID = new Map();\n    this.#allMutationsAppliedListeners = new Set();\n    this.#largestOutstandingMutationID = 0;\n    this.#currentMutationID = 0;\n    this.#ackMutations = ackMutations;\n    this.#onFatalError = onFatalError;\n  }\n\n  setClientIDAndWatch(\n    clientID: string,\n    experimentalWatch: ReplicacheImpl['experimentalWatch'],\n  ) {\n    assert(this.#clientID === undefined, 'clientID already set');\n    this.#clientID = clientID;\n    experimentalWatch(\n      diffs => {\n        this.#processMutationResponses(diffs);\n      },\n      {\n        prefix: MUTATIONS_KEY_PREFIX + clientID + '/',\n        initialValuesInFirstDiff: true,\n      },\n    );\n  }\n\n  trackMutation(): MutationTrackingData<MutationSuccessType> {\n    const id = nextEphemeralID();\n    const mutationResolver = resolver<MutationSuccessType, MutationErrorType>();\n\n    this.#outstandingMutations.set(id, {\n      resolver: mutationResolver,\n    });\n    return {ephemeralID: id, serverPromise: mutationResolver.promise};\n  }\n\n  mutationIDAssigned(id: EphemeralID, mutationID: number): void {\n    const entry = this.#outstandingMutations.get(id);\n    if (entry) {\n      entry.mutationID = mutationID;\n      this.#ephemeralIDsByMutationID.set(mutationID, id);\n      this.#largestOutstandingMutationID = Math.max(\n        this.#largestOutstandingMutationID,\n        mutationID,\n      );\n    }\n  }\n\n  /**\n   * Reject the mutation due to an unhandled exception on the client.\n   * The mutation must not have been persisted to the client store.\n   */\n  rejectMutation(id: EphemeralID, e: unknown): void {\n    const entry = this.#outstandingMutations.get(id);\n    if (entry) {\n      this.#settleMutation(id, entry, wrapWithApplicationError(e));\n    }\n  }\n\n  /**\n   * Reject all outstanding mutations. Called when the client is in a state\n   * that prevents mutations from being applied, such as offline or closed.\n   */\n  rejectAllOutstandingMutations(error: ZeroError): void {\n    if (this.#outstandingMutations.size === 0) {\n      return;\n    }\n    for (const [id, entry] of this.#outstandingMutations) {\n      this.#settleMutation(id, entry, error);\n    }\n    this.#largestOutstandingMutationID = this.#currentMutationID;\n    this.#notifyAllMutationsAppliedListeners();\n  }\n\n  /**\n   * Used when zero-cache pokes down mutation results.\n   */\n  #processMutationResponses(diffs: NoIndexDiff): void {\n    const clientID = must(this.#clientID);\n    let largestLmid = 0;\n    for (const diff of diffs) {\n      const mutationID = Number(\n        diff.key.slice(MUTATIONS_KEY_PREFIX.length + clientID.length + 1),\n      );\n      assert(\n        !isNaN(mutationID),\n        `MutationTracker received a diff with an invalid mutation ID: ${diff.key}`,\n      );\n      largestLmid = Math.max(largestLmid, mutationID);\n      switch (diff.op) {\n        case 'add': {\n          const result = v.parse(diff.newValue, mutationResultSchema);\n          if ('error' in result) {\n            this.#processMutationError(clientID, mutationID, result);\n          } else {\n            this.#processMutationOk(clientID, mutationID, result);\n          }\n          break;\n        }\n        case 'del':\n          break;\n        case 'change':\n          throw new Error('MutationTracker does not expect change operations');\n      }\n    }\n\n    if (largestLmid > 0) {\n      this.#ackMutations({\n        clientID: must(this.#clientID),\n        id: largestLmid,\n      });\n    }\n  }\n\n  processPushResponse(response: PushResponseBody): void {\n    if ('error' in response) {\n      this.#lc.error?.(\n        'Received an error response when pushing mutations',\n        response,\n      );\n      const fatalError = this.#fatalErrorFromPushError(response);\n      if (fatalError) {\n        this.#onFatalError(fatalError);\n      }\n    } else {\n      this.#processPushOk(response);\n    }\n  }\n\n  #fatalErrorFromPushError(error: PushError): ZeroError | undefined {\n    switch (error.error) {\n      case 'unsupportedPushVersion':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `Unsupported push version`,\n          mutationIDs: [],\n        });\n      case 'unsupportedSchemaVersion':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `Unsupported schema version`,\n          mutationIDs: [],\n        });\n      case 'http':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.HTTP,\n          status: error.status,\n          message: `Fetch from API server returned non-OK status ${error.status}: ${error.details ?? 'unknown'}`,\n          mutationIDs: [],\n        });\n      case 'zeroPusher':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `ZeroPusher error: ${error.details ?? 'unknown'}`,\n          mutationIDs: [],\n        });\n      default:\n        unreachable(error);\n    }\n  }\n\n  /**\n   * DEPRECATED: to be removed when we switch to fully driving\n   * mutation resolution via poke.\n   *\n   * When we reconnect to zero-cache, we resolve all outstanding mutations\n   * whose ID is less than or equal to the lastMutationID.\n   *\n   * The reason is that any responses the API server sent\n   * to those mutations have been lost.\n   *\n   * An example case: the API server responds while the connection\n   * is down. Those responses are lost.\n   *\n   * Mutations whose LMID is > the lastMutationID are not resolved\n   * since they will be retried by the client, giving us another chance\n   * at getting a response.\n   *\n   * The only way to ensure that all API server responses are\n   * received would be to have the API server write them\n   * to the DB while writing the LMID.\n   */\n  onConnected(lastMutationID: number) {\n    this.lmidAdvanced(lastMutationID);\n  }\n\n  /**\n   * lmid advance will:\n   * 1. notify \"allMutationsApplied\" listeners if the lastMutationID\n   *    is greater than or equal to the largest outstanding mutation ID.\n   * 2. resolve all mutations whose mutation ID is less than or equal to\n   *    the lastMutationID.\n   */\n  lmidAdvanced(lastMutationID: number): void {\n    assert(\n      lastMutationID >= this.#currentMutationID,\n      'lmid must be greater than or equal to current lmid',\n    );\n    if (lastMutationID === this.#currentMutationID) {\n      return;\n    }\n\n    try {\n      this.#currentMutationID = lastMutationID;\n      this.#resolveMutations(lastMutationID);\n    } finally {\n      if (lastMutationID >= this.#largestOutstandingMutationID) {\n        // this is very important otherwise we hang query de-registration\n        this.#notifyAllMutationsAppliedListeners();\n      }\n    }\n  }\n\n  get size() {\n    return this.#outstandingMutations.size;\n  }\n\n  #resolveMutations(upTo: number): void {\n    // We resolve all mutations whose mutation ID is less than or equal to\n    // the upTo mutation ID.\n    for (const [id, entry] of this.#outstandingMutations) {\n      if (entry.mutationID && entry.mutationID <= upTo) {\n        this.#settleMutation(id, entry, emptyObject);\n      } else {\n        break; // the map is in insertion order which is in mutation ID order\n      }\n    }\n  }\n\n  #processPushOk(ok: PushOk): void {\n    for (const mutation of ok.mutations) {\n      if ('error' in mutation.result) {\n        this.#processMutationError(\n          mutation.id.clientID,\n          mutation.id.id,\n          mutation.result,\n        );\n      } else {\n        this.#processMutationOk(\n          mutation.id.clientID,\n          mutation.id.id,\n          mutation.result,\n        );\n      }\n    }\n  }\n\n  #processMutationError(\n    clientID: string,\n    mid: number,\n    error: MutationError | Omit<PushError, 'mutationIDs'>,\n  ): void {\n    assert(\n      clientID === this.#clientID,\n      'received mutation for the wrong client',\n    );\n\n    // Each tab sends all mutations for the client group\n    // and the server responds back to the individual client that actually\n    // ran the mutation. This means that N clients can send the same\n    // mutation concurrently. If that happens, the promise for the mutation tracked\n    // by this class will try to be resolved N times.\n    // Every time after the first, the ephemeral ID will not be found.\n    //\n    // We also reject all outstanding mutations when the client is in a state\n    // that prevents mutations from being applied, such as offline or closed.\n    // In this case, the ephemeral ID will also not be found.\n    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);\n    if (!ephemeralID) {\n      this.#lc.debug?.(\n        'Mutation already resolved or rejected (e.g. due to disconnect); ignore late reject.',\n      );\n      return;\n    }\n\n    const entry = this.#outstandingMutations.get(ephemeralID);\n    assert(\n      entry && entry.mutationID === mid,\n      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`,\n    );\n\n    if (error.error === 'alreadyProcessed') {\n      this.#settleMutation(ephemeralID, entry, emptyObject);\n      return;\n    }\n\n    this.#settleMutation(\n      ephemeralID,\n      entry,\n      error.error === 'app'\n        ? new ApplicationError(\n            error.message ?? `Unknown application error: ${error.error}`,\n            error.details ? {details: error.details} : undefined,\n          )\n        : new ProtocolError({\n            kind: ErrorKind.InvalidPush,\n            origin: ErrorOrigin.Server,\n            reason: ErrorReason.Internal,\n            message:\n              error.error === 'oooMutation'\n                ? 'Server reported an out-of-order mutation'\n                : `Unknown fallback error with mutation ID ${mid}: ${error.error}`,\n            details: getErrorDetails(error),\n          }),\n    );\n\n    // this is included for backwards compatibility with the per-mutation fatal error responses\n    if (error.error === 'oooMutation') {\n      this.#onFatalError(\n        new ProtocolError({\n          kind: ErrorKind.InvalidPush,\n          origin: ErrorOrigin.Server,\n          reason: ErrorReason.Internal,\n          message: 'Server reported an out-of-order mutation',\n          details: error.details,\n        }),\n      );\n    }\n  }\n\n  #processMutationOk(clientID: string, mid: number, result: MutationOk): void {\n    assert(\n      clientID === this.#clientID,\n      'received mutation for the wrong client',\n    );\n\n    // We reject all outstanding mutations when the client is in a state\n    // that prevents mutations from being applied, such as offline or closed.\n    // In this case, the ephemeral ID will not be found.\n    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);\n    if (!ephemeralID) {\n      this.#lc.debug?.(\n        'Mutation already resolved or rejected (e.g. due to disconnect); ignore late resolve.',\n      );\n      return;\n    }\n\n    const entry = this.#outstandingMutations.get(ephemeralID);\n    assert(\n      entry && entry.mutationID === mid,\n      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`,\n    );\n    this.#settleMutation(ephemeralID, entry, result);\n  }\n\n  #settleMutation<Result extends MutationOk | ApplicationError | ZeroError>(\n    ephemeralID: EphemeralID,\n    entry: {\n      mutationID?: number | undefined;\n      resolver: Resolver<MutationSuccessType, MutationErrorType>;\n    },\n    result: Result,\n  ): void {\n    if (isApplicationError(result) || isZeroError(result)) {\n      // we reject here and catch in the mutator proxy\n      // the mutator proxy catches both client and server errors\n      entry.resolver.reject(result);\n    } else {\n      entry.resolver.resolve(successResultDetails);\n    }\n\n    this.#outstandingMutations.delete(ephemeralID);\n    if (entry.mutationID) {\n      this.#ephemeralIDsByMutationID.delete(entry.mutationID);\n    }\n  }\n\n  /**\n   * Be notified when all mutations have been included in the server snapshot.\n   *\n   * The query manager will not de-register queries from the server until there\n   * are no pending mutations.\n   *\n   * The reason is that a mutation may need to be rebased. We do not want\n   * data that was available the first time it was run to not be available\n   * on a rebase.\n   */\n  onAllMutationsApplied(listener: () => void): void {\n    this.#allMutationsAppliedListeners.add(listener);\n  }\n\n  #notifyAllMutationsAppliedListeners() {\n    for (const listener of this.#allMutationsAppliedListeners) {\n      listener();\n    }\n  }\n}\n"],"names":["v.parse","ErrorKind.PushFailed","ErrorOrigin.ZeroCache","ErrorReason.Internal","ErrorReason.HTTP","ErrorKind.InvalidPush","ErrorOrigin.Server"],"mappings":"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"}

package/out/zero-client/src/client/mutator-proxy.d.ts

@@ -0,0 +1,16 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { ReadonlyJSONValue } from '../../../shared/src/json.ts';
+import type { ConnectionManager } from './connection-manager.ts';
+import type { MutatorResult } from './custom.ts';
+import { type ZeroError } from './error.ts';
+import type { MutationTracker } from './mutation-tracker.ts';
+export declare class MutatorProxy {
+    #private;
+    constructor(lc: LogContext, connectionManager: ConnectionManager, mutationTracker: MutationTracker);
+    get mutationRejectionError(): ZeroError | undefined;
+    wrapCustomMutator<F extends (...args: [] | [ReadonlyJSONValue]) => {
+        client: Promise<unknown>;
+        server: Promise<unknown>;
+    }>(name: string, f: F): (...args: Parameters<F>) => MutatorResult;
+}
+//# sourceMappingURL=mutator-proxy.d.ts.map

package/out/zero-client/src/client/mutator-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator-proxy.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/mutator-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AAInE,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EACV,aAAa,EAGd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAc,KAAK,SAAS,EAAC,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAY3D,qBAAa,YAAY;;gBAOrB,EAAE,EAAE,UAAU,EACd,iBAAiB,EAAE,iBAAiB,EACpC,eAAe,EAAE,eAAe;IAYlC,IAAI,sBAAsB,IAAI,SAAS,GAAG,SAAS,CAElD;IA0CD,iBAAiB,CACf,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,CAAC,iBAAiB,CAAC,KAAK;QAC/C,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QACzB,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;KAC1B,EACD,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,aAAa;CAwGjE"}

package/out/zero-client/src/client/mutator-proxy.js

@@ -0,0 +1,143 @@
+import { unreachable } from "../../../shared/src/asserts.js";
+import { wrapWithApplicationError } from "../../../zero-protocol/src/application-error.js";
+import { NoSocketOrigin } from "./client-error-kind-enum.js";
+import { Disconnected, NeedsAuth, Connecting, Connected, Closed, Error } from "./connection-status-enum.js";
+import { isZeroError } from "./error.js";
+const successResultDetails = {
+  type: "success"
+};
+const successResult = () => successResultDetails;
+class MutatorProxy {
+  #lc;
+  #connectionManager;
+  #mutationTracker;
+  #mutationRejection;
+  constructor(lc, connectionManager, mutationTracker) {
+    this.#lc = lc;
+    this.#connectionManager = connectionManager;
+    this.#mutationTracker = mutationTracker;
+    this.#connectionManager.subscribe(
+      (state) => this.#onConnectionStateChange(state)
+    );
+    this.#onConnectionStateChange(connectionManager.state);
+  }
+  get mutationRejectionError() {
+    return this.#mutationRejection?.error;
+  }
+  /**
+   * Called when the connection state changes.
+   *
+   * If the connection state is disconnected, error, or closed, the
+   * mutation rejection error is set and all outstanding `.server` promises in
+   * the mutation tracker are rejected with the error.
+   */
+  #onConnectionStateChange(state) {
+    if (state.name === Disconnected && state.reason.kind === NoSocketOrigin) {
+      this.#mutationRejection = void 0;
+      return;
+    }
+    switch (state.name) {
+      case Disconnected:
+      case Error:
+      case Closed:
+        this.#mutationRejection = {
+          error: state.reason,
+          promise: Promise.resolve(
+            this.#makeZeroErrorResultDetails(state.reason)
+          )
+        };
+        this.#mutationTracker.rejectAllOutstandingMutations(state.reason);
+        break;
+      case Connected:
+      case Connecting:
+      case NeedsAuth:
+        this.#mutationRejection = void 0;
+        return;
+      default:
+        unreachable();
+    }
+  }
+  wrapCustomMutator(name, f) {
+    return (...args) => {
+      if (this.#mutationRejection) {
+        return {
+          client: this.#mutationRejection.promise,
+          server: this.#mutationRejection.promise
+        };
+      }
+      let result;
+      const cachedMutationPromises = {};
+      const wrapErrorFor = (origin) => (error) => {
+        const cachedPromise = cachedMutationPromises[origin];
+        if (cachedPromise) {
+          return cachedPromise;
+        }
+        if (isZeroError(error)) {
+          this.#lc.error?.(`Mutator "${name}" error on ${origin}`, error);
+          const zeroErrorPromise = this.#makeZeroErrorResultDetails(error);
+          cachedMutationPromises[origin] = zeroErrorPromise;
+          return zeroErrorPromise;
+        }
+        const applicationError = wrapWithApplicationError(error);
+        this.#lc.error?.(
+          `Mutator "${name}" app error on ${origin}`,
+          applicationError
+        );
+        const applicationErrorPromise = this.#makeApplicationErrorResultDetails(applicationError);
+        cachedMutationPromises[origin] = applicationErrorPromise;
+        return applicationErrorPromise;
+      };
+      try {
+        result = f(...args);
+      } catch (error) {
+        const clientPromise = wrapErrorFor("client")(error);
+        const serverPromise = wrapErrorFor("server")(error);
+        return {
+          client: clientPromise,
+          server: serverPromise
+        };
+      }
+      const client = this.#normalizeResultPromise(
+        result.client,
+        wrapErrorFor("client")
+      );
+      const server = this.#normalizeResultPromise(
+        result.server,
+        wrapErrorFor("server")
+      );
+      return {
+        client,
+        server
+      };
+    };
+  }
+  #normalizeResultPromise(promise, wrapError) {
+    return promise.then(
+      successResult,
+      wrapError
+    );
+  }
+  #makeZeroErrorResultDetails(zeroError) {
+    return Promise.resolve({
+      type: "error",
+      error: {
+        type: "zero",
+        message: zeroError.message
+      }
+    });
+  }
+  #makeApplicationErrorResultDetails(applicationError) {
+    return Promise.resolve({
+      type: "error",
+      error: {
+        type: "app",
+        message: applicationError.message,
+        details: applicationError.details
+      }
+    });
+  }
+}
+export {
+  MutatorProxy
+};
+//# sourceMappingURL=mutator-proxy.js.map

package/out/zero-client/src/client/mutator-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator-proxy.js","sources":["../../../../../zero-client/src/client/mutator-proxy.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {unreachable} from '../../../shared/src/asserts.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport type {ApplicationError} from '../../../zero-protocol/src/application-error.ts';\nimport {wrapWithApplicationError} from '../../../zero-protocol/src/application-error.ts';\nimport {ClientErrorKind} from './client-error-kind.ts';\nimport type {\n  ConnectionManager,\n  ConnectionManagerState,\n} from './connection-manager.ts';\nimport {ConnectionStatus} from './connection-status.ts';\nimport type {\n  MutatorResult,\n  MutatorResultErrorDetails,\n  MutatorResultSuccessDetails,\n} from './custom.ts';\nimport {isZeroError, type ZeroError} from './error.ts';\nimport type {MutationTracker} from './mutation-tracker.ts';\n\nconst successResultDetails = {\n  type: 'success',\n} as const satisfies MutatorResultSuccessDetails;\nconst successResult = () => successResultDetails;\n\ntype CachedMutationRejection = {\n  readonly error: ZeroError;\n  readonly promise: Promise<MutatorResultErrorDetails>;\n};\n\nexport class MutatorProxy {\n  readonly #lc: LogContext;\n  readonly #connectionManager: ConnectionManager;\n  readonly #mutationTracker: MutationTracker;\n  #mutationRejection: CachedMutationRejection | undefined;\n\n  constructor(\n    lc: LogContext,\n    connectionManager: ConnectionManager,\n    mutationTracker: MutationTracker,\n  ) {\n    this.#lc = lc;\n    this.#connectionManager = connectionManager;\n    this.#mutationTracker = mutationTracker;\n\n    this.#connectionManager.subscribe(state =>\n      this.#onConnectionStateChange(state),\n    );\n    this.#onConnectionStateChange(connectionManager.state);\n  }\n\n  get mutationRejectionError(): ZeroError | undefined {\n    return this.#mutationRejection?.error;\n  }\n\n  /**\n   * Called when the connection state changes.\n   *\n   * If the connection state is disconnected, error, or closed, the\n   * mutation rejection error is set and all outstanding `.server` promises in\n   * the mutation tracker are rejected with the error.\n   */\n  #onConnectionStateChange(state: ConnectionManagerState) {\n    // we short circuit the rejection if the error is due to a missing cacheURL\n    // this allows local writes to continue\n    if (\n      state.name === ConnectionStatus.Disconnected &&\n      state.reason.kind === ClientErrorKind.NoSocketOrigin\n    ) {\n      this.#mutationRejection = undefined;\n      return;\n    }\n\n    switch (state.name) {\n      case ConnectionStatus.Disconnected:\n      case ConnectionStatus.Error:\n      case ConnectionStatus.Closed:\n        this.#mutationRejection = {\n          error: state.reason,\n          promise: Promise.resolve(\n            this.#makeZeroErrorResultDetails(state.reason),\n          ),\n        };\n        this.#mutationTracker.rejectAllOutstandingMutations(state.reason);\n        break;\n      case ConnectionStatus.Connected:\n      case ConnectionStatus.Connecting:\n      case ConnectionStatus.NeedsAuth:\n        this.#mutationRejection = undefined;\n        return;\n      default:\n        unreachable(state);\n    }\n  }\n\n  wrapCustomMutator<\n    F extends (...args: [] | [ReadonlyJSONValue]) => {\n      client: Promise<unknown>;\n      server: Promise<unknown>;\n    },\n  >(name: string, f: F): (...args: Parameters<F>) => MutatorResult {\n    return (...args) => {\n      if (this.#mutationRejection) {\n        return {\n          client: this.#mutationRejection.promise,\n          server: this.#mutationRejection.promise,\n        } as const satisfies MutatorResult;\n      }\n\n      let result: {\n        client: Promise<unknown>;\n        server: Promise<unknown>;\n      };\n\n      const cachedMutationPromises: Partial<\n        Record<'client' | 'server', Promise<MutatorResultErrorDetails>>\n      > = {};\n\n      const wrapErrorFor =\n        (origin: 'client' | 'server') =>\n        (error: unknown): Promise<MutatorResultErrorDetails> => {\n          const cachedPromise = cachedMutationPromises[origin];\n          if (cachedPromise) {\n            return cachedPromise;\n          }\n\n          if (isZeroError(error)) {\n            this.#lc.error?.(`Mutator \"${name}\" error on ${origin}`, error);\n\n            const zeroErrorPromise = this.#makeZeroErrorResultDetails(error);\n            cachedMutationPromises[origin] = zeroErrorPromise;\n            return zeroErrorPromise;\n          }\n\n          const applicationError = wrapWithApplicationError(error);\n          this.#lc.error?.(\n            `Mutator \"${name}\" app error on ${origin}`,\n            applicationError,\n          );\n\n          const applicationErrorPromise =\n            this.#makeApplicationErrorResultDetails(applicationError);\n          cachedMutationPromises[origin] = applicationErrorPromise;\n          return applicationErrorPromise;\n        };\n\n      try {\n        result = f(...args);\n      } catch (error) {\n        const clientPromise = wrapErrorFor('client')(error);\n        const serverPromise = wrapErrorFor('server')(error);\n\n        return {\n          client: clientPromise,\n          server: serverPromise,\n        } as const satisfies MutatorResult;\n      }\n\n      const client = this.#normalizeResultPromise(\n        result.client,\n        wrapErrorFor('client'),\n      );\n      const server = this.#normalizeResultPromise(\n        result.server,\n        wrapErrorFor('server'),\n      );\n\n      return {\n        client,\n        server,\n      };\n    };\n  }\n\n  #normalizeResultPromise(\n    promise: Promise<unknown>,\n    wrapError: (error: unknown) => Promise<MutatorResultErrorDetails>,\n  ) {\n    return promise.then<MutatorResultSuccessDetails, MutatorResultErrorDetails>(\n      successResult,\n      wrapError,\n    );\n  }\n\n  #makeZeroErrorResultDetails(zeroError: ZeroError) {\n    return Promise.resolve({\n      type: 'error',\n      error: {\n        type: 'zero',\n        message: zeroError.message,\n      },\n    } as const satisfies MutatorResultErrorDetails);\n  }\n\n  #makeApplicationErrorResultDetails(applicationError: ApplicationError) {\n    return Promise.resolve({\n      type: 'error',\n      error: {\n        type: 'app',\n        message: applicationError.message,\n        details: applicationError.details,\n      },\n    } as const satisfies MutatorResultErrorDetails);\n  }\n}\n"],"names":["ConnectionStatus.Disconnected","ClientErrorKind.NoSocketOrigin","ConnectionStatus.Error","ConnectionStatus.Closed","ConnectionStatus.Connected","ConnectionStatus.Connecting","ConnectionStatus.NeedsAuth"],"mappings":"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"}