@rocicorp/zero 0.22.2025071100 → 0.22.2025071101

package/out/{chunk-ZVMEFHVU.js → chunk-4FQJO7OM.js}

@@ -1,6 +1,6 @@
 import {
   clientToServer
-} from "./chunk-ZRSXCDPE.js";
+} from "./chunk-5A6QECBY.js";
 import {
   AbstractQuery,
   ExpressionBuilder,
@@ -337,4 +337,4 @@ export {
   querify,
   namedQuery
 };
-//# sourceMappingURL=chunk-ZVMEFHVU.js.map
+//# sourceMappingURL=chunk-4FQJO7OM.js.map

package/out/{chunk-ZRSXCDPE.js → chunk-5A6QECBY.js}

@@ -5916,7 +5916,8 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
     initConnectionMessage,
     authToken
   };
-  return encodeURIComponent(btoa(JSON.stringify(protocols)));
+  const bytes = new TextEncoder().encode(JSON.stringify(protocols));
+  return encodeURIComponent(btoa(String.fromCharCode(...bytes)));
 }
 
 // ../zero-protocol/src/error.ts
@@ -8537,7 +8538,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.22.2025071100";
+var version2 = "0.22.2025071101";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -8833,9 +8834,7 @@ var State = class {
 
 // ../zero-client/src/client/mutation-tracker.ts
 import { resolver as resolver8 } from "@rocicorp/resolver";
-var transientPushErrorTypes = [
-  "zeroPusher",
-  "http",
+var completeFailureTypes = [
   // These should never actually be received as they cause the websocket
   // connection to be closed.
   "unsupportedPushVersion",
@@ -8848,14 +8847,20 @@ function nextEphemeralID() {
 var MutationTracker = class {
   #outstandingMutations;
   #ephemeralIDsByMutationID;
-  #allMutationsConfirmedListeners;
+  #allMutationsAppliedListeners;
   #lc;
+  #limboMutations;
   #clientID;
+  #largestOutstandingMutationID;
+  #currentMutationID;
   constructor(lc) {
     this.#lc = lc.withContext("MutationTracker");
     this.#outstandingMutations = /* @__PURE__ */ new Map();
     this.#ephemeralIDsByMutationID = /* @__PURE__ */ new Map();
-    this.#allMutationsConfirmedListeners = /* @__PURE__ */ new Set();
+    this.#allMutationsAppliedListeners = /* @__PURE__ */ new Set();
+    this.#limboMutations = /* @__PURE__ */ new Set();
+    this.#largestOutstandingMutationID = 0;
+    this.#currentMutationID = 0;
   }
   set clientID(clientID) {
     this.#clientID = clientID;
@@ -8873,6 +8878,10 @@ var MutationTracker = class {
     if (entry) {
       entry.mutationID = mutationID;
       this.#ephemeralIDsByMutationID.set(mutationID, id);
+      this.#largestOutstandingMutationID = Math.max(
+        this.#largestOutstandingMutationID,
+        mutationID
+      );
     }
   }
   /**
@@ -8904,7 +8913,7 @@ var MutationTracker = class {
    * to those mutations have been lost.
    *
    * An example case: the API server responds while the connection
-   * is down. Those responses are dropped.
+   * 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
@@ -8913,9 +8922,6 @@ var MutationTracker = class {
    * 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.
-   *
-   * This would have the downside of not being able to provide responses to a
-   * mutation with data gathered after the transaction.
    */
   onConnected(lastMutationID) {
     for (const [id, entry] of this.#outstandingMutations) {
@@ -8928,12 +8934,78 @@ var MutationTracker = class {
         break;
       }
     }
+    for (const [id, entry] of this.#outstandingMutations) {
+      if (entry.mutationID && entry.mutationID > lastMutationID) {
+        this.#limboMutations.add(id);
+      }
+    }
+    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 limbo mutations whose mutation ID is less than or equal to
+   *    the lastMutationID.
+   *
+   * We only resolve "limbo mutations" since we want to give the mutation
+   * responses a chance to be received. `poke` and `pushResponse` are non transactional
+   * so they race.
+   *
+   * E.g., a `push` may call the api server which:
+   * writes to PG, replicates to zero-cache, then pokes the lmid down before the
+   * push response is sent.
+   *
+   * The only fix for this would be to have mutation responses be written to the database
+   * and sent down through the poke protocol.
+   *
+   * The artifact the user sees is that promise resolutions for mutations is not transactional
+   * with the update to synced data.
+   *
+   * It was a mistake to not just write the mutation responses to the database
+   * in the first place as this route ends up being more complicated
+   * and less reliable.
+   */
+  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.#resolveLimboMutations(lastMutationID);
+    } finally {
+      if (lastMutationID >= this.#largestOutstandingMutationID) {
+        this.#notifyAllMutationsAppliedListeners();
+      }
+    }
   }
   get size() {
     return this.#outstandingMutations.size;
   }
+  /**
+   * Push errors fall into two categories:
+   * - Those where we know the mutations were not applied
+   * - Those where we do not know the state of the mutations.
+   *
+   * The first category includes errors like "unsupportedPushVersion"
+   * and "unsupportedSchemaVersion". The mutations were never applied in those cases.
+   *
+   * The second category includes errors like "http" errors. E.g., a 500 on the user's
+   * API server or a network error.
+   *
+   * The mutations may have been applied by the API server but we never
+   * received the response.
+   *
+   * In this latter case, we must mark the mutations as being in limbo.
+   * This allows us to resolve them when we receive the next
+   * lmid bump if their lmids are lesser.
+   */
   #processPushError(error) {
-    if (transientPushErrorTypes.includes(error.error)) {
+    if (completeFailureTypes.includes(error.error)) {
       return;
     }
     const mids = error.mutationIDs;
@@ -8941,7 +9013,30 @@ var MutationTracker = class {
       return;
     }
     for (const mid of mids) {
-      this.#processMutationError(mid, error);
+      const ephemeralID = this.#ephemeralIDsByMutationID.get(mid.id);
+      if (ephemeralID) {
+        if (mid.id <= this.#currentMutationID) {
+          const entry = this.#outstandingMutations.get(ephemeralID);
+          if (entry) {
+            this.#settleMutation(ephemeralID, entry, "resolve", emptyObject);
+          }
+          continue;
+        }
+        this.#limboMutations.add(ephemeralID);
+      }
+    }
+  }
+  #resolveLimboMutations(lastMutationID) {
+    for (const id of this.#limboMutations) {
+      const entry = this.#outstandingMutations.get(id);
+      if (!entry || !entry.mutationID) {
+        this.#limboMutations.delete(id);
+        continue;
+      }
+      if (entry.mutationID <= lastMutationID) {
+        this.#limboMutations.delete(id);
+        this.#settleMutation(id, entry, "resolve", emptyObject);
+      }
     }
   }
   #processPushOk(ok) {
@@ -8994,19 +9089,27 @@ var MutationTracker = class {
         entry.resolver.reject(result);
         break;
     }
-    const removed = this.#outstandingMutations.delete(ephemeralID);
+    this.#outstandingMutations.delete(ephemeralID);
     if (entry.mutationID) {
       this.#ephemeralIDsByMutationID.delete(entry.mutationID);
     }
-    if (removed && this.#outstandingMutations.size === 0) {
-      this.#notifyAllMutationsConfirmedListeners();
-    }
+    this.#limboMutations.delete(ephemeralID);
   }
-  onAllMutationsConfirmed(listener) {
-    this.#allMutationsConfirmedListeners.add(listener);
+  /**
+   * 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);
   }
-  #notifyAllMutationsConfirmedListeners() {
-    for (const listener of this.#allMutationsConfirmedListeners) {
+  #notifyAllMutationsAppliedListeners() {
+    for (const listener of this.#allMutationsAppliedListeners) {
       listener();
     }
   }
@@ -9039,7 +9142,7 @@ var QueryManager = class {
     this.#send = send2;
     this.#mutationTracker = mutationTracker;
     this.#queryChangeThrottleMs = queryChangeThrottleMs;
-    this.#mutationTracker.onAllMutationsConfirmed(() => {
+    this.#mutationTracker.onAllMutationsApplied(() => {
       if (this.#pendingRemovals.length === 0) {
         return;
       }
@@ -10735,6 +10838,7 @@ var Zero = class _Zero {
   #handlePokeEnd(_lc, pokeMessage) {
     this.#abortPingTimeout();
     this.#pokeHandler.handlePokeEnd(pokeMessage[1]);
+    this.#mutationTracker.lmidAdvanced(this.#lastMutationIDReceived);
   }
   #onPokeError() {
     const lc = this.#lc;
@@ -11241,4 +11345,4 @@ export {
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-ZRSXCDPE.js.map
+//# sourceMappingURL=chunk-5A6QECBY.js.map