cojson 0.19.21 → 0.19.22

package/src/tests/CojsonMessageChannel.test.ts

@@ -0,0 +1,306 @@
+import { describe, test, expect, beforeEach, assert } from "vitest";
+import { CojsonMessageChannel } from "../CojsonMessageChannel";
+import type { Peer } from "../sync.js";
+import type { RawCoMap } from "../coValues/coMap.js";
+import {
+  setupTestNode,
+  SyncMessagesLog,
+  waitFor,
+  createTrackedMessageChannel,
+  createMockWorkerWithAccept,
+  loadCoValueOrFail,
+} from "./testUtils";
+
+describe("CojsonMessageChannel", () => {
+  beforeEach(() => {
+    SyncMessagesLog.clear();
+  });
+
+  test("should sync data between two contexts via MessageChannel", async () => {
+    // Create two nodes using setupTestNode (handles cleanup automatically)
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      // This runs in the "worker" context
+      const peer = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+      });
+      node2.syncManager.addPeer(peer);
+    });
+
+    // Host side: expose to the mock worker
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+      messageChannel: createTrackedMessageChannel({
+        port1Name: "client",
+        port2Name: "server",
+      }),
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Create data on node1
+    const group = node1.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    map.set("key", "value", "trusting");
+
+    // Verify data synced
+    const mapOnNode2 = await loadCoValueOrFail<RawCoMap>(node2, map.id);
+    expect(mapOnNode2.get("key")).toBe("value");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Map: map.core,
+        Group: group.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "server -> client | LOAD Map sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Group sessions: header/5",
+        "server -> client | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("should handle disconnection correctly", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    const peerId = "disconnect-test-peer";
+    let peer2: Peer | null = null;
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      peer2 = await CojsonMessageChannel.acceptFromPort(port, {
+        id: peerId,
+        role: "server",
+      });
+      node2.syncManager.addPeer(peer2);
+    });
+
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      id: peerId,
+      role: "client",
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Verify peers are connected (same ID on both sides)
+    expect(node1.syncManager.peers["disconnect-test-peer"]).toBeDefined();
+    expect(node2.syncManager.peers["disconnect-test-peer"]).toBeDefined();
+
+    peer1.outgoing.close();
+
+    expect(node1.syncManager.peers["disconnect-test-peer"]).toBeUndefined();
+
+    await waitFor(() => {
+      expect(node2.syncManager.peers["disconnect-test-peer"]).toBeUndefined();
+    });
+  });
+
+  test("should ignore mismatched peer IDs in waitForConnection() when id filter is provided", async () => {
+    const { node } = setupTestNode();
+
+    const hostPeerId = "host-peer-id";
+    const wrongPeerId = "wrong-peer-id";
+
+    let acceptPromiseResolved = false;
+
+    // Mock worker that expects a different ID
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      // This should not resolve because the ID doesn't match
+      const acceptPromise = CojsonMessageChannel.acceptFromPort(port, {
+        id: wrongPeerId, // Expecting a different ID
+        role: "server",
+      });
+
+      // Set a timeout to detect if it's waiting
+      const timeoutPromise = new Promise<null>((resolve) =>
+        setTimeout(() => resolve(null), 100),
+      );
+
+      const result = await Promise.race([acceptPromise, timeoutPromise]);
+      if (result !== null) {
+        acceptPromiseResolved = true;
+        node.syncManager.addPeer(result);
+      }
+    });
+
+    // Expose with a different ID than what accept expects
+    CojsonMessageChannel.expose(mockWorker, {
+      id: hostPeerId,
+      role: "client",
+    });
+
+    // Wait a bit to ensure the accept didn't resolve
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    // The accept should not have resolved because IDs don't match
+    expect(acceptPromiseResolved).toBe(false);
+  });
+
+  test("should sync data bidirectionally", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      const peer = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+      });
+      node2.syncManager.addPeer(peer);
+    });
+
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Create data on node1
+    const group1 = node1.createGroup();
+    group1.addMember("everyone", "writer");
+    const map1 = group1.createMap();
+    map1.set("from", "node1", "trusting");
+
+    // Create data on node2
+    const group2 = node2.createGroup();
+    group2.addMember("everyone", "writer");
+    const map2 = group2.createMap();
+    map2.set("from", "node2", "trusting");
+
+    // Verify data synced in both directions
+    const map1OnNode2 = await loadCoValueOrFail<RawCoMap>(node2, map1.id);
+    expect(map1OnNode2.get("from")).toBe("node1");
+
+    const map2OnNode1 = await loadCoValueOrFail<RawCoMap>(node1, map2.id);
+    expect(map2OnNode1.get("from")).toBe("node2");
+  });
+
+  test("should invoke onClose callback when connection closes", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    let onCloseCalledOnHost = false;
+    let onCloseCalledOnWorker = false;
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      const peer = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+        onClose: () => {
+          onCloseCalledOnWorker = true;
+        },
+      });
+      node2.syncManager.addPeer(peer);
+    });
+
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+      onClose: () => {
+        onCloseCalledOnHost = true;
+      },
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Close the connection
+    peer1.outgoing.close();
+
+    // Wait for close to propagate
+    await waitFor(() => {
+      expect(onCloseCalledOnHost).toBe(true);
+    });
+
+    await waitFor(() => {
+      expect(onCloseCalledOnWorker).toBe(true);
+    });
+  });
+
+  test("should apply role configuration correctly", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    let peer2: Peer | null = null;
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      peer2 = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+      });
+      node2.syncManager.addPeer(peer2);
+    });
+
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Verify roles are correctly set
+    expect(peer1.role).toBe("client");
+    expect(peer2).not.toBeNull();
+    expect(peer2!.role).toBe("server");
+  });
+
+  test("should generate and use the same peer ID on both sides when not provided", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    let peer2: Peer | null = null;
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      peer2 = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+      });
+      node2.syncManager.addPeer(peer2);
+    });
+
+    // Don't provide an id - it should be auto-generated
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Verify peer1 has an auto-generated ID
+    expect(peer1.id).toMatch(/^channel_/);
+
+    // Verify both peers have the same ID
+    expect(peer2).not.toBeNull();
+    expect(peer2!.id).toBe(peer1.id);
+
+    // Verify the peer is accessible in both sync managers with the same ID
+    expect(node1.syncManager.peers[peer1.id]).toBeDefined();
+    expect(node2.syncManager.peers[peer1.id]).toBeDefined();
+  });
+
+  test("should handle delayed addPeer on accept side", async () => {
+    const { node: node1 } = setupTestNode();
+    const { node: node2 } = setupTestNode();
+
+    let peer2: Peer | null = null;
+
+    const delay = new Promise((resolve) => setTimeout(resolve, 50));
+
+    const mockWorker = createMockWorkerWithAccept(async (port) => {
+      peer2 = await CojsonMessageChannel.acceptFromPort(port, {
+        role: "server",
+      });
+      // Deliberately delay adding the peer
+      await delay;
+      node2.syncManager.addPeer(peer2);
+    });
+
+    const peer1 = await CojsonMessageChannel.expose(mockWorker, {
+      role: "client",
+    });
+    node1.syncManager.addPeer(peer1);
+
+    // Create data on node1 immediately (before node2 has added the peer)
+    const group = node1.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    map.set("key", "value", "trusting");
+
+    await delay;
+
+    // Verify data synced despite the delay
+    const mapOnNode2 = await loadCoValueOrFail<RawCoMap>(node2, map.id);
+    expect(mapOnNode2.get("key")).toBe("value");
+  });
+});

