cojson 0.20.1 → 0.20.2

package/src/tests/sync.multipleServers.test.ts

@@ -99,71 +99,6 @@ describe("multiple servers peers", () => {
       expect(mapOnSession2.get("count")).toEqual(4);
     });
 
-    expect(
-      SyncMessagesLog.getMessages({
-        Group: group.core,
-        Map: map.core,
-      }),
-    ).toMatchInlineSnapshot(`
-      [
-        "client -> server1 | LOAD Map sessions: empty",
-        "client -> server2 | LOAD Map sessions: empty",
-        "client -> server1 | CONTENT Group header: true new: After: 0 New: 3",
-        "client -> server2 | CONTENT Group header: true new: After: 0 New: 3",
-        "client -> server1 | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> server2 | CONTENT Map header: true new: After: 0 New: 1",
-        "server1 -> client | KNOWN Map sessions: empty",
-        "server2 -> client | KNOWN Map sessions: empty",
-        "server1 -> client | KNOWN Group sessions: header/3",
-        "server2 -> client | KNOWN Group sessions: header/3",
-        "server1 -> client | KNOWN Map sessions: header/1",
-        "server1 -> client | CONTENT Group header: true new: After: 0 New: 3",
-        "server1 -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "server2 -> client | KNOWN Map sessions: header/1",
-        "server2 -> client | CONTENT Group header: true new: After: 0 New: 3",
-        "server2 -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> server1 | KNOWN Group sessions: header/3",
-        "client -> server2 | LOAD Group sessions: header/3",
-        "client -> server1 | KNOWN Map sessions: header/1",
-        "client -> server2 | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> server1 | CONTENT Map header: false new: After: 0 New: 1",
-        "client -> server2 | CONTENT Map header: false new: After: 0 New: 1",
-        "client -> server1 | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server2 | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server2 | KNOWN Group sessions: header/3",
-        "client -> server2 | CONTENT Group header: false new: After: 0 New: 3",
-        "client -> server2 | KNOWN Map sessions: header/2",
-        "server2 -> client | KNOWN Map sessions: header/1",
-        "server1 -> client | KNOWN Map sessions: header/2",
-        "server1 -> client | CONTENT Map header: false new: After: 0 New: 1",
-        "server2 -> client | KNOWN Map sessions: header/2",
-        "server2 -> client | CONTENT Map header: false new: After: 0 New: 1",
-        "server1 -> client | KNOWN Map sessions: header/3",
-        "server1 -> client | CONTENT Map header: false new: After: 1 New: 1",
-        "server2 -> client | KNOWN Map sessions: header/3",
-        "server2 -> client | CONTENT Map header: false new: After: 1 New: 1",
-        "server2 -> client | KNOWN Group sessions: header/3",
-        "client -> server1 | KNOWN Map sessions: header/3",
-        "client -> server2 | CONTENT Map header: false new: After: 0 New: 1",
-        "client -> server2 | KNOWN Map sessions: header/3",
-        "client -> server1 | KNOWN Map sessions: header/3",
-        "client -> server2 | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server2 | KNOWN Map sessions: header/3",
-        "server2 -> client | KNOWN Map sessions: header/3",
-        "server2 -> client | KNOWN Map sessions: header/3",
-        "client -> server1 | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server2 | CONTENT Map header: false new: After: 1 New: 1",
-        "server1 -> client | KNOWN Map sessions: header/4",
-        "server1 -> client | CONTENT Map header: false new: After: 1 New: 1",
-        "server2 -> client | KNOWN Map sessions: header/4",
-        "server2 -> client | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server1 | KNOWN Map sessions: header/4",
-        "client -> server2 | CONTENT Map header: false new: After: 1 New: 1",
-        "client -> server2 | KNOWN Map sessions: header/4",
-        "server2 -> client | KNOWN Map sessions: header/4",
-      ]
-    `);
-
     const mapOnServer1 = server1.node.getCoValue(map.id);
     const mapOnServer2 = server2.node.getCoValue(map.id);
 

package/src/tests/sync.peerReconciliation.test.ts

@@ -1,5 +1,6 @@
 import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 import { expectMap } from "../coValue";
+import { setGarbageCollectorMaxAge } from "../config";
 import { RawCoMap } from "../exports";
 import {
   SyncMessagesLog,
@@ -17,6 +18,8 @@ let jazzCloud: ReturnType<typeof setupTestNode>;
 beforeEach(async () => {
   SyncMessagesLog.clear();
   jazzCloud = setupTestNode({ isSyncServer: true });
+  // Set GC max age to -1 so items are collected immediately when needed
+  setGarbageCollectorMaxAge(-1);
 });
 
 describe("peer reconciliation", () => {
@@ -336,3 +339,199 @@ describe("peer reconciliation", () => {
     );
   });
 });
