cojson 0.13.27 → 0.13.29

package/src/tests/group.addMember.test.ts

@@ -0,0 +1,432 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { expectMap } from "../coValue.js";
+import {
+  SyncMessagesLog,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
+
+beforeEach(async () => {
+  SyncMessagesLog.clear();
+  setupTestNode({ isSyncServer: true });
+});
+
+describe("Group.addMember", () => {
+  test("an admin should be able to grant read access", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
+
+    expect(personOnReaderNode.get("name")).toEqual(undefined);
+
+    const readerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnAdminNode, "reader");
+
+    expect(group.roleOf(reader.accountID)).toEqual("reader");
+
+    await waitFor(() => {
+      expect(
+        expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
+      ).toEqual("John Doe");
+    });
+  });
+
+  test("an admin should be able to grant write access", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writer = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const personOnWriterNode = await loadCoValueOrFail(writer.node, person.id);
+
+    expect(personOnWriterNode.get("name")).toEqual(undefined);
+
+    const writerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writer.accountID,
+    );
+    group.addMember(writerOnAdminNode, "writer");
+    expect(group.roleOf(writer.accountID)).toEqual("writer");
+
+    await waitFor(() => {
+      expect(
+        expectMap(personOnWriterNode.core.getCurrentContent()).get("name"),
+      ).toEqual("John Doe");
+    });
+
+    personOnWriterNode.set("name", "Jane Doe");
+    expect(personOnWriterNode.get("name")).toEqual("Jane Doe");
+  });
+
+  test("an admin should be able to grant writeOnly access", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writeOnlyUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const writeOnlyUserOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writeOnlyUser.accountID,
+    );
+    group.addMember(writeOnlyUserOnAdminNode, "writeOnly");
+    expect(group.roleOf(writeOnlyUser.accountID)).toEqual("writeOnly");
+    const personOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnlyUser.node,
+      person.id,
+    );
+
+    // Should not be able to read
+    expect(personOnWriteOnlyNode.get("name")).toEqual(undefined);
+
+    // Should be able to write
+    personOnWriteOnlyNode.set("name", "Jane Doe");
+
+    expect(personOnWriteOnlyNode.get("name")).toEqual("Jane Doe");
+  });
+
+  test("an admin should be able to grant admin access", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherAdmin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const otherAdminOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherAdmin.accountID,
+    );
+    group.addMember(otherAdminOnAdminNode, "admin");
+
+    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
+
+    expect(personOnReaderNode.get("name")).toEqual(undefined);
+
+    const readerOnOtherAdminNode = await loadCoValueOrFail(
+      otherAdmin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnOtherAdminNode, "reader");
+
+    await waitFor(() => {
+      expect(
+        expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
+      ).toEqual("John Doe");
+    });
+  });
+
+  test("an admin should be able downgrade a writer to reader", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writer = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const writerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writer.accountID,
+    );
+    group.addMember(writerOnAdminNode, "writer");
+    group.addMember(writerOnAdminNode, "reader");
+
+    expect(group.roleOf(writer.accountID)).toEqual("reader");
+
+    // Verify writer can read and write
+    const personOnWriterNode = await loadCoValueOrFail(writer.node, person.id);
+
+    // Should not be able to write
+    personOnWriterNode.set("name", "Jane Doe");
+
+    expect(personOnWriterNode.get("name")).toEqual("John Doe");
+  });
+
+  test("an admin should be able downgrade a reader to writeOnly", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+
+    const readerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnAdminNode, "reader");
+    group.addMember(readerOnAdminNode, "writeOnly");
+
+    expect(group.roleOf(reader.accountID)).toEqual("writeOnly");
+
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    // Verify reader can read
+    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
+
+    expect(personOnReaderNode.get("name")).toEqual(undefined);
+  });
+
+  test("an admin should not be able downgrade an admin", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherAdmin = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const otherAdminOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherAdmin.accountID,
+    );
+    group.addMember(otherAdminOnAdminNode, "admin");
+
+    // Try to downgrade other admin
+    try {
+      group.addMember(otherAdminOnAdminNode, "writer");
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+
+    expect(group.roleOf(otherAdmin.accountID)).toEqual("admin");
+
+    // Verify other admin still has admin access by adding a new member
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const readerOnOtherAdminNode = await loadCoValueOrFail(
+      otherAdmin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnOtherAdminNode, "reader");
+
+    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
+
+    await waitFor(() => {
+      expect(
+        expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
+      ).toEqual("John Doe");
+    });
+  });
+
+  test("an admin should be able downgrade themselves", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+
+    const account = await loadCoValueOrFail(admin.node, admin.accountID);
+
+    // Downgrade self to writer
+    group.addMember(account, "writer");
+    expect(group.roleOf(admin.accountID)).toEqual("writer");
+  });
+
+  test("an admin should be able downgrade a writeOnly to reader", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writeOnlyUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const person = group.createMap({
+      name: "John Doe",
+    });
+
+    const writeOnlyUserOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writeOnlyUser.accountID,
+    );
+    group.addMember(writeOnlyUserOnAdminNode, "writeOnly");
+    group.addMember(writeOnlyUserOnAdminNode, "reader");
+
+    expect(group.roleOf(writeOnlyUser.accountID)).toEqual("reader");
+
+    const personOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnlyUser.node,
+      person.id,
+    );
+
+    expect(personOnWriteOnlyNode.get("name")).toEqual("John Doe");
+  });
+
+  test("a reader should not be able to add a member", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const newUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const readerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnAdminNode, "reader");
+
+    const newUserOnReaderNode = await loadCoValueOrFail(
+      reader.node,
+      newUser.accountID,
+    );
+
+    const groupOnReaderNode = await loadCoValueOrFail(reader.node, group.id);
+
+    // Try to add member as reader
+    try {
+      groupOnReaderNode.addMember(newUserOnReaderNode, "reader");
+      throw new Error("Should not be able to add member as reader");
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+
+    expect(groupOnReaderNode.roleOf(newUser.accountID)).toBeUndefined();
+  });
+
+  test("a writer should not be able to add a member", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writer = await setupTestAccount({
+      connected: true,
+    });
+
+    const newUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writer.accountID,
+    );
+    group.addMember(writerOnAdminNode, "writer");
+
+    const newUserOnWriterNode = await loadCoValueOrFail(
+      writer.node,
+      newUser.accountID,
+    );
+
+    const groupOnWriterNode = await loadCoValueOrFail(writer.node, group.id);
+
+    // Try to add member as writer
+    try {
+      groupOnWriterNode.addMember(newUserOnWriterNode, "reader");
+      throw new Error("Should not be able to add member as writer");
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+
+    expect(groupOnWriterNode.roleOf(newUser.accountID)).toBeUndefined();
+  });
+
+  test("a writeOnly should not be able to add a member", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writeOnlyUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const newUser = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writeOnlyUserOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writeOnlyUser.accountID,
+    );
+    group.addMember(writeOnlyUserOnAdminNode, "writeOnly");
+
+    const newUserOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnlyUser.node,
+      newUser.accountID,
+    );
+
+    const groupOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnlyUser.node,
+      group.id,
+    );
+
+    // Try to add member as writeOnly user
+    try {
+      groupOnWriteOnlyNode.addMember(newUserOnWriteOnlyNode, "reader");
+      throw new Error("Should not be able to add member as writeOnly user");
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+
+    expect(groupOnWriteOnlyNode.roleOf(newUser.accountID)).toBeUndefined();
+  });
+});

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

