cojson 0.18.28 → 0.18.30

package/src/tests/StorageApiAsync.test.ts

@@ -170,7 +170,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after load
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       const groupOnNode = await loadCoValueOrFail(node, group.id);
 
@@ -211,7 +211,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after load
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       const groupOnNode = await loadCoValueOrFail(node, group.id);
       expect(groupOnNode.get("everyone")).toEqual("reader");
@@ -239,7 +239,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after store
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
 
@@ -256,7 +256,7 @@ describe("StorageApiAsync", () => {
 
       // Create a real group and add a member to create transactions
       const group = fixturesNode.createGroup();
-      const knownState = group.core.verified.knownState();
+      const knownState = group.core.knownState();
 
       group.addMember("everyone", "reader");
 
@@ -275,7 +275,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after store
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
 
@@ -288,7 +288,7 @@ describe("StorageApiAsync", () => {
       const { node, storage } = await createTestNode();
 
       const group = fixturesNode.createGroup();
-      const knownState = group.core.verified.knownState();
+      const knownState = group.core.knownState();
 
       group.addMember("everyone", "reader");
 
@@ -309,7 +309,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after store with correction
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
       const groupOnNode = await loadCoValueOrFail(node, group.id);
@@ -355,7 +355,7 @@ describe("StorageApiAsync", () => {
 
       // Verify that storage known state is updated after store with correction
       const finalKnownState = storage.getKnownState(group.id);
-      expect(finalKnownState).toEqual(group.core.verified.knownState());
+      expect(finalKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
       const groupOnNode = await loadCoValueOrFail(node, group.id);
@@ -722,8 +722,8 @@ describe("StorageApiAsync", () => {
       // Verify that storage known states are updated after load
       const updatedGroupKnownState = storage.getKnownState(group.id);
       const updatedMapKnownState = storage.getKnownState(map.id);
-      expect(updatedGroupKnownState).toEqual(group.core.verified.knownState());
-      expect(updatedMapKnownState).toEqual(map.core.verified.knownState());
+      expect(updatedGroupKnownState).toEqual(group.core.knownState());
+      expect(updatedMapKnownState).toEqual(map.core.knownState());
 
       node.setStorage(storage);
       const mapOnNode = await loadCoValueOrFail(node, map.id);
@@ -759,7 +759,7 @@ describe("StorageApiAsync", () => {
 
       // Verify group known state is updated after first load
       const afterGroupLoad = storage.getKnownState(group.id);
-      expect(afterGroupLoad).toEqual(group.core.verified.knownState());
+      expect(afterGroupLoad).toEqual(group.core.knownState());
 
       // Then load the map - the group dependency should already be loaded
       await storage.load(map.id, callback, done);
@@ -776,7 +776,7 @@ describe("StorageApiAsync", () => {
 
       // Verify map known state is updated after second load
       const finalMapKnownState = storage.getKnownState(map.id);
-      expect(finalMapKnownState).toEqual(map.core.verified.knownState());
+      expect(finalMapKnownState).toEqual(map.core.knownState());
 
       node.setStorage(storage);
       const mapOnNode = await loadCoValueOrFail(node, map.id);

package/src/tests/StorageApiSync.test.ts

@@ -152,7 +152,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after load
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       const groupOnNode = await loadCoValueOrFail(node, group.id);
 
@@ -193,7 +193,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after load
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       const groupOnNode = await loadCoValueOrFail(node, group.id);
       expect(groupOnNode.get("everyone")).toEqual("reader");
@@ -220,7 +220,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after store
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
 
@@ -254,7 +254,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after store
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
 
@@ -267,7 +267,7 @@ describe("StorageApiSync", () => {
       const { node, storage } = await createTestNode();
 
       const group = fixturesNode.createGroup();
-      const knownState = group.core.verified.knownState();
+      const knownState = group.core.knownState();
 
       group.addMember("everyone", "reader");
 
@@ -288,7 +288,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after store with correction
       const updatedKnownState = storage.getKnownState(group.id);
-      expect(updatedKnownState).toEqual(group.core.verified.knownState());
+      expect(updatedKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
       const groupOnNode = await loadCoValueOrFail(node, group.id);
@@ -338,7 +338,7 @@ describe("StorageApiSync", () => {
 
       // Verify that storage known state is updated after store with correction
       const finalKnownState = storage.getKnownState(group.id);
-      expect(finalKnownState).toEqual(group.core.verified.knownState());
+      expect(finalKnownState).toEqual(group.core.knownState());
 
       node.setStorage(storage);
       const groupOnNode = await loadCoValueOrFail(node, group.id);
@@ -518,8 +518,8 @@ describe("StorageApiSync", () => {
       // Verify that storage known states are updated after load
       const updatedGroupKnownState = storage.getKnownState(group.id);
       const updatedMapKnownState = storage.getKnownState(map.id);
-      expect(updatedGroupKnownState).toEqual(group.core.verified.knownState());
-      expect(updatedMapKnownState).toEqual(map.core.verified.knownState());
+      expect(updatedGroupKnownState).toEqual(group.core.knownState());
+      expect(updatedMapKnownState).toEqual(map.core.knownState());
 
       node.setStorage(storage);
       const mapOnNode = await loadCoValueOrFail(node, map.id);
@@ -555,7 +555,7 @@ describe("StorageApiSync", () => {
 
       // Verify group known state is updated after first load
       const afterGroupLoad = storage.getKnownState(group.id);
-      expect(afterGroupLoad).toEqual(group.core.verified.knownState());
+      expect(afterGroupLoad).toEqual(group.core.knownState());
 
       // Then load the map - the group dependency should already be loaded
       await storage.load(map.id, callback, done);
@@ -572,7 +572,7 @@ describe("StorageApiSync", () => {
 
       // Verify map known state is updated after second load
       const finalMapKnownState = storage.getKnownState(map.id);
-      expect(finalMapKnownState).toEqual(map.core.verified.knownState());
+      expect(finalMapKnownState).toEqual(map.core.knownState());
 
       node.setStorage(storage);
       const mapOnNode = await loadCoValueOrFail(node, map.id);

package/src/tests/SyncStateManager.test.ts

@@ -39,15 +39,14 @@ describe("SyncStateManager", () => {
     const unsubscribe = subscriptionManager.subscribeToUpdates(updateSpy);
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded;
+      return subscriptionManager.isSynced(peerState, map.core.id);
     });
 
+    const newPeerState = client.node.syncManager.peers[peerState.id]!;
+
     expect(updateSpy).toHaveBeenCalledWith(
       peerState.id,
-      client.node.syncManager.peers[peerState.id]!.knownStates.get(
-        map.core.id,
-      )!,
+      newPeerState.getKnownState(map.core.id)!,
       { uploaded: true },
     );
 
@@ -91,14 +90,11 @@ describe("SyncStateManager", () => {
     });
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded;
+      return subscriptionManager.isSynced(peerState, map.core.id);
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
-      client.node.syncManager.peers[peerState.id]!.knownStates.get(
-        map.core.id,
-      )!,
+      peerState.getKnownState(map.core.id)!,
       { uploaded: true },
     );
 
@@ -120,20 +116,13 @@ describe("SyncStateManager", () => {
 
     const subscriptionManager = client.node.syncManager.syncState;
 
-    expect(
-      subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded,
-    ).toBe(false);
+    expect(subscriptionManager.isSynced(peerState, map.core.id)).toBe(false);
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded;
+      return subscriptionManager.isSynced(peerState, map.core.id);
     });
 
-    expect(
-      subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded,
-    ).toBe(true);
+    expect(subscriptionManager.isSynced(peerState, map.core.id)).toBe(true);
   });
 
   test("unsubscribe stops receiving updates", async () => {
@@ -160,8 +149,7 @@ describe("SyncStateManager", () => {
     anyUpdateSpy.mockClear();
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
-        .uploaded;
+      return subscriptionManager.isSynced(peerState, map.core.id);
     });
 
     expect(anyUpdateSpy).not.toHaveBeenCalled();
@@ -171,7 +159,7 @@ describe("SyncStateManager", () => {
     // Setup nodes
     const client = setupTestNode({ connected: true });
     const serverNode = jazzCloud.node;
-    const { peer, peerOnServer } = client.connectToSyncServer();
+    const { peerState, peerStateOnServer } = client.connectToSyncServer();
 
     // Create test data
     const group = client.node.createGroup();
@@ -181,55 +169,37 @@ describe("SyncStateManager", () => {
 
     // Initially should not be synced
     expect(
-      client.node.syncManager.syncState.getCurrentSyncState(
-        peer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: false });
+      client.node.syncManager.syncState.isSynced(peerState, map.core.id),
+    ).toEqual(false);
 
     // Wait for full sync
     await map.core.waitForSync();
 
     expect(
-      client.node.syncManager.syncState.getCurrentSyncState(
-        peer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: true });
+      client.node.syncManager.syncState.isSynced(peerState, map.core.id),
+    ).toEqual(true);
 
     const mapOnServer = await loadCoValueOrFail(serverNode, map.id);
 
     mapOnServer.set("key2", "value2", "trusting");
 
     expect(
-      client.node.syncManager.syncState.getCurrentSyncState(
-        peer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: true });
+      client.node.syncManager.syncState.isSynced(peerState, map.core.id),
+    ).toEqual(true);
 
     expect(
-      serverNode.syncManager.syncState.getCurrentSyncState(
-        peerOnServer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: false });
+      serverNode.syncManager.syncState.isSynced(peerStateOnServer, map.core.id),
+    ).toEqual(false);
 
     await mapOnServer.core.waitForSync();
 
     expect(
-      client.node.syncManager.syncState.getCurrentSyncState(
-        peer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: true });
+      client.node.syncManager.syncState.isSynced(peerState, map.core.id),
+    ).toEqual(true);
 
     expect(
-      serverNode.syncManager.syncState.getCurrentSyncState(
-        peerOnServer.id,
-        map.core.id,
-      ),
-    ).toEqual({ uploaded: true });
+      serverNode.syncManager.syncState.isSynced(peerStateOnServer, map.core.id),
+    ).toEqual(true);
   });
 
   test("should skip non-persistent closed peers", async () => {

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

@@ -88,3 +88,90 @@ test("should track the account dependency when syncing a group extension", async
     new Set([parentGroup.core.id, sourceClient.accountID]),
   );
 });
+
+test("should track group as dependant when creating a coValue owned by it", () => {
+  const client = setupTestNode();
+
+  const group = client.node.createGroup();
+  const map = group.createMap();
+
+  expect(group.core.dependant).toEqual(new Set([map.core.id]));
+});
+
+test("should track source as dependant when creating a branch", () => {
+  const client = setupTestNode();
+
+  const group = client.node.createGroup();
+  const map = group.createMap();
+
+  const branch = map.core.createBranch("feature-branch", group.id);
+
+  expect(map.core.dependant).toEqual(new Set([branch.id]));
+});
+
+test("should track parent group as dependant when extending a group", () => {
+  const client = setupTestNode();
+
+  const group = client.node.createGroup();
+  const parentGroup = client.node.createGroup();
+
+  group.extend(parentGroup);
+
+  expect(parentGroup.core.dependant).toEqual(new Set([group.core.id]));
+});
+
+test("should track multiple dependants when multiple coValues depend on the same group", () => {
+  const client = setupTestNode();
+
+  const group = client.node.createGroup();
+  const map1 = group.createMap();
+  const map2 = group.createMap();
+  const list = group.createList();
+
+  expect(group.core.dependant).toEqual(
+    new Set([map1.core.id, map2.core.id, list.core.id]),
+  );
+});
+
+test("should track account as dependant when syncing a coValue", async () => {
+  const sourceClient = await setupTestAccount({
+    connected: true,
+  });
+  const targetClient = await setupTestAccount({
+    connected: true,
+  });
+
+  const group = sourceClient.node.createGroup();
+  group.addMember("everyone", "reader");
+  const map = group.createMap();
+
+  map.set("hello", "world");
+
+  await map.core.waitForSync();
+
+  const loadedMap = await loadCoValueOrFail(targetClient.node, map.id);
+  const sourceAccount = targetClient.node.getCoValue(sourceClient.accountID);
+
+  expect(sourceAccount.dependant.has(loadedMap.core.id)).toBe(true);
+});
+
+test("should track account as dependant when syncing a group extension", async () => {
+  const sourceClient = await setupTestAccount({
+    connected: true,
+  });
+  const targetClient = await setupTestAccount({
+    connected: true,
+  });
+
+  const group = sourceClient.node.createGroup();
+  const parentGroup = sourceClient.node.createGroup();
+
+  group.extend(parentGroup);
+
+  await group.core.waitForSync();
+
+  const loadedGroup = await loadCoValueOrFail(targetClient.node, group.id);
+  const sourceAccount = targetClient.node.getCoValue(sourceClient.accountID);
+
+  expect(sourceAccount.dependant.has(loadedGroup.core.id)).toBe(true);
+});

package/src/tests/coValueCore.test.ts

@@ -19,6 +19,7 @@ import {
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
   randomAgentAndSessionID,
+  setupTestAccount,
   setupTestNode,
   tearDownTestMetricReader,
   waitFor,
@@ -148,32 +149,24 @@ describe("transactions that exceed the byte size limit are rejected", () => {
   });
 });
 
-test("New transactions in a group correctly update owned values, including subscriptions", async () => {
-  const [agent, sessionID] = randomAgentAndSessionID();
-  const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
-
-  const timeBeforeEdit = Date.now() - 1000;
-  const dateNowMock = vi
-    .spyOn(Date, "now")
-    .mockImplementation(() => timeBeforeEdit);
+test("new transactions in a group correctly update owned values, including subscriptions", async () => {
+  const client = await setupTestAccount();
 
-  const group = node.createGroup();
+  const agent = client.node.getCurrentAgent();
 
-  await new Promise((resolve) => setTimeout(resolve, 10));
+  const group = client.node.createGroup();
 
   const map = group.createMap();
 
-  map.set("hello", "world");
+  await new Promise((resolve) => setTimeout(resolve, 10));
 
-  const listener = vi.fn();
+  map.set("hello", "world");
 
-  map.subscribe((map) => {
-    listener(map.get("hello"));
-  });
+  const transaction = map.core.getValidSortedTransactions().at(-1);
 
-  expect(listener).toHaveBeenLastCalledWith("world");
+  assert(transaction);
 
-  expect(map.core.getValidSortedTransactions().length).toBe(1);
+  expect(transaction.isValid).toBe(true);
   expect(group.get(agent.id)).toBe("admin");
 
   group.core.makeTransaction(
@@ -185,16 +178,65 @@ test("New transactions in a group correctly update owned values, including subsc
       },
     ],
     "trusting",
+    undefined,
+    transaction.madeAt - 1, // Make the revocation to be before the map update
   );
 
   expect(group.get(agent.id)).toBe("revoked");
-  dateNowMock.mockReset();
+  expect(map.core.getValidSortedTransactions().length).toBe(0);
+});
 
-  // Group invalidation updates are async
-  await waitFor(() => expect(listener).toHaveBeenCalledTimes(2));
+// TODO: The test is skipped because we don't support this invalidation yet
+test.skip("new transactions in a parent group correctly update owned values, including subscriptions", async () => {
+  const client = await setupTestAccount();
 
-  expect(listener).toHaveBeenLastCalledWith(undefined);
-  expect(map.core.getValidSortedTransactions().length).toBe(0);
+  const agent = client.node.getCurrentAgent();
+
+  const group = client.node.createGroup();
+  const parentGroup = client.node.createGroup();
+  group.extend(parentGroup);
+  group.core.makeTransaction(
+    [
+      {
+        op: "set",
+        key: agent.id,
+        value: "revoked",
+      },
+    ],
+    "trusting",
+  );
+
+  const map = group.createMap();
+
+  await new Promise((resolve) => setTimeout(resolve, 10));
+
+  map.set("hello", "world");
+
+  const transaction = map.core.getValidSortedTransactions().at(-1);
+
+  assert(transaction);
+
+  expect(transaction.isValid).toBe(true);
+  expect(group.roleOfInternal(agent.id)).toBe("admin");
+
+  parentGroup.core.makeTransaction(
+    [
+      {
+        op: "set",
+        key: agent.id,
+        value: "revoked",
+      },
+    ],
+    "trusting",
+    undefined,
+    transaction.madeAt - 1, // Make the revocation to be before the map update
+  );
+
+  expect(group.roleOfInternal(agent.id)).toBe(undefined);
+
+  await waitFor(() =>
+    expect(map.core.getValidSortedTransactions().length).toBe(0),
+  );
 });
 
 test("correctly records transactions", async () => {