cojson 0.8.19 → 0.8.23

package/src/tests/coValueState.test.ts

@@ -0,0 +1,362 @@
+import { describe, expect, test, vi } from "vitest";
+import { PeerState } from "../PeerState";
+import { CoValueCore } from "../coValueCore";
+import { CO_VALUE_LOADING_MAX_RETRIES, CoValueState } from "../coValueState";
+import { RawCoID } from "../ids";
+import { Peer } from "../sync";
+
+describe("CoValueState", () => {
+  const mockCoValueId = "co_test123" as RawCoID;
+
+  test("should create unknown state", () => {
+    const state = CoValueState.Unknown(mockCoValueId);
+
+    expect(state.id).toBe(mockCoValueId);
+    expect(state.state.type).toBe("unknown");
+  });
+
+  test("should create loading state", () => {
+    const peerIds = ["peer1", "peer2"];
+    const state = CoValueState.Loading(mockCoValueId, peerIds);
+
+    expect(state.id).toBe(mockCoValueId);
+    expect(state.state.type).toBe("loading");
+  });
+
+  test("should create available state", async () => {
+    const mockCoValue = { id: mockCoValueId } as CoValueCore;
+    const state = CoValueState.Available(mockCoValue);
+
+    expect(state.id).toBe(mockCoValueId);
+    expect(state.state.type).toBe("available");
+    expect((state.state as any).coValue).toBe(mockCoValue);
+    await expect(state.getCoValue()).resolves.toEqual(mockCoValue);
+  });
+
+  test("should handle found action", async () => {
+    const mockCoValue = { id: mockCoValueId } as CoValueCore;
+    const state = CoValueState.Loading(mockCoValueId, ["peer1", "peer2"]);
+
+    const stateValuePromise = state.getCoValue();
+
+    state.dispatch({
+      type: "available",
+      coValue: mockCoValue,
+    });
+
+    const result = await state.getCoValue();
+    expect(result).toBe(mockCoValue);
+    await expect(stateValuePromise).resolves.toBe(mockCoValue);
+  });
+
+  test("should ignore actions when not in loading state", () => {
+    const state = CoValueState.Unknown(mockCoValueId);
+
+    state.dispatch({
+      type: "not-found-in-peer",
+      peerId: "peer1",
+    });
+
+    expect(state.state.type).toBe("unknown");
+  });
+
+  test("should retry loading from peers when unsuccessful", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer2",
+        });
+      },
+    );
+    const mockPeers = [peer1, peer2] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+      await vi.runAllTimersAsync();
+    }
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_MAX_RETRIES,
+    );
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_MAX_RETRIES,
+    );
+    expect(state.state.type).toBe("unavailable");
+    await expect(state.getCoValue()).resolves.toBe("unavailable");
+
+    vi.useRealTimers();
+  });
+
+  test("should skip errored coValues when loading from peers", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        peer1.erroredCoValues.set(mockCoValueId, new Error("test") as any);
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer2",
+        });
+      },
+    );
+
+    const mockPeers = [peer1, peer2] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+      await vi.runAllTimersAsync();
+    }
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_MAX_RETRIES,
+    );
+    expect(state.state.type).toBe("unavailable");
+    await expect(state.getCoValue()).resolves.toBe("unavailable");
+
+    vi.useRealTimers();
+  });
+
+  test("should retry only on server peers", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "storage",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer2",
+        });
+      },
+    );
+    const mockPeers = [peer1, peer2] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+      await vi.runAllTimersAsync();
+    }
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_MAX_RETRIES,
+    );
+    expect(state.state.type).toBe("unavailable");
+    await expect(state.getCoValue()).resolves.toEqual("unavailable");
+
+    vi.useRealTimers();
+  });
+
+  test("should handle the coValues that become available in between of the retries", async () => {
+    vi.useFakeTimers();
+
+    let retries = 0;
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        retries++;
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+
+        if (retries === 2) {
+          setTimeout(() => {
+            state.dispatch({
+              type: "available",
+              coValue: { id: mockCoValueId } as CoValueCore,
+            });
+          }, 100);
+        }
+      },
+    );
+
+    const mockPeers = [peer1] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES + 1; i++) {
+      await vi.runAllTimersAsync();
+    }
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(2);
+    expect(state.state.type).toBe("available");
+    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
+    vi.useRealTimers();
+  });
+
+  test("should have a coValue as value property when becomes available after that have been marked as unavailable", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+      },
+    );
+
+    const mockPeers = [peer1] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+      await vi.runAllTimersAsync();
+    }
+
+    state.dispatch({
+      type: "available",
+      coValue: { id: mockCoValueId } as CoValueCore,
+    });
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(5);
+    expect(state.state.type).toBe("available");
+    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
+
+    vi.useRealTimers();
+  });
+
+  test("should stop retrying when value becomes available", async () => {
+    vi.useFakeTimers();
+
+    let run = 1;
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        if (run > 2) {
+          state.dispatch({
+            type: "available",
+            coValue: { id: mockCoValueId } as CoValueCore,
+          });
+        }
+        state.dispatch({
+          type: "not-found-in-peer",
+          peerId: "peer1",
+        });
+        run++;
+      },
+    );
+
+    const mockPeers = [peer1] as unknown as PeerState[];
+
+    const state = CoValueState.Unknown(mockCoValueId);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+      await vi.runAllTimersAsync();
+    }
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(3);
+    expect(state.state.type).toBe("available");
+    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
+
+    vi.useRealTimers();
+  });
+});
+
+function createMockPeerState(
+  peer: Partial<Peer>,
+  pushFn = () => Promise.resolve(),
+) {
+  const peerState = new PeerState(
+    {
+      id: "peer",
+      role: "server",
+      outgoing: {
+        push: pushFn,
+      },
+      ...peer,
+    } as Peer,
+    undefined,
+  );
+
+  vi.spyOn(peerState, "pushOutgoingMessage").mockImplementation(pushFn);
+
+  return peerState;
+}

