cojson 0.18.28 → 0.18.30

package/src/sync.ts

@@ -229,7 +229,7 @@ export class SyncManager {
     }
 
     const newContentPieces = coValue.verified.newContentSince(
-      peer.optimisticKnownStates.get(id),
+      peer.getOptimisticKnownState(id),
     );
 
     if (newContentPieces) {
@@ -306,8 +306,8 @@ export class SyncManager {
       }
 
       // Fill the missing known states with empty known states
-      if (!peer.optimisticKnownStates.has(coValue.id)) {
-        peer.setOptimisticKnownState(coValue.id, "empty");
+      if (!peer.getKnownState(coValue.id)) {
+        peer.setKnownState(coValue.id, "empty");
       }
     }
 
@@ -342,20 +342,18 @@ export class SyncManager {
   addPeer(peer: Peer, skipReconciliation: boolean = false) {
     const prevPeer = this.peers[peer.id];
 
-    if (prevPeer && !prevPeer.closed) {
-      prevPeer.gracefulShutdown();
-    }
+    const peerState = prevPeer
+      ? prevPeer.newPeerStateFrom(peer)
+      : new PeerState(peer, undefined);
 
-    const peerState = new PeerState(peer, prevPeer?.knownStates);
     this.peers[peer.id] = peerState;
 
     this.peersCounter.add(1, { role: peer.role });
 
-    const unsubscribeFromKnownStatesUpdates = peerState.knownStates.subscribe(
-      (id) => {
-        this.syncState.triggerUpdate(peer.id, id);
-      },
-    );
+    const unsubscribeFromKnownStatesUpdates =
+      peerState.subscribeToKnownStatesUpdates((id, knownState) => {
+        this.syncState.triggerUpdate(peer.id, id, knownState.value());
+      });
 
     if (!skipReconciliation && peerState.role === "server") {
       void this.startPeerReconciliation(peerState);
@@ -450,7 +448,7 @@ export class SyncManager {
 
     // The header is a boolean value that tells us if the other peer do have information about the header.
     // If it's false in this point it means that the coValue is unavailable on the other peer.
-    const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
+    const availableOnPeer = peer.getOptimisticKnownState(msg.id)?.header;
 
     if (!availableOnPeer) {
       coValue.markNotFoundInPeer(peer.id);
@@ -598,7 +596,7 @@ export class SyncManager {
 
     let invalidStateAssumed = false;
 
-    const contentToStore: NewContentMessage = {
+    const validNewContent: NewContentMessage = {
       action: "content",
       id: msg.id,
       priority: msg.priority,
@@ -667,13 +665,12 @@ export class SyncManager {
 
       // The new content for this session has been verified, so we can store it
       if (result.value) {
-        contentToStore.new[sessionID] = newContentForSession;
+        validNewContent.new[sessionID] = newContentForSession;
       }
+    }
 
-      const transactionsCount =
-        newContentForSession.after +
-        newContentForSession.newTransactions.length;
-      peer?.updateSessionCounter(msg.id, sessionID, transactionsCount);
+    if (peer) {
+      peer.combineWith(msg.id, knownStateFromContent(validNewContent));
     }
 
     /**
@@ -718,10 +715,10 @@ export class SyncManager {
      * Store the content and propagate it to the server peers and the subscribed client peers
      */
     const hasNewContent =
-      contentToStore.header || Object.keys(contentToStore.new).length > 0;
+      validNewContent.header || Object.keys(validNewContent.new).length > 0;
 
     if (from !== "storage" && hasNewContent) {
-      this.storeContent(contentToStore);
+      this.storeContent(validNewContent);
     }
 
     for (const peer of this.getPeers(coValue.id)) {
@@ -729,11 +726,13 @@ export class SyncManager {
        * We sync the content against the source peer if it is a client or server peers
        * to upload any content that is available on the current node and not on the source peer.
        */
-      if (peer.closed) continue;
-      if (coValue.isErroredInPeer(peer.id)) continue;
+      if (peer.closed || coValue.isErroredInPeer(peer.id)) {
+        peer.emitCoValueChange(coValue.id);
+        continue;
+      }
 
       // We directly forward the new content to peers that have an active subscription
-      if (peer.optimisticKnownStates.has(coValue.id)) {
+      if (peer.isCoValueSubscribedToPeer(coValue.id)) {
         this.sendNewContent(coValue.id, peer);
         syncedPeers.push(peer);
       } else if (
@@ -756,13 +755,6 @@ export class SyncManager {
         }
       }
     }
-
-    /**
-     * Send an update to all the sync state listeners
-     */
-    for (const peer of syncedPeers) {
-      this.syncState.triggerUpdate(peer.id, coValue.id);
-    }
   }
 
   handleCorrection(msg: KnownStateMessage, peer: PeerState) {
@@ -786,27 +778,25 @@ export class SyncManager {
     const contentKnownState = knownStateFromContent(content);
 
     for (const peer of this.getPeers(coValue.id)) {
-      if (peer.closed) continue;
-      if (coValue.isErroredInPeer(peer.id)) continue;
-
       // Only subscribed CoValues are synced to clients
       if (
         peer.role === "client" &&
-        !peer.optimisticKnownStates.has(coValue.id)
+        !peer.isCoValueSubscribedToPeer(coValue.id)
       ) {
         continue;
       }
 
+      if (peer.closed || coValue.isErroredInPeer(peer.id)) {
+        peer.emitCoValueChange(content.id);
+        continue;
+      }
+
       // We assume that the peer already knows anything before this content
       // Any eventual reconciliation will be handled through the known state messages exchange
       this.trySendToPeer(peer, content);
       peer.combineOptimisticWith(coValue.id, contentKnownState);
       peer.trackToldKnownState(coValue.id);
     }
-
-    for (const peer of this.getPeers(coValue.id)) {
-      this.syncState.triggerUpdate(peer.id, coValue.id);
-    }
   }
 
   private storeContent(content: NewContentMessage) {
@@ -837,15 +827,6 @@ export class SyncManager {
   }
 
   waitForSyncWithPeer(peerId: PeerID, id: RawCoID, timeout: number) {
-    const { syncState } = this;
-    const currentSyncState = syncState.getCurrentSyncState(peerId, id);
-
-    const isTheConditionAlreadyMet = currentSyncState.uploaded;
-
-    if (isTheConditionAlreadyMet) {
-      return;
-    }
-
     const peerState = this.peers[peerId];
 
     // The peer has been closed and is not persistent, so it isn't possible to sync
@@ -853,11 +834,14 @@ export class SyncManager {
       return;
     }
 
-    // The client isn't subscribed to the coValue, so we won't sync it
-    if (
-      peerState.role === "client" &&
-      !peerState.optimisticKnownStates.has(id)
-    ) {
+    if (peerState.isCoValueSubscribedToPeer(id)) {
+      const isAlreadySynced = this.syncState.isSynced(peerState, id);
+
+      if (isAlreadySynced) {
+        return;
+      }
+    } else if (peerState.role === "client") {
+      // The client isn't subscribed to the coValue, so we won't sync it
       return;
     }
 

package/src/tests/PeerKnownState.test.ts

@@ -0,0 +1,426 @@
+import { describe, expect, test } from "vitest";
+import { PeerKnownState } from "../coValueCore/PeerKnownState.js";
+import type { CoValueKnownState } from "../knownState.js";
+import { cloneKnownState } from "../knownState.js";
+import { RawCoID, SessionID } from "../ids.js";
+import type { PeerID } from "../sync.js";
+
+describe("PeerKnownState", () => {
+  const testId = "co_ztest123" as RawCoID;
+  const testPeerId = "peer123" as PeerID;
+  const session1 = "session1_session_z123" as SessionID;
+  const session2 = "session2_session_z456" as SessionID;
+
+  describe("constructor", () => {
+    test("should initialize with correct peerId and empty knownState", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      expect(peerKnownState.peerId).toBe(testPeerId);
+      expect(peerKnownState.value()).toEqual({
+        id: testId,
+        header: false,
+        sessions: {},
+      });
+      expect(peerKnownState.optimisticValue()).toEqual({
+        id: testId,
+        header: false,
+        sessions: {},
+      });
+    });
+
+    test("should maintain knownState reference", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      // Verify that the reference is preserved by checking that modifications
+      // to the returned object affect subsequent calls to value()
+      const state1 = peerKnownState.value();
+      const state2 = peerKnownState.value();
+      expect(state1).toBe(state2); // Same reference
+      expect(state1).toBe(initialKnownState); // Same as initial reference
+    });
+  });
+
+  describe("updateHeader", () => {
+    test("should update header in knownState when no optimistic state exists", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      peerKnownState.updateHeader(true);
+
+      expect(peerKnownState.value().header).toBe(true);
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+    });
+
+    test("should update header in both knownState and optimisticKnownState", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      // Create optimistic state first
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 5 },
+      });
+
+      const knownStateRef = peerKnownState.value();
+      const optimisticStateRef = peerKnownState.optimisticValue();
+
+      peerKnownState.updateHeader(true);
+
+      expect(peerKnownState.value().header).toBe(true);
+      expect(peerKnownState.optimisticValue().header).toBe(true);
+      expect(peerKnownState.value()).toBe(knownStateRef); // Reference preserved
+      expect(peerKnownState.optimisticValue()).toBe(optimisticStateRef); // Reference preserved
+    });
+
+    test("should update header to false", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      peerKnownState.updateHeader(true);
+
+      peerKnownState.updateHeader(false);
+
+      expect(peerKnownState.value().header).toBe(false);
+      expect(peerKnownState.optimisticValue().header).toBe(false);
+    });
+  });
+
+  describe("combineWith", () => {
+    test("should combine sessions and header correctly", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      const toCombine: CoValueKnownState = {
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5, [session2]: 10 },
+      };
+
+      peerKnownState.combineWith(toCombine);
+
+      expect(peerKnownState.value()).toEqual({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5, [session2]: 10 },
+      });
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+    });
+
+    test("should update existing sessions with higher values", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      // Set initial state
+      peerKnownState.combineWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 3, [session2]: 5 },
+      });
+
+      // Combine with higher values for session1, lower for session2
+      peerKnownState.combineWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 7, [session2]: 2 },
+      });
+
+      expect(peerKnownState.value().sessions[session1]).toBe(7); // Updated to higher value
+      expect(peerKnownState.value().sessions[session2]).toBe(5); // Kept higher existing value
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+    });
+
+    test("should update optimisticKnownState when it exists", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      // Create optimistic state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 3 },
+      });
+
+      const optimisticStateRef = peerKnownState.optimisticValue();
+
+      peerKnownState.combineWith({
+        id: testId,
+        header: true,
+        sessions: { [session2]: 10 },
+      });
+
+      expect(peerKnownState.optimisticValue().sessions[session1]).toBe(3); // From optimistic state
+      expect(peerKnownState.optimisticValue().sessions[session2]).toBe(10); // Combined
+      expect(peerKnownState.optimisticValue().header).toBe(true); // Combined header
+      expect(peerKnownState.optimisticValue()).toBe(optimisticStateRef); // Reference preserved
+    });
+  });
+
+  describe("combineOptimisticWith", () => {
+    test("should create optimisticKnownState when none exists", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      const toCombine: CoValueKnownState = {
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      };
+
+      peerKnownState.combineOptimisticWith(toCombine);
+
+      expect(peerKnownState.optimisticValue()).toEqual({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+      // Should be a different object from knownState
+      expect(peerKnownState.optimisticValue()).not.toBe(peerKnownState.value());
+      // Should not affect the known state
+      expect(peerKnownState.value()).toEqual(initialKnownState);
+    });
+
+    test("should combine with existing optimisticKnownState", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      // Create initial optimistic state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 3 },
+      });
+
+      const optimisticStateRef = peerKnownState.optimisticValue();
+
+      // Combine with additional state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session2]: 7 },
+      });
+
+      expect(peerKnownState.optimisticValue()).toEqual({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 3, [session2]: 7 },
+      });
+      expect(peerKnownState.optimisticValue()).toBe(optimisticStateRef); // Reference preserved
+    });
+
+    test("should preserve knownState when combining optimistic", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 10 },
+      });
+
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+      expect(peerKnownState.value().sessions).toEqual({}); // Known state unchanged
+    });
+  });
+
+  describe("set", () => {
+    test("should set knownState with provided CoValueKnownState", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      // Create optimistic state first
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 5 },
+      });
+
+      const newState: CoValueKnownState = {
+        id: testId,
+        header: true,
+        sessions: { [session1]: 10, [session2]: 20 },
+      };
+
+      peerKnownState.set(newState);
+
+      expect(peerKnownState.value()).toEqual(newState);
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+      expect(peerKnownState.optimisticValue()).toBe(peerKnownState.value()); // Should return knownState when optimistic is cleared
+    });
+
+    test("should handle shallow copy of sessions in set", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const initialKnownState = peerKnownState.value();
+
+      const sessions = { [session1]: 5, [session2]: 10 };
+      const newState: CoValueKnownState = {
+        id: testId,
+        header: true,
+        sessions,
+      };
+
+      peerKnownState.set(newState);
+
+      expect(peerKnownState.value().sessions).toEqual(sessions);
+      expect(peerKnownState.value().sessions).not.toBe(sessions); // Should be a copy
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+    });
+
+    test("should set empty state when payload is 'empty'", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      // Set some initial state
+      peerKnownState.combineWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+
+      // Create optimistic state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: false,
+        sessions: { [session2]: 10 },
+      });
+
+      const initialKnownState = peerKnownState.value();
+      peerKnownState.set("empty");
+
+      expect(peerKnownState.value()).toEqual({
+        id: testId,
+        header: false,
+        sessions: {},
+      });
+      expect(peerKnownState.value()).toBe(initialKnownState); // Reference preserved
+      expect(peerKnownState.optimisticValue()).toBe(peerKnownState.value()); // Should return knownState when optimistic is cleared
+    });
+
+    test("should clear optimisticKnownState on set", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      // Create optimistic state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+
+      expect(peerKnownState.optimisticValue()).toBeDefined();
+      expect(peerKnownState.optimisticValue()).not.toBe(peerKnownState.value());
+
+      peerKnownState.set("empty");
+
+      expect(peerKnownState.optimisticValue()).toBe(peerKnownState.value()); // Should return knownState when optimistic is cleared
+    });
+  });
+
+  describe("value", () => {
+    test("should return the current knownState", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const state1 = peerKnownState.value();
+      const state2 = peerKnownState.value();
+
+      expect(state1).toBe(state2); // Same reference
+      expect(state1).toEqual({
+        id: testId,
+        header: false,
+        sessions: {},
+      });
+    });
+
+    test("should return updated knownState after modifications", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      peerKnownState.combineWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+
+      expect(peerKnownState.value()).toEqual({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+    });
+  });
+
+  describe("optimisticValue", () => {
+    test("should return knownState when no optimistic state exists", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      expect(peerKnownState.optimisticValue()).toBe(peerKnownState.value());
+    });
+
+    test("should return optimisticKnownState when it exists", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+
+      const optimisticState = peerKnownState.optimisticValue();
+      expect(optimisticState).not.toBe(peerKnownState.value());
+      expect(optimisticState).toEqual({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+    });
+
+    test("should maintain reference consistency", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 5 },
+      });
+
+      const optimisticState1 = peerKnownState.optimisticValue();
+      const optimisticState2 = peerKnownState.optimisticValue();
+
+      expect(optimisticState1).toBe(optimisticState2); // Same reference
+    });
+  });
+
+  describe("integration scenarios", () => {
+    test("should handle complex workflow maintaining references", () => {
+      const peerKnownState = new PeerKnownState(testId, testPeerId);
+      const originalKnownState = peerKnownState.value();
+
+      // Initial state setup
+      peerKnownState.updateHeader(true);
+      expect(peerKnownState.value()).toBe(originalKnownState);
+
+      // Combine with some sessions
+      peerKnownState.combineWith({
+        id: testId,
+        header: false,
+        sessions: { [session1]: 3, [session2]: 7 },
+      });
+      expect(peerKnownState.value()).toBe(originalKnownState);
+
+      // Create optimistic state
+      peerKnownState.combineOptimisticWith({
+        id: testId,
+        header: true,
+        sessions: { [session2]: 5 },
+      });
+
+      const originalOptimisticState = peerKnownState.optimisticValue();
+
+      // Update header should affect both states
+      peerKnownState.updateHeader(false);
+      expect(peerKnownState.value()).toBe(originalKnownState);
+      expect(peerKnownState.optimisticValue()).toBe(originalOptimisticState);
+
+      // Set should clear optimistic and update known
+      peerKnownState.set({
+        id: testId,
+        header: true,
+        sessions: { [session1]: 20 },
+      });
+      expect(peerKnownState.value()).toBe(originalKnownState);
+      expect(peerKnownState.optimisticValue()).toBe(peerKnownState.value()); // Should return knownState when optimistic is cleared
+    });
+  });
+});

