cojson 0.13.12 → 0.13.14

package/src/PeerState.ts

@@ -1,9 +1,5 @@
 import { PeerKnownStates, ReadonlyPeerKnownStates } from "./PeerKnownStates.js";
-import {
-  PriorityBasedMessageQueue,
-  QueueEntry,
-} from "./PriorityBasedMessageQueue.js";
-import { TryAddTransactionsError } from "./coValueCore.js";
+import { PriorityBasedMessageQueue } from "./PriorityBasedMessageQueue.js";
 import { RawCoID, SessionID } from "./ids.js";
 import { logger } from "./logger.js";
 import { CO_VALUE_PRIORITY } from "./priority.js";
@@ -12,9 +8,6 @@ import { CoValueKnownState, Peer, SyncMessage } from "./sync.js";
 export class PeerState {
   private queue: PriorityBasedMessageQueue;
 
-  incomingMessagesProcessingPromise: Promise<void> | undefined;
-  nextPeer: Peer | undefined;
-
   constructor(
     private peer: Peer,
     knownStates: ReadonlyPeerKnownStates | undefined,
@@ -156,15 +149,26 @@ export class PeerState {
 
     this.processing = true;
 
-    let entry: QueueEntry | undefined;
-    while ((entry = this.queue.pull())) {
+    let msg: SyncMessage | undefined;
+    while ((msg = this.queue.pull())) {
+      if (this.closed) {
+        break;
+      }
+
       // Awaiting the push to send one message at a time
       // This way when the peer is "under pressure" we can enqueue all
       // the coming messages and organize them by priority
-      await this.peer.outgoing
-        .push(entry.msg)
-        .then(entry.resolve)
-        .catch(entry.reject);
+      try {
+        await this.peer.outgoing.push(msg);
+      } catch (e) {
+        logger.error("Error sending message", {
+          err: e,
+          action: msg.action,
+          id: msg.id,
+          peerId: this.id,
+          peerRole: this.role,
+        });
+      }
     }
 
     this.processing = false;
@@ -172,14 +176,16 @@ export class PeerState {
 
   pushOutgoingMessage(msg: SyncMessage) {
     if (this.closed) {
-      return Promise.resolve();
+      return;
     }
 
-    const promise = this.queue.push(msg);
+    this.queue.push(msg);
 
     void this.processQueue();
+  }
 
-    return promise;
+  isProcessing() {
+    return this.processing;
   }
 
   get incoming() {
@@ -192,14 +198,6 @@ export class PeerState {
     return this.peer.incoming;
   }
 
-  private closeQueue() {
-    let entry: QueueEntry | undefined;
-    while ((entry = this.queue.pull())) {
-      // Using resolve here to avoid unnecessary noise in the logs
-      entry.resolve();
-    }
-  }
-
   closeListeners = new Set<() => void>();
 
   addCloseListener(listener: () => void) {
@@ -228,40 +226,38 @@ export class PeerState {
       peerId: this.id,
       peerRole: this.role,
     });
-    this.closeQueue();
     this.peer.outgoing.close();
     this.closed = true;
     this.emitClose();
   }
 
-  async processIncomingMessages(callback: (msg: SyncMessage) => Promise<void>) {
+  async processIncomingMessages(callback: (msg: SyncMessage) => void) {
     if (this.closed) {
       throw new Error("Peer is closed");
     }
 
-    if (this.incomingMessagesProcessingPromise) {
-      throw new Error("Incoming messages processing already in progress");
-    }
-
     const processIncomingMessages = async () => {
       for await (const msg of this.incoming) {
+        if (this.closed) {
+          return;
+        }
+
         if (msg === "Disconnected") {
-          break;
+          return;
         }
+
         if (msg === "PingTimeout") {
           logger.error("Ping timeout from peer", {
             peerId: this.id,
             peerRole: this.role,
           });
-          break;
+          return;
         }
 
-        await callback(msg);
+        callback(msg);
       }
     };
 
-    this.incomingMessagesProcessingPromise = processIncomingMessages();
-
-    return this.incomingMessagesProcessingPromise;
+    return processIncomingMessages();
   }
 }

package/src/PriorityBasedMessageQueue.ts

@@ -2,29 +2,6 @@ import { Counter, ValueType, metrics } from "@opentelemetry/api";
 import { CO_VALUE_PRIORITY, type CoValuePriority } from "./priority.js";
 import type { SyncMessage } from "./sync.js";
 
-function promiseWithResolvers<R>() {
-  let resolve = (_: R) => {};
-  let reject = (_: unknown) => {};
-
-  const promise = new Promise<R>((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-
-  return {
-    promise,
-    resolve,
-    reject,
-  };
-}
-
-export type QueueEntry = {
-  msg: SyncMessage;
-  promise: Promise<void>;
-  resolve: () => void;
-  reject: (_: unknown) => void;
-};
-
 /**
  * Since we have a fixed range of priority values (0-7) we can create a fixed array of queues.
  */
@@ -34,7 +11,7 @@ type Tuple<T, N extends number, A extends unknown[] = []> = A extends {
   ? A
   : Tuple<T, N, [...A, T]>;
 
-type QueueTuple = Tuple<LinkedList<QueueEntry>, 3>;
+type QueueTuple = Tuple<LinkedList<SyncMessage>, 3>;
 
 type LinkedListNode<T> = {
   value: T;
@@ -164,14 +141,9 @@ export class PriorityBasedMessageQueue {
   }
 
   public push(msg: SyncMessage) {
-    const { promise, resolve, reject } = promiseWithResolvers<void>();
-    const entry: QueueEntry = { msg, promise, resolve, reject };
-
     const priority = "priority" in msg ? msg.priority : this.defaultPriority;
 
-    this.getQueue(priority).push(entry);
-
-    return promise;
+    this.getQueue(priority).push(msg);
   }
 
   public pull() {

package/src/coValueCore.ts

@@ -488,7 +488,7 @@ export class CoValueCore {
 
     if (success) {
       this.node.syncManager.recordTransactionsSize([transaction], "local");
-      void this.node.syncManager.syncCoValue(this);
+      void this.node.syncManager.requestCoValueSync(this);
     }
 
     return success;

package/src/coValueState.ts

@@ -44,21 +44,19 @@ export class CoValueState {
   get highLevelState() {
     if (this.core) {
       return "available";
-    } else {
-      if (this.peers.size === 0) {
-        return "unknown";
-      } else if (
-        this.peers
-          .values()
-          .every((p) => p.type === "unavailable" || p.type === "errored")
-      ) {
-        return "unavailable";
-      } else if (this.peers.values().some((p) => p.type === "pending")) {
+    } else if (this.peers.size === 0) {
+      return "unknown";
+    }
+
+    for (const peer of this.peers.values()) {
+      if (peer.type === "pending") {
         return "loading";
-      } else {
+      } else if (peer.type === "unknown") {
         return "unknown";
       }
     }
+
+    return "unavailable";
   }
 
   isErroredInPeer(peerId: PeerID) {
@@ -143,16 +141,10 @@ export class CoValueState {
           continue;
         }
 
-        peer
-          .pushOutgoingMessage({
-            action: "load",
-            ...(this.core ? this.core.knownState() : emptyKnownState(this.id)),
-          })
-          .catch((err) => {
-            logger.warn(`Failed to push load message to peer ${peer.id}`, {
-              err,
-            });
-          });
+        peer.pushOutgoingMessage({
+          action: "load",
+          ...(this.core ? this.core.knownState() : emptyKnownState(this.id)),
+        });
 
         /**
          * Use a very long timeout for storage peers, because under pressure

package/src/localNode.ts

@@ -140,7 +140,9 @@ export class LocalNode {
     function syncAllCoValuesAfterCreateAccount() {
       for (const coValueEntry of nodeWithAccount.coValuesStore.getValues()) {
         if (coValueEntry.isAvailable()) {
-          void nodeWithAccount.syncManager.syncCoValue(coValueEntry.core);
+          void nodeWithAccount.syncManager.requestCoValueSync(
+            coValueEntry.core,
+          );
         }
       }
     }
@@ -248,7 +250,7 @@ export class LocalNode {
     const coValue = new CoValueCore(header, this);
     this.coValuesStore.internalMarkMagicallyAvailable(coValue.id, coValue);
 
-    void this.syncManager.syncCoValue(coValue);
+    void this.syncManager.requestCoValueSync(coValue);
 
     return coValue;
   }

package/src/streamUtils.ts

@@ -7,8 +7,8 @@ export function connectedPeers(
   peer2id: PeerID,
   {
     trace = false,
-    peer1role = "peer",
-    peer2role = "peer",
+    peer1role = "client",
+    peer2role = "client",
     crashOnClose = false,
   }: {
     trace?: boolean;

package/src/sync.ts

@@ -78,7 +78,7 @@ export interface Peer {
   id: PeerID;
   incoming: IncomingSyncStream;
   outgoing: OutgoingSyncQueue;
-  role: "peer" | "server" | "client" | "storage";
+  role: "server" | "client" | "storage";
   priority?: number;
   crashOnClose: boolean;
   deletePeerStateOnClose?: boolean;
@@ -112,11 +112,6 @@ export function combinedKnownStates(
 export class SyncManager {
   peers: { [key: PeerID]: PeerState } = {};
   local: LocalNode;
-  requestedSyncs: {
-    [id: RawCoID]:
-      | { done: Promise<void>; nRequestsThisTick: number }
-      | undefined;
-  } = {};
 
   peersCounter = metrics.getMeter("cojson").createUpDownCounter("jazz.peers", {
     description: "Amount of connected peers",
@@ -162,7 +157,7 @@ export class SyncManager {
     );
   }
 
-  async handleSyncMessage(msg: SyncMessage, peer: PeerState) {
+  handleSyncMessage(msg: SyncMessage, peer: PeerState) {
     if (this.local.coValuesStore.get(msg.id).isErroredInPeer(peer.id)) {
       logger.warn(
         `Skipping message ${msg.action} on errored coValue ${msg.id} from peer ${peer.id}`,
@@ -183,18 +178,17 @@ export class SyncManager {
     // TODO: validate
     switch (msg.action) {
       case "load":
-        return await this.handleLoad(msg, peer);
+        return this.handleLoad(msg, peer);
       case "known":
         if (msg.isCorrection) {
-          return await this.handleCorrection(msg, peer);
+          return this.handleCorrection(msg, peer);
         } else {
-          return await this.handleKnownState(msg, peer);
+          return this.handleKnownState(msg, peer);
         }
       case "content":
-        // await new Promise<void>((resolve) => setTimeout(resolve, 0));
-        return await this.handleNewContent(msg, peer);
+        return this.handleNewContent(msg, peer);
       case "done":
-        return await this.handleUnsubscribe(msg);
+        return this.handleUnsubscribe(msg);
       default:
         throw new Error(
           `Unknown message type ${(msg as { action: "string" }).action}`,
@@ -202,14 +196,12 @@ export class SyncManager {
     }
   }
 
-  async sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
+  sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
     const coValue = this.local.expectCoValueLoaded(id);
 
-    await Promise.all(
-      coValue
-        .getDependedOnCoValues()
-        .map((id) => this.sendNewContentIncludingDependencies(id, peer)),
-    );
+    coValue
+      .getDependedOnCoValues()
+      .map((id) => this.sendNewContentIncludingDependencies(id, peer));
 
     const newContentPieces = coValue.newContentSince(
       peer.optimisticKnownStates.get(id),
@@ -217,9 +209,7 @@ export class SyncManager {
 
     if (newContentPieces) {
       for (const piece of newContentPieces) {
-        this.trySendToPeer(peer, piece).catch((e: unknown) => {
-          logger.error("Error sending content piece", { err: e });
-        });
+        this.trySendToPeer(peer, piece);
       }
 
       peer.toldKnownState.add(id);
@@ -228,15 +218,13 @@ export class SyncManager {
       this.trySendToPeer(peer, {
         action: "known",
         ...coValue.knownState(),
-      }).catch((e: unknown) => {
-        logger.error("Error sending known state", { err: e });
       });
 
       peer.toldKnownState.add(id);
     }
   }
 
-  async startPeerReconciliation(peer: PeerState) {
+  startPeerReconciliation(peer: PeerState) {
     const coValuesOrderedByDependency: CoValueCore[] = [];
 
     const gathered = new Set<string>();
@@ -264,8 +252,12 @@ export class SyncManager {
         // If the coValue is unavailable and we never tried this peer
         // we try to load it from the peer
         if (!peer.toldKnownState.has(entry.id)) {
-          await entry.loadFromPeers([peer]).catch((e: unknown) => {
-            logger.error("Error sending load", { err: e });
+          peer.toldKnownState.add(entry.id);
+          this.trySendToPeer(peer, {
+            action: "load",
+            header: false,
+            id: entry.id,
+            sessions: {},
           });
         }
       } else {
@@ -293,33 +285,15 @@ export class SyncManager {
       this.trySendToPeer(peer, {
         action: "load",
         ...coValue.knownState(),
-      }).catch((e: unknown) => {
-        logger.error("Error sending load", { err: e });
       });
     }
   }
 
-  nextPeer: Map<PeerID, Peer> = new Map();
-
   async addPeer(peer: Peer) {
     const prevPeer = this.peers[peer.id];
 
-    if (prevPeer) {
-      // Assign to nextPeer to check against race conditions
-      prevPeer.nextPeer = peer;
-
-      if (!prevPeer.closed) {
-        prevPeer.gracefulShutdown();
-      }
-
-      // Wait for the previous peer to finish processing the incoming messages
-      await prevPeer.incomingMessagesProcessingPromise?.catch((e) => {});
-
-      // If another peer was added in the meantime, we close this peer
-      if (prevPeer.nextPeer !== peer) {
-        peer.outgoing.close();
-        return;
-      }
+    if (prevPeer && !prevPeer.closed) {
+      prevPeer.gracefulShutdown();
     }
 
     const peerState = new PeerState(peer, prevPeer?.knownStates);
@@ -338,8 +312,8 @@ export class SyncManager {
     }
 
     peerState
-      .processIncomingMessages(async (msg) => {
-        await this.handleSyncMessage(msg, peerState);
+      .processIncomingMessages((msg) => {
+        this.handleSyncMessage(msg, peerState);
       })
       .then(() => {
         if (peer.crashOnClose) {
@@ -386,7 +360,7 @@ export class SyncManager {
    * - The peer known state is stored as-is instead of being merged
    * - The load message always replies with a known state message
    */
-  async handleLoad(msg: LoadMessage, peer: PeerState) {
+  handleLoad(msg: LoadMessage, peer: PeerState) {
     /**
      * We use the msg sessions as source of truth for the known states
      *
@@ -413,8 +387,6 @@ export class SyncManager {
           id: msg.id,
           header: false,
           sessions: {},
-        }).catch((e) => {
-          logger.error("Error sending known state back", { err: e });
         });
 
         return;
@@ -442,14 +414,12 @@ export class SyncManager {
               id: msg.id,
               header: false,
               sessions: {},
-            }).catch((e) => {
-              logger.error("Error sending known state back", { err: e });
             });
 
             return;
           }
 
-          await this.sendNewContentIncludingDependencies(msg.id, peer);
+          this.sendNewContentIncludingDependencies(msg.id, peer);
         })
         .catch((e) => {
           logger.error("Error loading coValue in handleLoad loading state", {
@@ -457,7 +427,7 @@ export class SyncManager {
           });
         });
     } else if (entry.isAvailable()) {
-      await this.sendNewContentIncludingDependencies(msg.id, peer);
+      this.sendNewContentIncludingDependencies(msg.id, peer);
     } else {
       this.trySendToPeer(peer, {
         action: "known",
@@ -468,7 +438,7 @@ export class SyncManager {
     }
   }
 
-  async handleKnownState(msg: KnownStateMessage, peer: PeerState) {
+  handleKnownState(msg: KnownStateMessage, peer: PeerState) {
     const entry = this.local.coValuesStore.get(msg.id);
 
     peer.combineWith(msg.id, knownStateIn(msg));
@@ -482,7 +452,7 @@ export class SyncManager {
     }
 
     if (entry.isAvailable()) {
-      await this.sendNewContentIncludingDependencies(msg.id, peer);
+      this.sendNewContentIncludingDependencies(msg.id, peer);
     }
   }
 
@@ -499,7 +469,7 @@ export class SyncManager {
     }
   }
 
-  async handleNewContent(msg: NewContentMessage, peer: PeerState) {
+  handleNewContent(msg: NewContentMessage, peer: PeerState) {
     const entry = this.local.coValuesStore.get(msg.id);
 
     let coValue: CoValueCore;
@@ -512,12 +482,6 @@ export class SyncManager {
           id: msg.id,
           header: false,
           sessions: {},
-        }).catch((e) => {
-          logger.error("Error sending known state correction", {
-            peerId: peer.id,
-            peerRole: peer.role,
-            err: e,
-          });
         });
         return;
       }
@@ -590,12 +554,6 @@ export class SyncManager {
         action: "known",
         isCorrection: true,
         ...coValue.knownState(),
-      }).catch((e) => {
-        logger.error("Error sending known state correction", {
-          peerId: peer.id,
-          peerRole: peer.role,
-          err: e,
-        });
       });
       peer.toldKnownState.add(msg.id);
     } else {
@@ -609,12 +567,6 @@ export class SyncManager {
       this.trySendToPeer(peer, {
         action: "known",
         ...coValue.knownState(),
-      }).catch((e: unknown) => {
-        logger.error("Error sending known state", {
-          peerId: peer.id,
-          peerRole: peer.role,
-          err: e,
-        });
       });
       peer.toldKnownState.add(msg.id);
     }
@@ -624,51 +576,54 @@ export class SyncManager {
      * response to the peers that are waiting for confirmation that a coValue is
      * fully synced
      */
-    this.syncCoValue(coValue);
+    this.requestCoValueSync(coValue);
   }
 
-  async handleCorrection(msg: KnownStateMessage, peer: PeerState) {
+  handleCorrection(msg: KnownStateMessage, peer: PeerState) {
     peer.setKnownState(msg.id, knownStateIn(msg));
 
     return this.sendNewContentIncludingDependencies(msg.id, peer);
   }
 
-  handleUnsubscribe(_msg: DoneMessage) {
-    throw new Error("Method not implemented.");
-  }
+  handleUnsubscribe(_msg: DoneMessage) {}
 
-  async syncCoValue(coValue: CoValueCore) {
-    if (this.requestedSyncs[coValue.id]) {
-      this.requestedSyncs[coValue.id]!.nRequestsThisTick++;
-      return this.requestedSyncs[coValue.id]!.done;
+  requestedSyncs = new Map<RawCoID, Promise<void>>();
+
+  async requestCoValueSync(coValue: CoValueCore) {
+    const promise = this.requestedSyncs.get(coValue.id);
+
+    if (promise) {
+      return promise;
     } else {
-      const done = new Promise<void>((resolve) => {
-        queueMicrotask(async () => {
-          delete this.requestedSyncs[coValue.id];
-          await this.actuallySyncCoValue(coValue);
+      const promise = new Promise<void>((resolve) => {
+        queueMicrotask(() => {
+          this.requestedSyncs.delete(coValue.id);
+          this.syncCoValue(coValue);
           resolve();
         });
       });
-      const entry = {
-        done,
-        nRequestsThisTick: 1,
-      };
-      this.requestedSyncs[coValue.id] = entry;
-      return done;
+
+      this.requestedSyncs.set(coValue.id, promise);
+      return promise;
     }
   }
 
-  async actuallySyncCoValue(coValue: CoValueCore) {
+  async syncCoValue(coValue: CoValueCore) {
+    const entry = this.local.coValuesStore.get(coValue.id);
+
     for (const peer of this.peersInPriorityOrder()) {
       if (peer.closed) continue;
-      if (this.local.coValuesStore.get(coValue.id).isErroredInPeer(peer.id))
-        continue;
+      if (entry.isErroredInPeer(peer.id)) continue;
 
-      if (peer.optimisticKnownStates.has(coValue.id)) {
-        await this.sendNewContentIncludingDependencies(coValue.id, peer);
-      } else if (peer.isServerOrStoragePeer()) {
-        await this.sendNewContentIncludingDependencies(coValue.id, peer);
+      // Only subscribed CoValues are synced to clients
+      if (
+        peer.role === "client" &&
+        !peer.optimisticKnownStates.has(coValue.id)
+      ) {
+        continue;
       }
+
+      this.sendNewContentIncludingDependencies(coValue.id, peer);
     }
 
     for (const peer of this.getPeers()) {