cojson 0.8.34 → 0.8.36

package/src/sync.ts

@@ -304,14 +304,19 @@ export class SyncManager {
 
     if (peerState.isServerOrStoragePeer()) {
       const initialSync = async () => {
-        for (const id of this.local.coValuesStore.getKeys()) {
-          // console.log("subscribing to after peer added", id, peer.id)
-          await this.subscribeToIncludingDependencies(id, peerState);
+        for (const entry of this.local.coValuesStore.getValues()) {
+          await this.subscribeToIncludingDependencies(entry.id, peerState);
 
-          peerState.optimisticKnownStates.dispatch({
-            type: "SET_AS_EMPTY",
-            id,
-          });
+          if (entry.state.type === "available") {
+            await this.sendNewContentIncludingDependencies(entry.id, peerState);
+          }
+
+          if (!peerState.optimisticKnownStates.has(entry.id)) {
+            peerState.optimisticKnownStates.dispatch({
+              type: "SET_AS_EMPTY",
+              id: entry.id,
+            });
+          }
         }
       };
       void initialSync();
@@ -403,27 +408,39 @@ export class SyncManager {
     }
 
     if (entry.state.type === "loading") {
-      const value = await entry.getCoValue();
+      // We need to return from handleLoad immediately and wait for the CoValue to be loaded
+      // in a new task, otherwise we might block further incoming content messages that would
+      // resolve the CoValue as available. This can happen when we receive fresh
+      // content from a client, but we are a server with our own upstream server(s)
+      entry
+        .getCoValue()
+        .then(async (value) => {
+          if (value === "unavailable") {
+            peer.dispatchToKnownStates({
+              type: "SET",
+              id: msg.id,
+              value: knownStateIn(msg),
+            });
+            peer.toldKnownState.add(msg.id);
+
+            this.trySendToPeer(peer, {
+              action: "known",
+              id: msg.id,
+              header: false,
+              sessions: {},
+            }).catch((e) => {
+              console.error("Error sending known state back", e);
+            });
 
-      if (value === "unavailable") {
-        peer.dispatchToKnownStates({
-          type: "SET",
-          id: msg.id,
-          value: knownStateIn(msg),
-        });
-        peer.toldKnownState.add(msg.id);
-
-        this.trySendToPeer(peer, {
-          action: "known",
-          id: msg.id,
-          header: false,
-          sessions: {},
-        }).catch((e) => {
-          console.error("Error sending known state back", e);
-        });
+            return;
+          }
 
-        return;
-      }
+          await this.tellUntoldKnownStateIncludingDependencies(msg.id, peer);
+          await this.sendNewContentIncludingDependencies(msg.id, peer);
+        })
+        .catch((e) => {
+          console.error("Error loading coValue in handleLoad loading state", e);
+        });
     }
 
     if (entry.state.type === "available") {

package/src/tests/group.test.ts

@@ -5,7 +5,13 @@ import { RawCoStream } from "../coValues/coStream.js";
 import { RawBinaryCoStream } from "../coValues/coStream.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  createThreeConnectedNodes,
+  createTwoConnectedNodes,
+  loadCoValueOrFail,
+  randomAnonymousAccountAndSessionID,
+  waitFor,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -53,3 +59,148 @@ test("Can create a FileStream in a group", () => {
   expect(stream.headerMeta.type).toEqual("binary");
   expect(stream instanceof RawBinaryCoStream).toEqual(true);
 });
+
+test("Remove a member from a group where the admin role is inherited", async () => {
+  const { node1, node2, node3, node1ToNode2Peer, node2ToNode3Peer } =
+    createThreeConnectedNodes("server", "server", "server");
+
+  const group = node1.createGroup();
+
+  group.addMember(node2.account, "admin");
+  group.addMember(node3.account, "reader");
+
+  const groupOnNode2 = await loadCoValueOrFail(node2, group.id);
+
+  // The account of node2 create a child group and extend the initial group
+  // This way the node1 account should become "admin" of the child group
+  // by inheriting the admin role from the initial group
+  const childGroup = node2.createGroup();
+  childGroup.extend(groupOnNode2);
+
+  const map = childGroup.createMap();
+  map.set("test", "Available to everyone");
+
+  const mapOnNode3 = await loadCoValueOrFail(node3, map.id);
+
+  // Check that the sync between node2 and node3 worked
+  expect(mapOnNode3.get("test")).toEqual("Available to everyone");
+
+  // The node1 account removes the reader from the group
+  // The reader should be automatically kicked out of the child group
+  await group.removeMember(node3.account);
+
+  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+
+  // Update the map to check that node3 can't read updates anymore
+  map.set("test", "Hidden to node3");
+
+  await node2.syncManager.waitForUploadIntoPeer(node2ToNode3Peer.id, map.id);
+
+  // Check that the value has not been updated on node3
+  expect(mapOnNode3.get("test")).toEqual("Available to everyone");
+
+  const mapOnNode1 = await loadCoValueOrFail(node1, map.id);
+
+  expect(mapOnNode1.get("test")).toEqual("Hidden to node3");
+});
+
+test("An admin should be able to rotate the readKey on child groups and keep access to new coValues", async () => {
+  const { node1, node2, node3, node1ToNode2Peer, node2ToNode1Peer } =
+    createThreeConnectedNodes("server", "server", "server");
+
+  const group = node1.createGroup();
+
+  group.addMember(node2.account, "admin");
+  group.addMember(node3.account, "reader");
+
+  const groupOnNode2 = await loadCoValueOrFail(node2, group.id);
+
+  // The account of node2 create a child group and extend the initial group
+  // This way the node1 account should become "admin" of the child group
+  // by inheriting the admin role from the initial group
+  const childGroup = node2.createGroup();
+  childGroup.extend(groupOnNode2);
+
+  await node2.syncManager.waitForUploadIntoPeer(
+    node2ToNode1Peer.id,
+    childGroup.id,
+  );
+
+  // The node1 account removes the reader from the group
+  // In this case we want to ensure that node1 is still able to read new coValues
+  // Even if some childs are not available when the readKey is rotated
+  await group.removeMember(node3.account);
+  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+
+  const map = childGroup.createMap();
+  map.set("test", "Available to node1");
+
+  const mapOnNode1 = await loadCoValueOrFail(node1, map.id);
+  expect(mapOnNode1.get("test")).toEqual("Available to node1");
+});
+
+test("An admin should be able to rotate the readKey on child groups even if it was unavailable when kicking out a member from a parent group", async () => {
+  const { node1, node2, node3, node1ToNode2Peer, node2ToNode1Peer } =
+    createThreeConnectedNodes("server", "server", "server");
+
+  const group = node1.createGroup();
+
+  group.addMember(node2.account, "admin");
+  group.addMember(node3.account, "reader");
+
+  const groupOnNode2 = await loadCoValueOrFail(node2, group.id);
+
+  // The account of node2 create a child group and extend the initial group
+  // This way the node1 account should become "admin" of the child group
+  // by inheriting the admin role from the initial group
+  const childGroup = node2.createGroup();
+  childGroup.extend(groupOnNode2);
+
+  // The node1 account removes the reader from the group
+  // In this case we want to ensure that node1 is still able to read new coValues
+  // Even if some childs are not available when the readKey is rotated
+  await group.removeMember(node3.account);
+  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+
+  const map = childGroup.createMap();
+  map.set("test", "Available to node1");
+
+  const mapOnNode1 = await loadCoValueOrFail(node1, map.id);
+  expect(mapOnNode1.get("test")).toEqual("Available to node1");
+});
+
+test("An admin should be able to rotate the readKey on child groups even if it was unavailable when kicking out a member from a parent group (grandChild)", async () => {
+  const { node1, node2, node3, node1ToNode2Peer } = createThreeConnectedNodes(
+    "server",
+    "server",
+    "server",
+  );
+
+  const group = node1.createGroup();
+
+  group.addMember(node2.account, "admin");
+  group.addMember(node3.account, "reader");
+
+  const groupOnNode2 = await loadCoValueOrFail(node2, group.id);
+
+  // The account of node2 create a child group and extend the initial group
+  // This way the node1 account should become "admin" of the child group
+  // by inheriting the admin role from the initial group
+  const childGroup = node2.createGroup();
+  childGroup.extend(groupOnNode2);
+  const grandChildGroup = node2.createGroup();
+  grandChildGroup.extend(childGroup);
+
+  // The node1 account removes the reader from the group
+  // In this case we want to ensure that node1 is still able to read new coValues
+  // Even if some childs are not available when the readKey is rotated
+  await group.removeMember(node3.account);
+  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+
+  const map = childGroup.createMap();
+  map.set("test", "Available to node1");
+
+  const mapOnNode1 = await loadCoValueOrFail(node1, map.id);
+
+  expect(mapOnNode1.get("test")).toEqual("Available to node1");
+});