@@ -4,6 +4,7 @@ import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
   blockMessageTypeOnOutgoingPeer,
+  connectedPeersWithMessagesTracking,
   loadCoValueOrFail,
   setupTestNode,
   waitFor,
@@ -76,8 +77,8 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "core -> storage | CONTENT Group header: true new: After: 0 New: 3",
         "storage -> core | KNOWN Group sessions: header/3",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "storage -> core | KNOWN Map sessions: header/1",
         "client -> edge-italy | LOAD Map sessions: empty",
+        "storage -> core | KNOWN Map sessions: header/1",
         "edge-italy -> core | LOAD Map sessions: empty",
         "core -> edge-italy | CONTENT Group header: true new: After: 0 New: 3",
         "edge-italy -> core | KNOWN Group sessions: header/3",
@@ -138,8 +139,8 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> core | KNOWN Group sessions: header/5",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "storage -> core | KNOWN Map sessions: header/1",
         "client -> edge-italy | LOAD Map sessions: empty",
+        "storage -> core | KNOWN Map sessions: header/1",
         "edge-italy -> core | LOAD Map sessions: empty",
         "core -> edge-italy | CONTENT ParentGroup header: true new: After: 0 New: 6",
         "edge-italy -> core | KNOWN ParentGroup sessions: header/6",
@@ -355,6 +356,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       syncServer: storage.node,
     });
 
+    storagePeer.role = "storage";
     storagePeer.priority = 100;
 
     const group = coreServer.node.createGroup();
@@ -402,4 +404,60 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
 
     expect(mapOnClient.get("hello")).toEqual("world");
   });
