cojson 0.20.0 → 0.20.2

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

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, test } from "vitest";
 
+import { expectMap } from "../coValue";
 import { setGarbageCollectorMaxAge } from "../config";
 import {
   SyncMessagesLog,
@@ -177,6 +178,8 @@ describe("sync after the garbage collector has run", () => {
     const mapOnServer = await loadCoValueOrFail(jazzCloud.node, map.id);
     expect(mapOnServer.get("hello")).toEqual("updated");
 
+    // With garbageCollected shells, client uses cached knownState (header/1)
+    // which is more accurate than asking storage (which returns empty)
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -184,14 +187,14 @@ describe("sync after the garbage collector has run", () => {
       }),
     ).toMatchInlineSnapshot(`
       [
-        "client -> server | LOAD Map sessions: empty",
+        "client -> server | LOAD Map sessions: header/1",
         "client -> server | LOAD Group sessions: header/3",
         "client -> storage | CONTENT Group header: true new: After: 0 New: 3",
         "client -> server | CONTENT Group header: true new: After: 0 New: 3",
         "client -> storage | CONTENT Map header: true new: After: 0 New: 1",
         "client -> server | CONTENT Map header: true new: After: 0 New: 1",
-        "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | KNOWN Map sessions: empty",
+        "server -> storage | GET_KNOWN_STATE Map",
+        "storage -> server | GET_KNOWN_STATE_RESULT Map sessions: empty",
         "server -> client | KNOWN Map sessions: empty",
         "server -> storage | GET_KNOWN_STATE Group",
         "storage -> server | GET_KNOWN_STATE_RESULT Group sessions: empty",
@@ -203,4 +206,113 @@ describe("sync after the garbage collector has run", () => {
       ]
     `);
   });
+
+  test("knownStateWithStreaming returns lastKnownState for garbageCollected CoValues", async () => {
+    // This test verifies that knownStateWithStreaming() returns the cached lastKnownState
+    // for garbage-collected CoValues, not an empty state. This is important for peer
+    // reconciliation where we want to send the last known state to minimize data transfer.
+
+    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();
+
+    // Capture known state before GC
+    const originalKnownState = map.core.knownState();
+    const originalKnownStateWithStreaming = map.core.knownStateWithStreaming();
+
+    // For available CoValues, both should be equal (no streaming in progress)
+    expect(originalKnownState).toEqual(originalKnownStateWithStreaming);
+    expect(originalKnownState.header).toBe(true);
+    expect(Object.values(originalKnownState.sessions)[0]).toBe(1);
+
+    // Disconnect before GC
+    client.disconnect();
+
+    // Run GC to create garbageCollected shell
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect();
+
+    const gcCoValue = client.node.getCoValue(map.id);
+    expect(gcCoValue.loadingState).toBe("garbageCollected");
+
+    // Key assertion: knownStateWithStreaming() should return lastKnownState, not empty state
+    const gcKnownState = gcCoValue.knownState();
+    const gcKnownStateWithStreaming = gcCoValue.knownStateWithStreaming();
+
+    // Both should equal the original known state (the cached lastKnownState)
+    expect(gcKnownState).toEqual(originalKnownState);
+    expect(gcKnownStateWithStreaming).toEqual(originalKnownState);
+
+    // Specifically verify it's NOT an empty state
+    expect(gcKnownStateWithStreaming.header).toBe(true);
+    expect(
+      Object.keys(gcKnownStateWithStreaming.sessions).length,
+    ).toBeGreaterThan(0);
+  });
+
+  test("garbageCollected CoValues read from verified content after reload", async () => {
+    // This test verifies that after reloading a GC'd CoValue:
+    // 1. lastKnownState is cleared
+    // 2. knownState() returns data from verified content (not cached)
+    // We prove this by adding a transaction after reload and verifying knownState() updates
+
+    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();
+
+    // Capture known state before GC (has 1 transaction)
+    const originalKnownState = map.core.knownState();
+    const originalSessionCount = Object.values(originalKnownState.sessions)[0];
+    expect(originalSessionCount).toBe(1);
+
+    // Disconnect before GC
+    client.disconnect();
+
+    // Run GC to create garbageCollected shell
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect();
+
+    const gcMap = client.node.getCoValue(map.id);
+    expect(gcMap.loadingState).toBe("garbageCollected");
+
+    // Verify knownState() returns lastKnownState (still shows 1 transaction)
+    expect(gcMap.knownState()).toEqual(originalKnownState);
+
+    // Reconnect and reload
+    client.connectToSyncServer();
+    const reloadedCore = await client.node.loadCoValueCore(map.id);
+
+    // Verify CoValue is now available
+    expect(reloadedCore.loadingState).toBe("available");
+    expect(reloadedCore.isAvailable()).toBe(true);
+
+    // At this point, knownState() should be reading from verified content
+    // To prove this, we add a new transaction and verify knownState() updates
+    const reloadedContent = expectMap(reloadedCore.getCurrentContent());
+    reloadedContent.set("hello", "updated locally", "trusting");
+
+    // Verify knownState() now shows 2 transactions
+    // This proves we're reading from verified content, not cached lastKnownState
+    const newKnownState = reloadedCore.knownState();
+    const newSessionCount = Object.values(newKnownState.sessions)[0];
+
+    expect(newSessionCount).toBe(2);
+    expect(newKnownState).not.toEqual(originalKnownState);
+  });
 });

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",
+      ]
+    `);
+  });
+});

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

@@ -1024,9 +1024,9 @@ describe("client syncs with a server with storage", () => {
           "server -> bob | CONTENT Map header: true new: After: 0 New: 1",
           "storage -> syncServer | CONTENT ParentGroup header: true new: After: 76 New: 73",
           "server -> bob | CONTENT ParentGroup header: false new: After: 76 New: 73 expectContentUntil: header/205",
-          "bob -> server | KNOWN ParentGroup sessions: header/76",
           "storage -> syncServer | CONTENT ParentGroup header: true new: After: 149 New: 56",
           "server -> bob | CONTENT ParentGroup header: false new: After: 149 New: 56",
+          "bob -> server | KNOWN ParentGroup sessions: header/76",
           "bob -> server | KNOWN Group sessions: header/5",
           "bob -> server | KNOWN Map sessions: header/1",
           "bob -> server | KNOWN ParentGroup sessions: header/149",

package/src/tests/testStorage.ts

@@ -163,7 +163,9 @@ export function getDbPath(defaultDbPath?: string) {
 
   if (!defaultDbPath) {
     onTestFinished(() => {
-      unlinkSync(dbPath);
+      setTimeout(() => {
+        unlinkSync(dbPath);
+      }, 100);
     });
   }
 

package/src/tests/testUtils.ts

@@ -268,6 +268,7 @@ export function blockMessageTypeOnOutgoingPeer(
   opts: {
     id?: string;
     once?: boolean;
+    matcher?: (msg: SyncMessage) => boolean;
   },
 ) {
   const push = peer.outgoing.push;
@@ -280,7 +281,8 @@ export function blockMessageTypeOnOutgoingPeer(
       typeof msg === "object" &&
       msg.action === messageType &&
       (!opts.id || msg.id === opts.id) &&
-      (!opts.once || !blockedIds.has(msg.id))
+      (!opts.once || !blockedIds.has(msg.id)) &&
+      (!opts.matcher || opts.matcher(msg))
     ) {
       blockedMessages.push(msg);
       blockedIds.add(msg.id);