cojson 0.8.37 → 0.8.39

package/src/tests/PeerState.test.ts

@@ -188,4 +188,53 @@ describe("PeerState", () => {
     expect(knownStatesSpy).toHaveBeenCalledWith(action);
     expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
   });
+
+  test("should use same reference for knownStates and optimisticKnownStates for storage peers", () => {
+    const mockStoragePeer: Peer = {
+      id: "test-storage-peer",
+      role: "storage",
+      priority: 1,
+      crashOnClose: false,
+      incoming: (async function* () {})(),
+      outgoing: {
+        push: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn(),
+      },
+    };
+    const peerState = new PeerState(mockStoragePeer, undefined);
+
+    // Verify they are the same reference
+    expect(peerState.knownStates).toBe(peerState.optimisticKnownStates);
+
+    // Verify that dispatching only updates one state
+    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
+    const optimisticKnownStatesSpy = vi.spyOn(
+      peerState.optimisticKnownStates,
+      "dispatch",
+    );
+
+    const action: PeerKnownStateActions = {
+      type: "SET",
+      id: "co_z1",
+      value: {
+        id: "co_z1",
+        header: false,
+        sessions: {},
+      },
+    };
+    peerState.dispatchToKnownStates(action);
+
+    // Only one dispatch should happen since they're the same reference
+    expect(knownStatesSpy).toHaveBeenCalledTimes(1);
+    expect(knownStatesSpy).toHaveBeenCalledWith(action);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledTimes(1);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+  });
+
+  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);
+  });
 });

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -1,14 +1,23 @@
-import { describe, expect, test } from "vitest";
+import { afterEach, describe, expect, test } from "vitest";
 import { PriorityBasedMessageQueue } from "../PriorityBasedMessageQueue.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
-import { SyncMessage } from "../sync.js";
+import type { SyncMessage } from "../sync.js";
+import {
+  createTestMetricReader,
+  tearDownTestMetricReader,
+} from "./testUtils.js";
 
 function setup() {
+  const metricReader = createTestMetricReader();
   const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
-  return { queue };
+  return { queue, metricReader };
 }
 
 describe("PriorityBasedMessageQueue", () => {
+  afterEach(() => {
+    tearDownTestMetricReader();
+  });
+
   test("should initialize with correct properties", () => {
     const { queue } = setup();
     expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
@@ -43,7 +52,7 @@ describe("PriorityBasedMessageQueue", () => {
   });
 
   test("should pull messages in priority order", async () => {
-    const { queue } = setup();
+    const { queue, metricReader } = setup();
     const lowPriorityMsg: SyncMessage = {
       action: "content",
       id: "co_zlow",
@@ -64,12 +73,42 @@ describe("PriorityBasedMessageQueue", () => {
     };
 
     void queue.push(lowPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: lowPriorityMsg.priority,
+      }),
+    ).toBe(1);
     void queue.push(mediumPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: mediumPriorityMsg.priority,
+      }),
+    ).toBe(1);
     void queue.push(highPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: highPriorityMsg.priority,
+      }),
+    ).toBe(1);
 
     expect(queue.pull()?.msg).toEqual(highPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: highPriorityMsg.priority,
+      }),
+    ).toBe(0);
     expect(queue.pull()?.msg).toEqual(mediumPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: mediumPriorityMsg.priority,
+      }),
+    ).toBe(0);
     expect(queue.pull()?.msg).toEqual(lowPriorityMsg);