package/src/tests/group.test.ts

@@ -42,7 +42,7 @@ test("Can create a CoStream in a group", () => {
   expect(stream instanceof RawCoStream).toEqual(true);
 });
 
-test("Can create a BinaryCoStream in a group", () => {
+test("Can create a FileStream in a group", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
   const group = node.createGroup();

package/src/tests/sync.test.ts

@@ -807,7 +807,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     sessions: {},
   } satisfies SyncMessage);
 
-  expect(node2.coValues[map.core.id]?.state).toEqual("loading");
+  expect(node2.coValuesStore.get(map.core.id).state.type).toEqual("loading");
 
   await inTx2.push(mapNewContentMsg);
 
@@ -875,7 +875,7 @@ test("Can sync a coValue through a server to another client", async () => {
     {
       peer1role: "server",
       peer2role: "client",
-      trace: true,
+      // trace: true,
     },
   );
 
@@ -894,7 +894,7 @@ test("Can sync a coValue through a server to another client", async () => {
     {
       peer1role: "server",
       peer2role: "client",
-      trace: true,
+      // trace: true,
     },
   );
 
@@ -926,7 +926,7 @@ test("Can sync a coValue with private transactions through a server to another c
   const server = new LocalNode(serverUser, serverSession, Crypto);
 
   const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
-    trace: true,
+    // trace: true,
     peer1role: "server",
     peer2role: "client",
   });
@@ -944,7 +944,7 @@ test("Can sync a coValue with private transactions through a server to another c
     "server",
     "client2",
     {
-      trace: true,
+      // trace: true,
       peer1role: "server",
       peer2role: "client",
     },
@@ -1095,14 +1095,14 @@ test("If we start loading a coValue before connecting to a peer that has it, it
   const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
     peer1role: "server",
     peer2role: "client",
-    trace: true,
+    // trace: true,
   });
 
   node1.syncManager.addPeer(node2asPeer);
 
   const mapOnNode2Promise = node2.loadCoValueCore(map.core.id);
 
-  expect(node2.coValues[map.core.id]?.state.type).toEqual("unknown");
+  expect(node2.coValuesStore.get(map.core.id).state.type).toEqual("unknown");
 
   node2.syncManager.addPeer(node1asPeer);
 
@@ -1116,6 +1116,59 @@ test("If we start loading a coValue before connecting to a peer that has it, it
   );
 });
 
