cojson 0.9.19 → 0.10.0

package/src/permissions.ts

@@ -2,7 +2,13 @@ import { CoID } from "./coValue.js";
 import { CoValueCore, Transaction } from "./coValueCore.js";
 import { RawAccount, RawAccountID, RawProfile } from "./coValues/account.js";
 import { MapOpPayload } from "./coValues/coMap.js";
-import { EVERYONE, Everyone, RawGroup } from "./coValues/group.js";
+import {
+  EVERYONE,
+  Everyone,
+  ParentGroupReferenceRole,
+  RawGroup,
+  isInheritableRole,
+} from "./coValues/group.js";
 import { KeyID } from "./crypto/crypto.js";
 import {
   AgentID,
@@ -141,6 +147,7 @@ function resolveMemberStateFromParentReference(
   coValue: CoValueCore,
   memberState: MemberState,
   parentReference: ParentGroupReference,
+  roleMapping: ParentGroupReferenceRole,
   extendChain: Set<CoValueCore["id"]>,
 ) {
   const parentGroup = coValue.node.expectCoValueLoaded(
@@ -174,8 +181,12 @@ function resolveMemberStateFromParentReference(
     const parentRole = parentGroupMemberState[agent];
     const currentRole = memberState[agent];
 
-    if (parentRole && isHigherRole(parentRole, currentRole)) {
-      memberState[agent] = parentRole;
+    if (isInheritableRole(parentRole)) {
+      if (roleMapping !== "extend" && isHigherRole(roleMapping, currentRole)) {
+        memberState[agent] = roleMapping;
+      } else if (isHigherRole(parentRole, currentRole)) {
+        memberState[agent] = parentRole;
+      }
     }
   }
 }
@@ -317,6 +328,7 @@ function determineValidTransactionsForGroup(
         coValue,
         memberState,
         change.key,
+        change.value as ParentGroupReferenceRole,
         extendChain,
       );
 

package/src/tests/SyncStateManager.test.ts

@@ -1,43 +1,36 @@
-import { describe, expect, onTestFinished, test, vi } from "vitest";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 import {
   GlobalSyncStateListenerCallback,
   PeerSyncStateListenerCallback,
 } from "../SyncStateManager.js";
-import { accountHeaderForInitialAgentSecret } from "../coValues/account.js";
 import { connectedPeers } from "../streamUtils.js";
 import { emptyKnownState } from "../sync.js";
 import {
   blockMessageTypeOnOutgoingPeer,
+  connectNodeToSyncServer,
   createTestNode,
-  createTwoConnectedNodes,
   loadCoValueOrFail,
+  setupSyncServer,
   waitFor,
 } from "./testUtils.js";
 
+let jazzCloud = setupSyncServer();
+
+beforeEach(async () => {
+  jazzCloud = setupSyncServer();
+});
+
 describe("SyncStateManager", () => {
   test("subscribeToUpdates receives updates when peer state changes", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     const subscriptionManager = client.syncManager.syncState;
 
     const updateSpy: GlobalSyncStateListenerCallback = vi.fn();
@@ -46,21 +39,21 @@ describe("SyncStateManager", () => {
     await client.syncManager.actuallySyncCoValue(map.core);
 
     expect(updateSpy).toHaveBeenCalledWith(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       emptyKnownState(map.core.id),
       { uploaded: false },
     );
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(updateSpy).toHaveBeenCalledWith(
-      "jazzCloudConnection",
-      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+      nodeToServerPeer.id,
+      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -73,42 +66,30 @@ describe("SyncStateManager", () => {
   test("subscribeToPeerUpdates receives updates only for specific peer", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
     const [clientStoragePeer] = connectedPeers("clientStorage", "unusedPeer", {
       peer1role: "client",
       peer2role: "server",
     });
 
-    client.syncManager.addPeer(jazzCloudAsPeer);
     client.syncManager.addPeer(clientStoragePeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
 
     const subscriptionManager = client.syncManager.syncState;
 
     const updateToJazzCloudSpy: PeerSyncStateListenerCallback = vi.fn();
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToPeerUpdates(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       updateToJazzCloudSpy,
     );
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
-      "clientStorage",
+      clientStoragePeer.id,
       updateToStorageSpy,
     );
 
@@ -126,13 +107,13 @@ describe("SyncStateManager", () => {
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
-      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -147,80 +128,50 @@ describe("SyncStateManager", () => {
   test("getIsCoValueFullyUploadedIntoPeer returns correct status", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     await client.syncManager.actuallySyncCoValue(map.core);
 
     const subscriptionManager = client.syncManager.syncState;
 
     expect(
-      subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
-        map.core.id,
-      ).uploaded,
+      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+        .uploaded,
     ).toBe(false);
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(
-      subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
-        map.core.id,
-      ).uploaded,
+      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+        .uploaded,
     ).toBe(true);
   });
 
   test("unsubscribe stops receiving updates", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     const subscriptionManager = client.syncManager.syncState;
     const anyUpdateSpy = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       anyUpdateSpy,
     );
 
@@ -233,7 +184,7 @@ describe("SyncStateManager", () => {
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
@@ -243,22 +194,21 @@ describe("SyncStateManager", () => {
 
   test("getCurrentSyncState should return the correct state", async () => {
     // Setup nodes
+    const clientNode = createTestNode();
+    const serverNode = jazzCloud;
     const {
-      node1: clientNode,
-      node2: serverNode,
-      node1ToNode2Peer: clientToServerPeer,
-      node2ToNode1Peer: serverToClientPeer,
-    } = await createTwoConnectedNodes("client", "server");
-
+      nodeToServerPeer: clientToServerPeer,
+      serverToNodePeer: serverToClientPeer,
+    } = connectNodeToSyncServer(clientNode);
     // Create test data
-    const group = clientNode.node.createGroup();
+    const group = clientNode.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
     group.addMember("everyone", "writer");
 
     // Initially should not be synced
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
@@ -268,13 +218,13 @@ describe("SyncStateManager", () => {
     await map.core.waitForSync();
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
-    const mapOnServer = await loadCoValueOrFail(serverNode.node, map.id);
+    const mapOnServer = await loadCoValueOrFail(serverNode, map.id);
 
     // Block the content messages so the client won't fully sync immediately
     const outgoing = blockMessageTypeOnOutgoingPeer(
@@ -285,14 +235,14 @@ describe("SyncStateManager", () => {
     mapOnServer.set("key2", "value2", "trusting");
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
-      serverNode.node.syncManager.syncState.getCurrentSyncState(
+      serverNode.syncManager.syncState.getCurrentSyncState(
         serverToClientPeer.id,
         map.core.id,
       ),
@@ -304,14 +254,14 @@ describe("SyncStateManager", () => {
     await mapOnServer.core.waitForSync();
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
-      serverNode.node.syncManager.syncState.getCurrentSyncState(
+      serverNode.syncManager.syncState.getCurrentSyncState(
         serverToClientPeer.id,
         map.core.id,
       ),

package/src/tests/coValueState.test.ts

@@ -1,10 +1,24 @@
-import { describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 import { PeerState } from "../PeerState";
 import { CoValueCore } from "../coValueCore";
-import { CO_VALUE_LOADING_MAX_RETRIES, CoValueState } from "../coValueState";
+import { CO_VALUE_LOADING_CONFIG, CoValueState } from "../coValueState";
 import { RawCoID } from "../ids";
 import { Peer } from "../sync";
 
+const initialMaxRetries = CO_VALUE_LOADING_CONFIG.MAX_RETRIES;
+
+function mockMaxRetries(maxRetries: number) {
+  CO_VALUE_LOADING_CONFIG.MAX_RETRIES = maxRetries;
+
+  onTestFinished(() => {
+    CO_VALUE_LOADING_CONFIG.MAX_RETRIES = initialMaxRetries;
+  });
+}
+
+beforeEach(() => {
+  mockMaxRetries(5);
+});
+
 describe("CoValueState", () => {
   const mockCoValueId = "co_test123" as RawCoID;
 
@@ -92,18 +106,18 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toBe("unavailable");
@@ -145,8 +159,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -154,7 +168,7 @@ describe("CoValueState", () => {
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toBe("unavailable");
@@ -194,8 +208,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -203,7 +217,7 @@ describe("CoValueState", () => {
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toEqual("unavailable");
@@ -214,6 +228,8 @@ describe("CoValueState", () => {
   test("should handle the coValues that become available in between of the retries", async () => {
     vi.useFakeTimers();
 
+    mockMaxRetries(5);
+
     let retries = 0;
 
     const peer1 = createMockPeerState(
@@ -244,8 +260,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES + 1; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES + 1; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -278,8 +294,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -290,7 +306,9 @@ describe("CoValueState", () => {
 
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(5);
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
+    );
     expect(state.state.type).toBe("available");
     await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
 
@@ -300,6 +318,8 @@ describe("CoValueState", () => {
   test("should stop retrying when value becomes available", async () => {
     vi.useFakeTimers();
 
+    mockMaxRetries(5);
+
     let run = 1;
 
     const peer1 = createMockPeerState(
@@ -327,7 +347,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -372,7 +392,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -421,7 +441,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -449,12 +469,14 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES * 2; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES * 2; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(5);
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
+    );
 
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toEqual("unavailable");