package/src/tests/PeerState.test.ts

@@ -44,7 +44,7 @@ describe("PeerState", () => {
     expect(peerState.closed).toBe(true);
   });
 
-  test("should clone the knownStates into optimisticKnownStates and knownStates when passed as argument", () => {
+  test("should clone the knownStates and reset the optimistic known state when using newPeerStateFrom", () => {
     const { peerState, mockPeer } = setup();
     peerState.setKnownState("co_z1", {
       id: "co_z1",
@@ -52,31 +52,40 @@ describe("PeerState", () => {
       sessions: {},
     });
 
-    const newPeerState = new PeerState(mockPeer, peerState.knownStates);
+    peerState.combineOptimisticWith("co_z1", {
+      id: "co_z1",
+      header: true,
+      sessions: {
+        "session-1": 1,
+      } as KnownStateSessions,
+    });
+
+    const newPeerState = peerState.newPeerStateFrom(mockPeer);
 
-    expect(newPeerState.knownStates).toEqual(peerState.knownStates);
-    expect(newPeerState.optimisticKnownStates).toEqual(peerState.knownStates);
+    expect(newPeerState.getKnownState("co_z1")).toEqual(
+      peerState.getKnownState("co_z1"),
+    );
+    expect(newPeerState.getKnownState("co_z1")).not.toBe(
+      peerState.getKnownState("co_z1"),
+    );
+    expect(newPeerState.getOptimisticKnownState("co_z1")).toBe(
+      newPeerState.getKnownState("co_z1"),
+    );
   });
 
   test("should dispatch to both states", () => {
     const { peerState } = setup();
-    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
-
-    const optimisticKnownStatesSpy = vi.spyOn(
-      peerState._optimisticKnownStates,
-      "set",
-    );
 
     const state: CoValueKnownState = {
       id: "co_z1",
-      header: false,
+      header: true,
       sessions: {},
     };
 
     peerState.setKnownState("co_z1", state);
 
-    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith("co_z1", state);
+    expect(peerState.getKnownState("co_z1")).toEqual(state);
+    expect(peerState.getOptimisticKnownState("co_z1")).toEqual(state);
   });
 
   test("dispatching an optimistic update should not affect the known states", () => {
@@ -100,16 +109,7 @@ describe("PeerState", () => {
 
     peerState.combineOptimisticWith("co_z1", optimisticState);
 
-    expect(peerState.knownStates.get("co_z1")).not.toEqual(optimisticState);
-    expect(peerState.optimisticKnownStates.get("co_z1")).toEqual(
-      optimisticState,
-    );
-  });
-
-  test("should use separate references for knownStates and optimisticKnownStates for non-storage peers", () => {
-    const { peerState } = setup(); // Uses a regular peer
-
-    // Verify they are different references
-    expect(peerState.knownStates).not.toBe(peerState.optimisticKnownStates);
+    expect(peerState.getKnownState("co_z1")).not.toEqual(optimisticState);
+    expect(peerState.getOptimisticKnownState("co_z1")).toEqual(optimisticState);
   });
 });