cojson 0.19.20 → 0.19.22

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);
@@ -150,6 +150,44 @@ function trackStorageMessages(
 ) {
   const originalStore = storage.store;
   const originalLoad = storage.load;
+  const originalLoadKnownState = storage.loadKnownState;
+
+  storage.loadKnownState = function (id, callback) {
+    SyncMessagesLog.add({
+      from: nodeName,
+      to: storageName,
+      msg: {
+        action: "lazyLoad",
+        id: id as RawCoID,
+      },
+    });
+
+    return originalLoadKnownState.call(storage, id, (knownState) => {
+      if (knownState) {
+        SyncMessagesLog.add({
+          from: storageName,
+          to: nodeName,
+          msg: {
+            action: "lazyLoadResult",
+            ...knownState,
+          },
+        });
+      } else {
+        SyncMessagesLog.add({
+          from: storageName,
+          to: nodeName,
+          msg: {
+            action: "lazyLoadResult",
+            id: id as RawCoID,
+            header: false,
+            sessions: {},
+          },
+        });
+      }
+
+      return callback(knownState);
+    });
+  };
 
   storage.store = function (data, correctionCallback) {
     SyncMessagesLog.add({

package/src/tests/testUtils.ts

@@ -13,13 +13,15 @@ import {
   AnyRawCoValue,
   type CoID,
   type CoValueCore,
+  MessageChannelLike,
+  MessagePortLike,
   type RawAccount,
   RawAccountID,
   RawCoMap,
   type RawCoValue,
   StorageAPI,
 } from "../exports.js";
-import type { SessionID } from "../ids.js";
+import type { RawCoID, SessionID } from "../ids.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
 import type { Peer, SyncMessage, SyncWhen } from "../sync.js";
@@ -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,
@@ -679,10 +681,22 @@ export async function setupTestAccount(
   };
 }
 
+export type LazyLoadMessage = {
+  action: "lazyLoad";
+  id: RawCoID;
+};
+
+export type LazyLoadResultMessage = {
+  action: "lazyLoadResult";
+  id: RawCoID;
+  header: boolean;
+  sessions: { [sessionID: string]: number };
+};
+
 export type SyncTestMessage = {
   from: string;
   to: string;
-  msg: SyncMessage;
+  msg: SyncMessage | LazyLoadMessage | LazyLoadResultMessage;
 };
 
 export function connectedPeersWithMessagesTracking(opts: {
@@ -799,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);
+      }
+    }),
+  };
+}