package/src/tests/GarbageCollector.test.ts

@@ -1,7 +1,13 @@
 import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 
 import { setGarbageCollectorMaxAge } from "../config";
-import { TEST_NODE_CONFIG, setupTestAccount, setupTestNode } from "./testUtils";
+import {
+  blockMessageTypeOnOutgoingPeer,
+  TEST_NODE_CONFIG,
+  setupTestAccount,
+  setupTestNode,
+} from "./testUtils";
+import { createSyncStorage } from "./testStorage.js";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -10,6 +16,8 @@ beforeEach(() => {
   // We want to test what happens when the garbage collector kicks in and removes a coValue
   // We set the max age to -1 to make it remove everything
   setGarbageCollectorMaxAge(-1);
+
+  setupTestNode({ isSyncServer: true });
 });
 
 describe("garbage collector", () => {
@@ -19,13 +27,14 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
@@ -40,6 +49,7 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
@@ -51,7 +61,7 @@ describe("garbage collector", () => {
       // This listener keeps the coValue alive
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
@@ -66,42 +76,132 @@ describe("garbage collector", () => {
     expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
   });
 
-  test("coValues are not garbage collected if they are a group or account", async () => {
-    const client = await setupTestAccount();
+  test("coValues are not garbage collected if they are not synced with server peers", async () => {
+    const client = setupTestNode();
 
     client.addStorage({
       ourName: "client",
     });
-    client.node.enableGarbageCollector({
-      garbageCollectGroups: true,
-    });
+    client.node.enableGarbageCollector();
+    const { peer: serverPeer } = client.connectToSyncServer();
+    // Block sync with server
+    const blocker = blockMessageTypeOnOutgoingPeer(serverPeer, "content", {});
 
     const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     client.node.garbageCollector?.collect();
 
-    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(true);
+
+    // Resume sync with server
+    blocker.sendBlockedMessages();
+    blocker.unblock();
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // The coValue should now be collected
+    client.node.garbageCollector?.collect();
+
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+  });
+
+  test("coValues are garbage collected if there are no server peers", async () => {
+    const client = setupTestNode();
+
+    client.addStorage({
+      ourName: "client",
+    });
+    client.node.enableGarbageCollector();
+    // Client is not connected to the sync server
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    client.node.garbageCollector?.collect();
+
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+  });
+
+  test("account coValues are not garbage collected if they have dependencies", async () => {
+    const client = await setupTestAccount({
+      // Add storage before creating the account so it's persisted
+      storage: createSyncStorage({
+        nodeName: "client",
+        storageName: "storage",
+      }),
+    });
+    // The account is created along with its profile, and the group that owns the profile
+    const profile = client.node.expectProfileLoaded(client.accountID);
+    const profileId = profile.id;
+    const profileOwnerId = profile.group.id;
+
+    client.connectToSyncServer();
+    client.node.enableGarbageCollector();
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // First collect removes the profile
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(profileId).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(profileOwnerId).isAvailable()).toBe(true);
+    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+
+    // Second collect removes the profile owner
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(profileOwnerId).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+
+    // Third collect removes the account
+    client.node.garbageCollector?.collect();
     expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(false);
   });
 
-  test("group or account coValues are garbage collected if garbageCollectGroups is true", async () => {
-    const client = await setupTestAccount();
+  test("group coValues are garbage collected if they have no dependencies", async () => {
+    const client = setupTestNode();
 
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
+    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
+  });
+
+  test("group coValues are not garbage collected if they have dependencies", 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");
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // First collect removes the map
+    client.node.garbageCollector?.collect();
     expect(client.node.getCoValue(group.id).isAvailable()).toBe(true);
-    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+
+    // Second collect removes the group
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
   });
 
   test("coValues are not garbage collected if the maxAge is not reached", async () => {
@@ -112,6 +212,7 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const garbageCollector = client.node.garbageCollector;

package/src/tests/StorageApiAsync.test.ts

@@ -81,7 +81,7 @@ async function createTestNode(dbPath?: string) {
   });
 
   onTestFinished(async () => {
-    node.gracefulShutdown();
+    await node.gracefulShutdown();
     await storage.close();
   });
 
@@ -782,6 +782,55 @@ describe("StorageApiAsync", () => {
       const mapOnNode = await loadCoValueOrFail(node, map.id);
       expect(mapOnNode.get("test")).toEqual("value");
     });
+
+    test("should load dependencies again if they were unmounted", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { node, storage } = await createTestNode(dbPath);
+
+      // Create a group and a map owned by that group
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      const map = group.createMap({ test: "value" });
+      await group.core.waitForSync();
+      await map.core.waitForSync();
+
+      const callback = vi.fn((content) =>
+        node.syncManager.handleNewContent(content, "storage"),
+      );
+      const done = vi.fn();
+
+      // Load the map (and its group)
+      await storage.load(map.id, callback, done);
+      callback.mockClear();
+      done.mockClear();
+
+      // Unmount the map and its group
+      storage.onCoValueUnmounted(map.id);
+      storage.onCoValueUnmounted(group.id);
+
+      // Load the map. The group dependency should be loaded again
+      await storage.load(map.id, callback, done);
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenNthCalledWith(
+        1,
+        expect.objectContaining({
+          id: group.id,
+        }),
+      );
+      expect(callback).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({
+          id: map.id,
+        }),
+      );
+
+      expect(done).toHaveBeenCalledWith(true);
+
+      node.setStorage(storage);
+      const mapOnNode = await loadCoValueOrFail(node, map.id);
+      expect(mapOnNode.get("test")).toEqual("value");
+    });
   });
 
   describe("waitForSync", () => {

package/src/tests/StorageApiSync.test.ts

@@ -578,6 +578,55 @@ describe("StorageApiSync", () => {
       const mapOnNode = await loadCoValueOrFail(node, map.id);
       expect(mapOnNode.get("test")).toEqual("value");
     });
+
+    test("should load dependencies again if they were unmounted", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { node, storage } = await createTestNode(dbPath);
+
+      // Create a group and a map owned by that group
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      const map = group.createMap({ test: "value" });
+      await group.core.waitForSync();
+      await map.core.waitForSync();
+
+      const callback = vi.fn((content) =>
+        node.syncManager.handleNewContent(content, "storage"),
+      );
+      const done = vi.fn();
+
+      // Load the map (and its group)
+      await storage.load(map.id, callback, done);
+      callback.mockClear();
+      done.mockClear();
+
+      // Unmount the map and its group
+      storage.onCoValueUnmounted(map.id);
+      storage.onCoValueUnmounted(group.id);
+
+      // Load the map. The group dependency should be loaded again
+      await storage.load(map.id, callback, done);
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenNthCalledWith(
+        1,
+        expect.objectContaining({
+          id: group.id,
+        }),
+      );
+      expect(callback).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({
+          id: map.id,
+        }),
+      );
+
+      expect(done).toHaveBeenCalledWith(true);
+
+      node.setStorage(storage);
+      const mapOnNode = await loadCoValueOrFail(node, map.id);
+      expect(mapOnNode.get("test")).toEqual("value");
+    });
   });
 
   describe("waitForSync", () => {

package/src/tests/SyncManager.processQueues.test.ts

@@ -70,7 +70,7 @@ describe("SyncManager.processQueues", () => {
       await loadCoValueOrFail(client.node, map.id);
 
       // Restart and load from storage
-      client.restart();
+      await client.restart();
       client.connectToSyncServer();
       client.addStorage({ storage });
 

package/src/tests/SyncStateManager.test.ts

@@ -46,7 +46,7 @@ describe("SyncStateManager", () => {
     const newPeerState = client.node.syncManager.peers[peerState.id]!;
 
     expect(updateSpy).toHaveBeenCalledWith(
-      peerState.id,
+      expect.objectContaining({ id: peerState.id }),
       newPeerState.getKnownState(map.core.id)!,
       { uploaded: true },
     );

package/src/tests/coPlainText.test.ts

@@ -355,7 +355,7 @@ test("chunks transactions when when the chars are longer than MAX_RECOMMENDED_TX
 
   await coValue.waitForSync();
 
-  client.restart();
+  await client.restart();
   client.addStorage({
     storage,
   });

package/src/tests/coValueCore.loadFromStorage.test.ts

@@ -45,6 +45,7 @@ function createMockStorage(
       callback: (unsyncedCoValueIDs: RawCoID[]) => void,
     ) => void;
     stopTrackingSyncState?: (id: RawCoID) => void;
+    onCoValueUnmounted?: (id: RawCoID) => void;
     close?: () => Promise<unknown> | undefined;
   } = {},
 ): StorageAPI {
@@ -58,6 +59,7 @@ function createMockStorage(
     trackCoValuesSyncState: opts.trackCoValuesSyncState || vi.fn(),
     getUnsyncedCoValueIDs: opts.getUnsyncedCoValueIDs || vi.fn(),
     stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
+    onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
   };
 }

package/src/tests/knownState.lazyLoading.test.ts

@@ -23,6 +23,7 @@ function createMockStorage(
       callback: (unsyncedCoValueIDs: RawCoID[]) => void,
     ) => void;
     stopTrackingSyncState?: (id: RawCoID) => void;
+    onCoValueUnmounted?: (id: RawCoID) => void;
     close?: () => Promise<unknown> | undefined;
   } = {},
 ): StorageAPI {
@@ -36,6 +37,7 @@ function createMockStorage(
     trackCoValuesSyncState: opts.trackCoValuesSyncState || vi.fn(),
     getUnsyncedCoValueIDs: opts.getUnsyncedCoValueIDs || vi.fn(),
     stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
+    onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
   };
 }