+    expect(
+      await metricReader.getMetricValue("jazz.messagequeue.size", {
+        priority: lowPriorityMsg.priority,
+      }),
+    ).toBe(0);
   });
 
   test("should return undefined when pulling from empty queue", () => {

package/src/tests/{SyncStateSubscriptionManager.test.ts → SyncStateManager.test.ts}

@@ -2,12 +2,19 @@ import { describe, expect, onTestFinished, test, vi } from "vitest";
 import {
   GlobalSyncStateListenerCallback,
   PeerSyncStateListenerCallback,
-} from "../SyncStateSubscriptionManager.js";
+} from "../SyncStateManager.js";
+import { accountHeaderForInitialAgentSecret } from "../coValues/account.js";
 import { connectedPeers } from "../streamUtils.js";
 import { emptyKnownState } from "../sync.js";
-import { createTestNode, waitFor } from "./testUtils.js";
-
-describe("SyncStateSubscriptionManager", () => {
+import {
+  blockMessageTypeOnOutgoingPeer,
+  createTestNode,
+  createTwoConnectedNodes,
+  loadCoValueOrFail,
+  waitFor,
+} from "./testUtils.js";
+
+describe("SyncStateManager", () => {
   test("subscribeToUpdates receives updates when peer state changes", async () => {
     // Setup nodes
     const client = createTestNode();
@@ -31,7 +38,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(jazzCloudAsPeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     const updateSpy: GlobalSyncStateListenerCallback = vi.fn();
     const unsubscribe = subscriptionManager.subscribeToUpdates(updateSpy);
@@ -41,14 +48,14 @@ describe("SyncStateSubscriptionManager", () => {
     expect(updateSpy).toHaveBeenCalledWith(
       "jazzCloudConnection",
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(updateSpy).toHaveBeenCalledWith(
@@ -56,7 +63,7 @@ describe("SyncStateSubscriptionManager", () => {
       client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
         map.core.id,
       )!,
-      { isUploaded: true },
+      { uploaded: true },
     );
 
     // Cleanup
@@ -92,7 +99,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(clientStoragePeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     const updateToJazzCloudSpy: PeerSyncStateListenerCallback = vi.fn();
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
@@ -114,26 +121,26 @@ describe("SyncStateSubscriptionManager", () => {
 
     expect(updateToJazzCloudSpy).toHaveBeenCalledWith(
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
       client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
         map.core.id,
       )!,
-      { isUploaded: true },
+      { uploaded: true },
     );
 
     expect(updateToStorageSpy).toHaveBeenLastCalledWith(
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
   });
 
@@ -162,27 +169,27 @@ describe("SyncStateSubscriptionManager", () => {
 
     await client.syncManager.actuallySyncCoValue(map.core);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     expect(
-      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      ),
+      ).uploaded,
     ).toBe(false);
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(
-      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      ),
+      ).uploaded,
     ).toBe(true);
   });
 
@@ -209,7 +216,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(jazzCloudAsPeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
     const anyUpdateSpy = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
@@ -225,12 +232,89 @@ describe("SyncStateSubscriptionManager", () => {
     anyUpdateSpy.mockClear();
 
     await waitFor(() => {
-      return client.syncManager.syncStateSubscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(anyUpdateSpy).not.toHaveBeenCalled();
   });
+
+  test("getCurrentSyncState should return the correct state", async () => {
+    // Setup nodes
+    const {
+      node1: clientNode,
+      node2: serverNode,
+      node1ToNode2Peer: clientToServerPeer,
+      node2ToNode1Peer: serverToClientPeer,
+    } = await createTwoConnectedNodes("client", "server");
+
+    // Create test data
+    const group = clientNode.node.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+    group.addMember("everyone", "writer");
+
+    // Initially should not be synced
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: false });
+
+    // Wait for full sync
+    await map.core.waitForSync();
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    const mapOnServer = await loadCoValueOrFail(serverNode.node, map.id);
+
+    // Block the content messages so the client won't fully sync immediately
+    const outgoing = blockMessageTypeOnOutgoingPeer(
+      serverToClientPeer,
+      "content",
+    );
+
+    mapOnServer.set("key2", "value2", "trusting");
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    expect(
+      serverNode.node.syncManager.syncState.getCurrentSyncState(
+        serverToClientPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: false });
+
+    await outgoing.sendBlockedMessages();
+    outgoing.unblock();
+
+    await mapOnServer.core.waitForSync();
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    expect(
+      serverNode.node.syncManager.syncState.getCurrentSyncState(
+        serverToClientPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+  });
 });

package/src/tests/coMap.test.ts

@@ -4,7 +4,7 @@ import { operationToEditEntry } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { hotSleep, randomAnonymousAccountAndSessionID } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -63,20 +63,11 @@ test("Can get CoMap entry values at different points in time", () => {
 
   expect(content.type).toEqual("comap");
 
-  const beforeA = Date.now();
-  while (Date.now() < beforeA + 10) {
-    /* hot sleep */
-  }
+  const beforeA = hotSleep(10);
   content.set("hello", "A", "trusting");
-  const beforeB = Date.now();
-  while (Date.now() < beforeB + 10) {
-    /* hot sleep */
-  }
+  const beforeB = hotSleep(10);
   content.set("hello", "B", "trusting");
-  const beforeC = Date.now();
-  while (Date.now() < beforeC + 10) {
-    /* hot sleep */
-  }
+  const beforeC = hotSleep(10);
   content.set("hello", "C", "trusting");
   expect(content.get("hello")).toEqual("C");
   expect(content.atTime(Date.now()).get("hello")).toEqual("C");

package/src/tests/group.test.ts

@@ -7,10 +7,8 @@ import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import {
   createThreeConnectedNodes,
-  createTwoConnectedNodes,
   loadCoValueOrFail,
   randomAnonymousAccountAndSessionID,
-  waitFor,
 } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
@@ -89,12 +87,12 @@ test("Remove a member from a group where the admin role is inherited", async ()
   // The reader should be automatically kicked out of the child group
   await group.removeMember(node3.account);
 
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   // Update the map to check that node3 can't read updates anymore
   map.set("test", "Hidden to node3");
 
-  await node2.syncManager.waitForUploadIntoPeer(node2ToNode3Peer.id, map.id);
+  await map.core.waitForSync();
 
   // Check that the value has not been updated on node3
   expect(mapOnNode3.get("test")).toEqual("Available to everyone");
@@ -121,16 +119,13 @@ test("An admin should be able to rotate the readKey on child groups and keep acc
   const childGroup = node2.createGroup();
   childGroup.extend(groupOnNode2);
 
-  await node2.syncManager.waitForUploadIntoPeer(
-    node2ToNode1Peer.id,
-    childGroup.id,
-  );
+  await childGroup.core.waitForSync();
 
   // The node1 account removes the reader from the group
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
   await group.removeMember(node3.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");
@@ -160,7 +155,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
   await group.removeMember(node3.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");
@@ -195,7 +190,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
   await group.removeMember(node3.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");

package/src/tests/permissions.test.ts

@@ -7,6 +7,8 @@ import {
   createTwoConnectedNodes,
   groupWithTwoAdmins,
   groupWithTwoAdminsHighLevel,
+  hotSleep,
+  loadCoValueOrFail,
   newGroup,
   newGroupHighLevel,
 } from "./testUtils.js";
@@ -1802,29 +1804,25 @@ test("Admins can set child extensions", () => {
 });
 
 test("Admins can set child extensions when the admin role is inherited", async () => {
-  const { node1, node2 } = createTwoConnectedNodes("server", "server");
+  const { node1, node2 } = await createTwoConnectedNodes("server", "server");
 
-  const node2Account = node2.account;
-  const group = node1.createGroup();
+  const node2AccountOnNode1 = await loadCoValueOrFail(
+    node1.node,
+    node2.accountID,
+  );
 
-  group.addMember(node2Account, "admin");
+  const group = node1.node.createGroup();
 
-  const groupOnNode2 = await node2.load(group.id);
+  group.addMember(node2AccountOnNode1, "admin");
 
-  if (groupOnNode2 === "unavailable") {
-    throw new Error("Group not found on node2");
-  }
+  const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
 
-  const childGroup = node2.createGroup();
+  const childGroup = node2.node.createGroup();
   childGroup.extend(groupOnNode2);
 
-  const childGroupOnNode1 = await node1.load(childGroup.id);
+  const childGroupOnNode1 = await loadCoValueOrFail(node1.node, childGroup.id);
 
-  if (childGroupOnNode1 === "unavailable") {
-    throw new Error("Child group not found on node1");
-  }
-
-  const grandChildGroup = node2.createGroup();
+  const grandChildGroup = node2.node.createGroup();
   grandChildGroup.extend(childGroupOnNode1);
 
   expect(childGroupOnNode1.get(`child_${grandChildGroup.id}`)).toEqual(
@@ -2315,6 +2313,38 @@ test("When rotating the key of a parent group, the keys of all child groups are
   expect(newChildReadKeyID).not.toEqual(currentChildReadKeyID);
 });
 
+test("When rotating the key of a parent group, the old transactions should still be valid", async () => {
+  const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+  const group = node1.node.createGroup();
+  const parentGroup = node1.node.createGroup();
+
+  group.extend(parentGroup);
+
+  const node2AccountOnNode1 = await loadCoValueOrFail(
+    node1.node,
+    node2.accountID,
+  );
+
+  parentGroup.addMember(node2AccountOnNode1, "writer");
+
+  const map = group.createMap();
+  map.set("from", "node1", "private");
+
+  const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+  mapOnNode2.set("from", "node2", "private");
+
+  await new Promise((resolve) => setTimeout(resolve, 10));
+
+  parentGroup.removeMember(node2AccountOnNode1);
+
+  await new Promise((resolve) => setTimeout(resolve, 10));
+
+  const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
+
+  expect(mapOnNode1.get("from")).toEqual("node2");
+});
+
 test("When rotating the key of a grand-parent group, the keys of all child and grand-child groups are also rotated", () => {
   const { group, node } = newGroupHighLevel();
   const grandParentGroup = node.createGroup();