cojson 0.19.21 → 0.19.22

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

@@ -50,6 +50,47 @@ describe("sync after the garbage collector has run", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> storage | LOAD Map sessions: empty",
+        "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Group sessions: header/3",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("loading a coValue from the sync server that was removed by the garbage collector along with its owner", async () => {
+    const client = setupTestNode();
+
+    client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    await map.core.waitForSync();
+
+    // force the garbage collector to run twice to remove the map and its group
+    jazzCloud.node.garbageCollector?.collect();
+    jazzCloud.node.garbageCollector?.collect();
+
+    expect(jazzCloud.node.getCoValue(group.id).isAvailable()).toBe(false);
+    expect(jazzCloud.node.getCoValue(map.id).isAvailable()).toBe(false);
+
+    SyncMessagesLog.clear();
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -103,7 +144,6 @@ describe("sync after the garbage collector has run", () => {
       [
         "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | KNOWN Map sessions: header/2",
         "server -> storage | CONTENT Map header: false new: After: 0 New: 1",
@@ -112,41 +152,30 @@ describe("sync after the garbage collector has run", () => {
   });
 
   test("syncing a coValue that was removed by the garbage collector", async () => {
-    const edge = setupTestNode();
-    edge.addStorage({
-      ourName: "edge",
-    });
-    edge.connectToSyncServer({
-      syncServer: jazzCloud.node,
-      syncServerName: "server",
-      ourName: "edge",
-    });
-    edge.node.enableGarbageCollector();
     const client = setupTestNode();
-
-    client.connectToSyncServer({
-      syncServer: edge.node,
-      syncServerName: "edge",
+    client.addStorage({
+      ourName: "client",
     });
+    client.node.enableGarbageCollector();
 
-    const group = edge.node.createGroup();
-    group.addMember("everyone", "writer");
-
-    await group.core.waitForSync();
-
+    const group = client.node.createGroup();
     const map = group.createMap();
-
     map.set("hello", "updated", "trusting");
 
     // force the garbage collector to run before the transaction is synced
-    edge.node.garbageCollector?.collect();
-    expect(edge.node.getCoValue(map.id).isAvailable()).toBe(false);
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
 
     SyncMessagesLog.clear();
 
+    client.connectToSyncServer();
+
+    // Wait for unsynced coValues to be resumed and synced after connecting to server
+    await client.node.syncManager.waitForAllCoValuesSync();
+
     // The storage should work even after the coValue is unmounted, so the load should be successful
-    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
-    expect(mapOnClient.get("hello")).toEqual("updated");
+    const mapOnServer = await loadCoValueOrFail(jazzCloud.node, map.id);
+    expect(mapOnServer.get("hello")).toEqual("updated");
 
     expect(
       SyncMessagesLog.getMessages({
@@ -155,18 +184,22 @@ describe("sync after the garbage collector has run", () => {
       }),
     ).toMatchInlineSnapshot(`
       [
-        "client -> edge | LOAD Map sessions: empty",
-        "edge -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> server | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> storage | LOAD Map sessions: empty",
-        "storage -> edge | CONTENT Group header: true new: After: 0 New: 5",
-        "storage -> edge | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> client | CONTENT Group header: true new: After: 0 New: 5",
-        "edge -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "server -> edge | KNOWN Map sessions: header/1",
+        "client -> server | LOAD Map sessions: empty",
+        "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 -> client | KNOWN Map sessions: empty",
+        "server -> storage | GET_KNOWN_STATE Group",
+        "storage -> server | GET_KNOWN_STATE_RESULT Group sessions: empty",
+        "server -> client | KNOWN Group sessions: empty",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Map sessions: header/1",
         "server -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> edge | KNOWN Group sessions: header/5",
-        "client -> edge | KNOWN Map sessions: header/1",
       ]
     `);
   });

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

@@ -514,7 +514,7 @@ describe("loading coValues from server", () => {
     });
 
     // Makes the CoValues unavailable on the server
-    jazzCloud.restart();
+    await jazzCloud.restart();
 
     const client = setupTestNode({
       connected: true,
@@ -1476,7 +1476,7 @@ describe("lazy storage load optimization", () => {
 
     // Restart the server to clear memory (keeping storage)
     // Now the server has no CoValues in memory, only in storage
-    jazzCloud.restart();
+    await jazzCloud.restart();
     jazzCloud.node.setStorage(storage);
 
     SyncMessagesLog.clear();
@@ -1519,7 +1519,7 @@ describe("lazy storage load optimization", () => {
     await map.core.waitForSync();
 
     // Restart the server to clear memory (keeping storage)
-    jazzCloud.restart();
+    await jazzCloud.restart();
     jazzCloud.node.setStorage(storage);
 
     SyncMessagesLog.clear();
@@ -1643,7 +1643,6 @@ describe("lazy storage load optimization", () => {
       [
         "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | KNOWN Map sessions: header/2",
         "server -> storage | CONTENT Map header: false new: After: 0 New: 1",
@@ -1702,7 +1701,6 @@ describe("lazy storage load optimization", () => {
       [
         "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> server | CONTENT Map header: true new: After: 0 New: 73 expectContentUntil: header/201",
         "server -> client | KNOWN Map sessions: header/74",
         "server -> storage | CONTENT Map header: false new: After: 0 New: 1",

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

@@ -506,7 +506,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       ]
     `);
 
-    edge.restart();
+    await edge.restart();
 
     edge.connectToSyncServer({
       syncServerName: "core",

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

@@ -167,7 +167,7 @@ describe("peer reconciliation", () => {
 
     await map.core.waitForSync();
 
-    jazzCloud.restart();
+    await jazzCloud.restart();
     SyncMessagesLog.clear();
     client.connectToSyncServer();
 
@@ -222,7 +222,7 @@ describe("peer reconciliation", () => {
 
     await map.core.waitForSync();
 
-    jazzCloud.restart();
+    await jazzCloud.restart();
     SyncMessagesLog.clear();
     client.connectToSyncServer();
 
@@ -305,7 +305,7 @@ describe("peer reconciliation", () => {
 
     await map.core.waitForSync();
 
-    jazzCloud.restart();
+    await jazzCloud.restart();
 
     SyncMessagesLog.clear();
     client.connectToSyncServer();

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

@@ -83,7 +83,7 @@ describe("client with storage syncs with server", () => {
 
     await loadCoValueOrFail(client.node, map.id);
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer();
     client.addStorage({
@@ -167,7 +167,7 @@ describe("client with storage syncs with server", () => {
 
     await map.core.waitForSync();
 
-    client.restart();
+    await client.restart();
 
     client.addStorage({
       storage,
@@ -217,7 +217,7 @@ describe("client with storage syncs with server", () => {
     branch.set("branchKey", "branchValue");
     await branch.core.waitForSync();
 
-    client.restart();
+    await client.restart();
     client.addStorage({
       storage,
     });
@@ -388,7 +388,7 @@ describe("client syncs with a server with storage", () => {
 
     SyncMessagesLog.clear();
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer({
       ourName: "client",
@@ -457,7 +457,7 @@ describe("client syncs with a server with storage", () => {
 
     expect(correctionSpy).not.toHaveBeenCalled();
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer({
       ourName: "client",
@@ -771,7 +771,7 @@ describe("client syncs with a server with storage", () => {
 
     SyncMessagesLog.clear();
 
-    syncServer.restart();
+    await syncServer.restart();
     syncServer.addStorage({
       ourName: "syncServer",
       storage,
@@ -848,7 +848,7 @@ describe("client syncs with a server with storage", () => {
       ]);
 
       // Restart to load from storage
-      client.restart();
+      await client.restart();
       client.addStorage({ storage });
 
       // Load all maps concurrently from storage
@@ -892,7 +892,7 @@ describe("client syncs with a server with storage", () => {
       SyncMessagesLog.clear();
 
       // Restart client with storage
-      client.restart();
+      await client.restart();
       client.connectToSyncServer();
       client.addStorage({ storage });
 
@@ -985,7 +985,7 @@ describe("client syncs with a server with storage", () => {
 
       SyncMessagesLog.clear();
 
-      syncServer.restart();
+      await syncServer.restart();
       syncServer.addStorage({
         ourName: "syncServer",
         storage,

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

@@ -72,7 +72,7 @@ describe("client with storage syncs with server", () => {
     const firstLoad = await loadCoValueOrFail(client.node, map.id);
     await firstLoad.core.waitForSync(); // Need to wait for sync with storage
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer();
     client.addStorage({
@@ -311,7 +311,7 @@ describe("client syncs with a server with storage", () => {
 
     SyncMessagesLog.clear();
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer({
       ourName: "client",
@@ -406,7 +406,7 @@ describe("client syncs with a server with storage", () => {
     const largeMapContent =
       largeMap.core.newContentSince(undefined)?.slice(0, 4) ?? [];
 
-    client.restart();
+    await client.restart();
 
     const newSyncServer = setupTestNode({
       isSyncServer: true,
@@ -518,7 +518,7 @@ describe("client syncs with a server with storage", () => {
 
     expect(correctionSpy).not.toHaveBeenCalled();
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer({
       ourName: "client",
@@ -566,14 +566,14 @@ describe("client syncs with a server with storage", () => {
 
     await largeMap.core.waitForSync();
 
-    server.restart();
+    await server.restart();
 
     server.addStorage({
       ourName: "server",
       storage: serverStorage,
     });
 
-    client.restart();
+    await client.restart();
 
     client.connectToSyncServer({
       ourName: "client",
@@ -703,7 +703,7 @@ describe("client syncs with a server with storage", () => {
 
     SyncMessagesLog.clear();
 
-    syncServer.restart();
+    await syncServer.restart();
     syncServer.addStorage({
       ourName: "syncServer",
       storage,

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

@@ -73,6 +73,56 @@ describe("coValue sync state tracking", () => {
     expect(unsyncedTracker.has(map.id)).toBe(true);
   });
 
+  test("coValue is marked as synced after connecting to a server peer", async () => {
+    const client = setupTestNode({ connected: false });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.node.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    client.connectToSyncServer();
+
+    const serverPeer =
+      client.node.syncManager.peers[jazzCloud.node.currentSessionID]!;
+    await waitFor(() =>
+      client.node.syncManager.syncState.isSynced(serverPeer, map.id),
+    );
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("coValue is NOT marked as synced after uploading it to a client peer", async () => {
+    const client = setupTestNode({ connected: false });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.node.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    const anotherClient = setupTestNode({ connected: false });
+    anotherClient.connectToSyncServer({
+      syncServer: client.node,
+    });
+
+    // Load the coValue from the client to trigger sync between the server and the client
+    await anotherClient.node.loadCoValueCore(map.id);
+
+    const clientPeer =
+      client.node.syncManager.peers[anotherClient.node.currentSessionID]!;
+    await waitFor(() =>
+      client.node.syncManager.syncState.isSynced(clientPeer, map.id),
+    );
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+  });
+
   test("only tracks sync state for persistent servers peers", async () => {
     const { node: client, connectToSyncServer } = setupTestNode({
       connected: true,
@@ -262,7 +312,7 @@ describe("sync resumption", () => {
     expect(unsyncedTracker.has(map.id)).toBe(true);
     expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(2);
 
-    client.restart();
+    await client.restart();
     client.addStorage({ storage });
     const { peerState: serverPeerState } = client.connectToSyncServer();
 
@@ -300,7 +350,7 @@ describe("sync resumption", () => {
     }
     expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(101);
 
-    client.restart();
+    await client.restart();
     client.addStorage({ storage });
     const { peerState: serverPeerState } = client.connectToSyncServer();
 
@@ -339,7 +389,7 @@ describe("sync resumption", () => {
 
     expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(2);
 
-    client.restart();
+    await client.restart();
     client.addStorage({ storage });
     const newSyncServer = setupTestNode({ isSyncServer: true });
     const { peerState: newServerPeerState } = client.connectToSyncServer({
@@ -377,7 +427,7 @@ describe("sync resumption", () => {
     expect(unsyncedCoValueIDs).toContain(map.id);
     expect(unsyncedCoValueIDs).toContain(group.id);
 
-    client.restart();
+    await client.restart();
     client.addStorage({ storage });
     const newPeer = setupTestNode({ isSyncServer: true });
     client.connectToSyncServer({

package/src/tests/testStorage.ts

@@ -104,8 +104,8 @@ export async function createAsyncStorage({
     new LibSQLSqliteAsyncDriver(getDbPath(filename)),
   );
 
-  onTestFinished(() => {
-    storage.close();
+  onTestFinished(async () => {
+    await storage.close();
   });
 
   trackStorageMessages(storage, nodeName, storageName);

package/src/tests/testUtils.ts

@@ -13,6 +13,8 @@ import {
   AnyRawCoValue,
   type CoID,
   type CoValueCore,
+  MessageChannelLike,
+  MessagePortLike,
   type RawAccount,
   RawAccountID,
   RawCoMap,
@@ -187,8 +189,8 @@ export function newGroupHighLevel() {
 
   const group = node.createGroup();
 
-  onTestFinished(() => {
-    node.gracefulShutdown();
+  onTestFinished(async () => {
+    await node.gracefulShutdown();
   });
   return { admin, node, group };
 }
@@ -517,8 +519,8 @@ export function setupTestNode(
     connectToSyncServer();
   }
 
-  onTestFinished(() => {
-    node.gracefulShutdown();
+  onTestFinished(async () => {
+    await node.gracefulShutdown();
   });
 
   const ctx = {
@@ -526,8 +528,8 @@ export function setupTestNode(
     connectToSyncServer,
     addStorage,
     addAsyncStorage,
-    restart: () => {
-      node.gracefulShutdown();
+    restart: async () => {
+      await node.gracefulShutdown();
       ctx.node = node = new LocalNode(
         admin.agentSecret,
         session,
@@ -811,3 +813,80 @@ export function fillCoMapWithLargeData(map: RawCoMap) {
 
   return map;
 }
+
+// ============================================================================
+// MessageChannel Test Helpers
+// ============================================================================
+
+/**
+ * Type guard to check if a message is a SyncMessage.
+ */
+export function isSyncMessage(msg: unknown): msg is SyncMessage {
+  return (
+    typeof msg === "object" &&
+    msg !== null &&
+    "action" in msg &&
+    typeof (msg as { action: unknown }).action === "string"
+  );
+}
+
+/**
+ * Creates a MessageChannel that logs all sync messages exchanged between ports.
+ * Similar to connectedPeersWithMessagesTracking but for MessageChannel.
+ */
+export function createTrackedMessageChannel(opts: {
+  port1Name?: string;
+  port2Name?: string;
+}) {
+  const { port1, port2 } = new MessageChannel();
+  const port1Name = opts.port1Name ?? "port1";
+  const port2Name = opts.port2Name ?? "port2";
+
+  // Wrap port1.postMessage to log messages
+  const originalPort1PostMessage = port1.postMessage.bind(port1);
+  port1.postMessage = (message, transfer) => {
+    if (isSyncMessage(message)) {
+      SyncMessagesLog.add({
+        from: port1Name,
+        to: port2Name,
+        msg: message,
+      });
+    }
+
+    originalPort1PostMessage(message, transfer);
+  };
+
+  // Wrap port2.postMessage to log messages
+  const originalPort2PostMessage = port2.postMessage.bind(port2);
+  port2.postMessage = (message, transfer) => {
+    if (isSyncMessage(message)) {
+      SyncMessagesLog.add({
+        from: port2Name,
+        to: port1Name,
+        msg: message,
+      });
+    }
+
+    originalPort2PostMessage(message, transfer);
+  };
+
+  return { port1, port2 };
+}
+
+/**
+ * Creates a mock worker target that simulates receiving a port
+ * and calling a callback with the received port (simulating a connection handshake).
+ */
+export function createMockWorkerWithAccept(
+  onPortReceived: (port: MessagePortLike) => Promise<void>,
+) {
+  return {
+    postMessage: vi.fn().mockImplementation((data, transfer) => {
+      if (data?.type === "jazz:port" && transfer?.[0]) {
+        const port = transfer[0] as MessagePortLike;
+        // Simulate the worker receiving the port and calling accept
+        onPortReceived(port);
+      }
+    }),
+  };
+}