+
+  test("a stuck server peer should not block the load from other server peers", async () => {
+    const client = setupTestNode();
+    const coreServer = setupTestNode({
+      isSyncServer: true,
+    });
+
+    const anotherServer = setupTestNode({});
+
+    const { peer: peerToCoreServer } = client.connectToSyncServer({
+      syncServerName: "core",
+      syncServer: coreServer.node,
+    });
+
+    const { peer1, peer2 } = connectedPeersWithMessagesTracking({
+      peer1: {
+        id: anotherServer.node.getCurrentAgent().id,
+        role: "server",
+        name: "another-server",
+      },
+      peer2: {
+        id: client.node.getCurrentAgent().id,
+        role: "client",
+        name: "client",
+      },
+    });
+
+    blockMessageTypeOnOutgoingPeer(peerToCoreServer, "load");
+
+    client.node.syncManager.addPeer(peer1);
+    anotherServer.node.syncManager.addPeer(peer2);
+
+    const group = anotherServer.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> another-server | LOAD Map sessions: empty",
+        "another-server -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> another-server | KNOWN Group sessions: header/3",
+        "another-server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> another-server | KNOWN Map sessions: header/1",
+      ]
+    `);
+
+    expect(mapOnClient.get("hello")).toEqual("world");
+  });
 });

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

@@ -1,7 +1,13 @@
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue";
 import { WasmCrypto } from "../crypto/WasmCrypto";
-import { SyncMessagesLog, setupTestNode, waitFor } from "./testUtils";
+import {
+  SyncMessagesLog,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
 
 let jazzCloud = setupTestNode({ isSyncServer: true });
 
@@ -146,7 +152,9 @@ describe("peer reconciliation", () => {
   });
 
   test("correctly handle server restarts in the middle of a sync", async () => {
-    const client = setupTestNode();
+    const client = setupTestNode({
+      connected: true,
+    });
 
     const group = client.node.createGroup();
     const map = group.createMap();
@@ -182,10 +190,90 @@ describe("peer reconciliation", () => {
         "server -> client | KNOWN Group sessions: empty",
         "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | LOAD Group sessions: empty",
         "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Group sessions: header/3",
         "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/2",
+        "server -> client | KNOWN Map sessions: header/2",
+      ]
+    `);
+  });
+
+  test("correctly handle server restarts in the middle of a sync (2 - account)", async () => {
+    const client = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    await map.core.waitForSync();
+
+    jazzCloud.restart();
+    SyncMessagesLog.clear();
+    client.connectToSyncServer();
+
+    map.set("hello", "updated", "trusting");
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    client.connectToSyncServer();
+
+    await waitFor(() => {
+      const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
+
+      expect(mapOnSyncServer.loadingState).toBe("available");
+    });
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: client.node.expectCurrentAccount("client account").core,
+        Profile: client.node.expectProfileLoaded(client.accountID).core,
+        ProfileGroup: client.node.expectProfileLoaded(client.accountID).group
+          .core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Account sessions: header/4",
+        "server -> client | KNOWN Account sessions: empty",
+        "client -> server | LOAD ProfileGroup sessions: header/5",
+        "server -> client | KNOWN ProfileGroup sessions: empty",
+        "client -> server | LOAD Profile sessions: header/1",
+        "server -> client | KNOWN Profile sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "server -> client | KNOWN Group sessions: empty",
+        "client -> server | LOAD Map sessions: header/2",
+        "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
         "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | LOAD Account sessions: empty",
+        "client -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "server -> client | LOAD Group sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Account sessions: header/4",
+        "server -> client | KNOWN Group sessions: header/3",
         "server -> client | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Account sessions: header/4",
+        "server -> client | KNOWN Account sessions: header/4",
+        "client -> server | LOAD ProfileGroup sessions: header/5",
+        "server -> client | KNOWN ProfileGroup sessions: empty",
+        "client -> server | LOAD Profile sessions: header/1",
+        "server -> client | KNOWN Profile sessions: empty",
         "client -> server | LOAD Group sessions: header/3",
         "server -> client | KNOWN Group sessions: header/3",
         "client -> server | LOAD Map sessions: header/2",

package/src/tests/testUtils.ts

@@ -8,12 +8,12 @@ import {
 import { expect, onTestFinished, vi } from "vitest";
 import { ControlledAccount, ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import type {
-  AgentSecret,
-  CoID,
-  CoValueCore,
-  RawAccount,
-  RawCoValue,
+import {
+  type AgentSecret,
+  type CoID,
+  type CoValueCore,
+  type RawAccount,
+  type RawCoValue,
 } from "../exports.js";
 import type { SessionID } from "../ids.js";
 import { LocalNode } from "../localNode.js";
@@ -463,6 +463,7 @@ export function createMockStoragePeer(opts: {
     },
   });
 
+  peer1.role = "storage";
   peer1.priority = 100;
 
   storage.syncManager.addPeer(peer2);