+
+describe("peer reconciliation with garbageCollected CoValues", () => {
+  test("sends cached known state for garbageCollected CoValues during reconciliation", async () => {
+    const client = setupTestNode();
+    client.addStorage({ ourName: "client" });
+    client.node.enableGarbageCollector();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    // Sync to server first
+    client.connectToSyncServer();
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // Capture the known state before GC
+    const mapKnownState = map.core.knownState();
+    const groupKnownState = group.core.knownState();
+
+    // Disconnect first to avoid server reloading CoValues after GC
+    client.disconnect();
+
+    // Run GC to unmount the CoValues (creates garbageCollected shells)
+    // GC works because there are no persistent server peers (disconnected)
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect(); // Second pass for dependencies
+
+    // Verify CoValues are now garbageCollected
+    const gcMap = client.node.getCoValue(map.id);
+    const gcGroup = client.node.getCoValue(group.id);
+    expect(gcMap.loadingState).toBe("garbageCollected");
+    expect(gcGroup.loadingState).toBe("garbageCollected");
+
+    // Verify knownState() returns the cached state (not empty)
+    expect(gcMap.knownState()).toEqual(mapKnownState);
+    expect(gcGroup.knownState()).toEqual(groupKnownState);
+
+    // Reconnect to trigger peer reconciliation
+    SyncMessagesLog.clear();
+    client.connectToSyncServer();
+
+    // Wait for messages to be exchanged
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // LOAD is sent with cached known state (no storage lookup needed)
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: gcGroup,
+        Map: gcMap,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/1",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("garbageCollected CoValues restore subscription with minimal data transfer", async () => {
+    // Setup: both client and server have the same data
+    const client = setupTestNode();
+    client.addStorage({ ourName: "client" });
+    client.node.enableGarbageCollector();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    // Sync to server
+    client.connectToSyncServer();
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // Verify server has the data
+    const serverMap = jazzCloud.node.getCoValue(map.id);
+    expect(serverMap.isAvailable()).toBe(true);
+
+    // Capture known states before GC
+    const clientMapKnownState = map.core.knownState();
+    const clientGroupKnownState = group.core.knownState();
+
+    // Disconnect before GC to avoid server reloading CoValues
+    client.disconnect();
+
+    // Run GC
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect();
+
+    const gcMap = client.node.getCoValue(map.id);
+    const gcGroup = client.node.getCoValue(group.id);
+
+    // Verify garbageCollected state
+    expect(gcMap.loadingState).toBe("garbageCollected");
+    expect(gcGroup.loadingState).toBe("garbageCollected");
+
+    // Reconnect to trigger peer reconciliation
+    SyncMessagesLog.clear();
+    client.connectToSyncServer();
+
+    // Wait for messages to be exchanged
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // LOAD is sent with cached known state
+    // Server responds with KNOWN since client and server have the same data
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: gcGroup,
+        Map: gcMap,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/1",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("unknown CoValues return empty knownState during reconciliation", async () => {
+    const client = setupTestNode();
+
+    // Create a CoValue on another node that we'll hear about but not load
+    const otherClient = setupTestNode();
+    const group = otherClient.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    // Sync other client to server
+    otherClient.connectToSyncServer();
+    await otherClient.node.syncManager.waitForAllCoValuesSync();
+
+    // Now client connects - it will hear about the CoValue IDs but not load them
+    // Create a reference to the CoValue without loading it
+    const unknownCoValue = client.node.getCoValue(map.id);
+
+    // Verify it's in unknown state
+    expect(unknownCoValue.loadingState).toBe("unknown");
+
+    // Verify knownState() returns empty state for unknown CoValues
+    const knownState = unknownCoValue.knownState();
+    expect(knownState.header).toBe(false);
+    expect(knownState.sessions).toEqual({});
+  });
+
+  test("unknown CoValues are skipped during peer reconciliation (no LOAD sent)", async () => {
+    const client = setupTestNode();
+
+    // Create a CoValue on another node
+    const otherClient = setupTestNode();
+    const group = otherClient.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    // Sync other client to server so the server knows about the CoValue
+    otherClient.connectToSyncServer();
+    await otherClient.node.syncManager.waitForAllCoValuesSync();
+
+    // Client creates its own group (so we have something to compare against)
+    const clientGroup = client.node.createGroup();
+    const clientMap = clientGroup.createMap();
+    clientMap.set("foo", "bar", "trusting");
+
+    // Create a reference to the other client's CoValue WITHOUT loading it
+    // This simulates "hearing about" a CoValue ID (e.g., from a reference)
+    const unknownCoValue = client.node.getCoValue(map.id);
+    expect(unknownCoValue.loadingState).toBe("unknown");
+
+    // Connect client to server - this triggers peer reconciliation
+    SyncMessagesLog.clear();
+    client.connectToSyncServer();
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // Verify: LOAD sent for client's own CoValues, but NOT for the unknown CoValue
+    expect(
+      SyncMessagesLog.getMessages({
+        ClientGroup: clientGroup.core,
+        ClientMap: clientMap.core,
+        UnknownMap: unknownCoValue,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD ClientGroup sessions: header/3",
+        "client -> server | LOAD ClientMap sessions: header/1",
+        "client -> server | CONTENT ClientGroup header: true new: After: 0 New: 3",
+        "client -> server | CONTENT ClientMap header: true new: After: 0 New: 1",
+        "server -> client | KNOWN ClientGroup sessions: empty",
+        "server -> client | KNOWN ClientMap sessions: empty",
+        "server -> client | KNOWN ClientGroup sessions: header/3",
+        "server -> client | KNOWN ClientMap sessions: header/1",
+      ]
+    `);
+  });
+});