+test("should keep the peer state when the peer closes", async () => {
+  const {
+    client,
+    jazzCloud,
+    jazzCloudConnectionAsPeer,
+    connectionWithClientAsPeer,
+  } = createTwoConnectedNodes();
+
+  const group = jazzCloud.createGroup();
+  const map = group.createMap();
+  map.set("hello", "world", "trusting");
+
+  await client.loadCoValueCore(map.core.id);
+
+  const syncManager = client.syncManager;
+  const peerState = syncManager.peers[jazzCloudConnectionAsPeer.id];
+
+  // @ts-expect-error Simulating a peer closing, leveraging the direct connection between the client/server peers
+  await connectionWithClientAsPeer.outgoing.push("Disconnected");
+
+  await waitFor(() => peerState?.closed);
+
+  expect(syncManager.peers[jazzCloudConnectionAsPeer.id]).not.toBeUndefined();
+});
+
+test("should delete the peer state when the peer closes if deletePeerStateOnClose is true", async () => {
+  const {
+    client,
+    jazzCloud,
+    jazzCloudConnectionAsPeer,
+    connectionWithClientAsPeer,
+  } = createTwoConnectedNodes();
+
+  jazzCloudConnectionAsPeer.deletePeerStateOnClose = true;
+
+  const group = jazzCloud.createGroup();
+  const map = group.createMap();
+  map.set("hello", "world", "trusting");
+
+  await client.loadCoValueCore(map.core.id);
+
+  const syncManager = client.syncManager;
+
+  const peerState = syncManager.peers[jazzCloudConnectionAsPeer.id];
+
+  // @ts-expect-error Simulating a peer closing, leveraging the direct connection between the client/server peers
+  await connectionWithClientAsPeer.outgoing.push("Disconnected");
+
+  await waitFor(() => peerState?.closed);
+
+  expect(syncManager.peers[jazzCloudConnectionAsPeer.id]).toBeUndefined();
+});
+
 describe("sync - extra tests", () => {
   test("Node handles disconnection and reconnection of a peer gracefully", async () => {
     // Create two nodes
@@ -1519,7 +1572,7 @@ describe("sync - extra tests", () => {
       {
         peer1role: "server",
         peer2role: "client",
-        trace: true,
+        // trace: true,
       },
     );
 
@@ -1529,7 +1582,7 @@ describe("sync - extra tests", () => {
       {
         peer1role: "server",
         peer2role: "client",
-        trace: true,
+        // trace: true,
       },
     );
 
@@ -1590,32 +1643,39 @@ function createTwoConnectedNodes() {
 
 describe("SyncManager - knownStates vs optimisticKnownStates", () => {
   test("knownStates and optimisticKnownStates are the same when the coValue is fully synced", async () => {
-    const { client } = createTwoConnectedNodes();
+    const { client, jazzCloud } = createTwoConnectedNodes();
 
     // Create test data
     const group = client.createGroup();
-    const map = group.createMap();
-    map.set("key1", "value1", "trusting");
+    const mapOnClient = group.createMap();
+    mapOnClient.set("key1", "value1", "trusting");
 
-    await client.syncManager.actuallySyncCoValue(map.core);
+    await client.syncManager.actuallySyncCoValue(mapOnClient.core);
 
     // Wait for the full sync to complete
     await waitFor(() => {
       return client.syncManager.syncStateSubscriptionManager.getIsCoValueFullyUploadedIntoPeer(
         "jazzCloudConnection",
-        map.core.id,
+        mapOnClient.core.id,
       );
     });
 
-    const peerState = client.syncManager.peers["jazzCloudConnection"]!;
+    const peerStateClient = client.syncManager.peers["jazzCloudConnection"]!;
+    const peerStateJazzCloud =
+      jazzCloud.syncManager.peers["connectionWithClient"]!;
 
     // The optimisticKnownStates should be the same as the knownStates after the full sync is complete
-    expect(peerState.optimisticKnownStates.get(map.core.id)).toEqual(
-      peerState.knownStates.get(map.core.id),
-    );
+    expect(
+      peerStateClient.optimisticKnownStates.get(mapOnClient.core.id),
+    ).toEqual(peerStateClient.knownStates.get(mapOnClient.core.id));
+
+    // On the other node the knownStates should be updated correctly based on the messages we received
+    expect(
+      peerStateJazzCloud.optimisticKnownStates.get(mapOnClient.core.id),
+    ).toEqual(peerStateJazzCloud.knownStates.get(mapOnClient.core.id));
   });
 
-  test("optimisticKnownStates is updated as new transactions are received, while knownStates only when the coValue is fully synced", async () => {
+  test("optimisticKnownStates is updated as new transactions are sent, while knownStates only when the updates are acknowledged", async () => {
     const { client, jazzCloudConnectionAsPeer } = createTwoConnectedNodes();
 
     // Create test data and sync the first change
@@ -1814,6 +1874,63 @@ describe("SyncManager.addPeer", () => {
   });
 });
 
+describe("loadCoValueCore with retry", () => {
+  test("should load the value if available on the server", async () => {
+    const { client, jazzCloud } = createTwoConnectedNodes();
+
+    const anotherClient = createTestNode();
+    const [
+      connectionWithAnotherClientAsPeer,
+      jazzCloudConnectionAsPeerForAnotherClient,
+    ] = connectedPeers("connectionWithAnotherClient", "jazzCloudConnection", {
+      peer1role: "client",
+      peer2role: "server",
+    });
+
+    jazzCloud.syncManager.addPeer(connectionWithAnotherClientAsPeer);
+
+    const group = anotherClient.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    const promise = client.loadCoValueCore(map.id);
+
+    anotherClient.syncManager.addPeer(
+      jazzCloudConnectionAsPeerForAnotherClient,
+    );
+    await expect(promise).resolves.not.toBe("unavailable");
+  });
+
+  test("should handle correctly two subsequent loads", async () => {
+    const { client, jazzCloud } = createTwoConnectedNodes();
+
+    const anotherClient = createTestNode();
+    const [
+      connectionWithAnotherClientAsPeer,
+      jazzCloudConnectionAsPeerForAnotherClient,
+    ] = connectedPeers("connectionWithAnotherClient", "jazzCloudConnection", {
+      peer1role: "client",
+      peer2role: "server",
+    });
+
+    jazzCloud.syncManager.addPeer(connectionWithAnotherClientAsPeer);
+
+    const group = anotherClient.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    const promise1 = client.loadCoValueCore(map.id);
+    const promise2 = client.loadCoValueCore(map.id);
+
+    anotherClient.syncManager.addPeer(
+      jazzCloudConnectionAsPeerForAnotherClient,
+    );
+
+    await expect(promise1).resolves.not.toBe("unavailable");
+    await expect(promise2).resolves.not.toBe("unavailable");
+  });
+});
+
 describe("waitForUploadIntoPeer", () => {
   test("should resolve when the coValue is fully uploaded into the peer", async () => {
     const { client, jazzCloudConnectionAsPeer: peer } =
@@ -1889,3 +2006,7 @@ function _admStateEx(adminID: RawAccountID) {
     id: adminID,
   };
 }
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}