cojson 0.13.29 → 0.13.31

package/src/tests/coPlainText.test.ts

@@ -1,28 +1,12 @@
 import { afterEach, expect, test, vi } from "vitest";
 import { expectPlainText } from "../coValue.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { LocalNode } from "../localNode.js";
-import {
-  nodeWithRandomAgentAndSessionID,
-  randomAgentAndSessionID,
-} from "./testUtils.js";
+import { nodeWithRandomAgentAndSessionID } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
 afterEach(() => void vi.unstubAllGlobals());
 
-test("should throw on creation if Intl.Segmenter is not available", () => {
-  vi.stubGlobal("Intl", {
-    Segmenter: undefined,
-  });
-
-  const node = nodeWithRandomAgentAndSessionID();
-  const group = node.createGroup();
-  expect(() => group.createPlainText()).toThrow(
-    "Intl.Segmenter is not supported. Use a polyfill to get coPlainText support in Jazz. (eg. https://formatjs.github.io/docs/polyfills/intl-segmenter/)",
-  );
-});
-
 test("Empty CoPlainText works", () => {
   const node = nodeWithRandomAgentAndSessionID();
 
@@ -86,7 +70,7 @@ test("Can insert and delete in CoPlainText", () => {
   content.insertBefore(2, "😍", "trusting");
   expect(content.toString()).toEqual("He😍llo, world");
 
-  content.deleteRange({ from: 2, to: 4 }, "trusting");
+  content.deleteRange({ from: 2, to: 3 }, "trusting");
   expect(content.toString()).toEqual("Hello, world");
 });
 
@@ -204,3 +188,80 @@ test("insertBefore and insertAfter work as expected", () => {
   content.insertBefore(0, "!", "trusting"); // "!hey"
   expect(content.toString()).toEqual("!hey");
 });
+
+test("Can delete a single grapheme", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  content.insertAfter(0, "a̐éö̲", "trusting"); // 3 graphemes
+  content.deleteRange({ from: 1, to: 2 }, "trusting"); // delete the second grapheme
+  expect(content.toString()).toEqual("a̐ö̲");
+});
+
+test("Handles complex grapheme clusters correctly", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Combining marks (should be treated as one grapheme each)
+  const combining = "a̐éö̲"; // 3 graphemes: [a̐][é][ö̲]
+  content.insertAfter(0, combining, "trusting");
+  expect(content.toString()).toEqual(combining);
+  content.deleteRange({ from: 1, to: 2 }, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲");
+
+  // ZWJ emoji (family)
+  const family = "👨‍👩‍👧‍👦"; // 1 grapheme
+  content.insertAfter(2, family, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲👨‍👩‍👧‍👦");
+  content.deleteRange({ from: 2, to: 3 }, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲");
+
+  // Flag emoji (regional indicators)
+  const flag = "🇺🇸"; // 1 grapheme
+  content.insertAfter(2, flag, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲🇺🇸");
+  content.deleteRange({ from: 2, to: 3 }, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲");
+
+  // Emoji with skin tone modifier
+  const thumbsUp = "👍🏽"; // 1 grapheme
+  content.insertAfter(2, thumbsUp, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲👍🏽");
+  content.deleteRange({ from: 2, to: 3 }, "trusting");
+  expect(content.toString()).toEqual("a̐ö̲");
+});
+
+test("Handle deletion of complex grapheme clusters correctly", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Combining marks (should be treated as one grapheme each)
+  content.insertAfter(0, "👋 안녕!", "trusting");
+  expect(content.toString()).toEqual("👋 안녕!");
+
+  // Delete the first grapheme
+  content.deleteRange({ from: 0, to: 1 }, "trusting");
+  expect(content.toString()).toEqual(" 안녕!");
+
+  // Delete the second grapheme
+  content.deleteRange({ from: 1, to: 2 }, "trusting");
+  expect(content.toString()).toEqual(" 녕!");
+});

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

@@ -0,0 +1,418 @@
+import { describe, expect, test } from "vitest";
+import {
+  createThreeConnectedNodes,
+  createTwoConnectedNodes,
+  loadCoValueOrFail,
+} from "./testUtils";
+
+describe("extend", () => {
+  test("inherited writer roles should work correctly", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writer",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group);
+    childGroup.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writeOnly",
+    );
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from the admin");
+
+    await map.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    // The writer role should be able to see the edits from the admin
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin");
+  });
+
+  test("a user should be able to extend a group when his role on the parent group is writer", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writer",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+
+    const childGroup = node2.node.createGroup();
+    childGroup.extend(groupOnNode2);
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from node2");
+
+    await map.core.waitForSync();
+    await childGroup.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from node2");
+  });
+
+  test("a user should be able to extend a group when his role on the parent group is reader", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+
+    const childGroup = node2.node.createGroup();
+    childGroup.extend(groupOnNode2);
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from node2");
+
+    await map.core.waitForSync();
+    await childGroup.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from node2");
+  });
+
+  test("a user should be able to extend a group when his role on the parent group is writeOnly", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writeOnly",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+
+    const childGroup = node2.node.createGroup();
+    childGroup.extend(groupOnNode2);
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from node2");
+
+    await map.core.waitForSync();
+    await childGroup.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from node2");
+  });
+
+  test("self-extend a group should not break anything", async () => {
+    const { node1 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.extend(group);
+
+    const map = group.createMap();
+    map.set("test", "Hello!");
+
+    expect(map.get("test")).toEqual("Hello!");
+  });
+
+  test("should not break when introducing extend cycles", async () => {
+    const { node1 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    const group2 = node1.node.createGroup();
+    const group3 = node1.node.createGroup();
+
+    group.extend(group2);
+    group2.extend(group3);
+    group3.extend(group);
+
+    const map = group.createMap();
+    map.set("test", "Hello!");
+
+    expect(map.get("test")).toEqual("Hello!");
+  });
+
+  test("a writerInvite role should not be inherited", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writerInvite",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group);
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
+  });
+});
+
+describe("unextend", () => {
+  test("should revoke roles", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    // `parentGroup` has `alice` as a writer
+    const parentGroup = node1.node.createGroup();
+    const alice = await loadCoValueOrFail(node1.node, node2.accountID);
+    parentGroup.addMember(alice, "writer");
+    // `alice`'s role in `parentGroup` is `"writer"`
+    expect(parentGroup.roleOf(alice.id)).toBe("writer");
+
+    // `childGroup` has `bob` as a reader
+    const childGroup = node1.node.createGroup();
+    const bob = await loadCoValueOrFail(node1.node, node3.accountID);
+    childGroup.addMember(bob, "reader");
+    // `bob`'s role in `childGroup` is `"reader"`
+    expect(childGroup.roleOf(bob.id)).toBe("reader");
+
+    // `childGroup` has `parentGroup`'s members (in this case, `alice` as a writer)
+    childGroup.extend(parentGroup);
+    expect(childGroup.roleOf(alice.id)).toBe("writer");
+
+    // `childGroup` no longer has `parentGroup`'s members
+    await childGroup.revokeExtend(parentGroup);
+    expect(childGroup.roleOf(bob.id)).toBe("reader");
+    expect(childGroup.roleOf(alice.id)).toBe(undefined);
+  });
+
+  test("should do nothing if applied to a group that is not extended", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const parentGroup = node1.node.createGroup();
+    const alice = await loadCoValueOrFail(node1.node, node2.accountID);
+    parentGroup.addMember(alice, "writer");
+    const childGroup = node1.node.createGroup();
+    const bob = await loadCoValueOrFail(node1.node, node3.accountID);
+    childGroup.addMember(bob, "reader");
+    await childGroup.revokeExtend(parentGroup);
+    expect(childGroup.roleOf(bob.id)).toBe("reader");
+    expect(childGroup.roleOf(alice.id)).toBe(undefined);
+  });
+
+  test("should not throw if the revokeExtend is called twice", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const parentGroup = node1.node.createGroup();
+    const alice = await loadCoValueOrFail(node1.node, node2.accountID);
+    parentGroup.addMember(alice, "writer");
+    const childGroup = node1.node.createGroup();
+    const bob = await loadCoValueOrFail(node1.node, node3.accountID);
+    childGroup.addMember(bob, "reader");
+
+    childGroup.extend(parentGroup);
+
+    await childGroup.revokeExtend(parentGroup);
+    await childGroup.revokeExtend(parentGroup);
+    expect(childGroup.roleOf(bob.id)).toBe("reader");
+    expect(childGroup.roleOf(alice.id)).toBe(undefined);
+  });
+});
+
+describe("extend with role mapping", () => {
+  test("mapping to writer should add the ability to write", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "writer");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from the admin");
+
+    await map.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin");
+    mapOnNode2.set("test", "Written from the inherited role");
+    expect(mapOnNode2.get("test")).toEqual("Written from the inherited role");
+
+    await mapOnNode2.core.waitForSync();
+
+    expect(map.get("test")).toEqual("Written from the inherited role");
+  });
+
+  test("mapping to reader should remove the ability to write", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writer",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "reader");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual("reader");
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from the admin");
+
+    await map.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin");
+
+    mapOnNode2.set("test", "Should not be visible");
+
+    await mapOnNode2.core.waitForSync();
+
+    expect(map.get("test")).toEqual("Written from the admin");
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin");
+  });
+
+  test("mapping to admin should add the ability to add members", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "admin");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual("admin");
+
+    await childGroup.core.waitForSync();
+
+    const childGroupOnNode2 = await loadCoValueOrFail(
+      node2.node,
+      childGroup.id,
+    );
+
+    childGroupOnNode2.addMember(
+      await loadCoValueOrFail(node2.node, node3.accountID),
+      "reader",
+    );
+
+    expect(childGroupOnNode2.roleOf(node3.accountID)).toEqual("reader");
+  });
+
+  test("mapping to reader should remove the ability to add members", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "admin",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "reader");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual("reader");
+
+    await childGroup.core.waitForSync();
+
+    const childGroupOnNode2 = await loadCoValueOrFail(
+      node2.node,
+      childGroup.id,
+    );
+
+    const accountToAdd = await loadCoValueOrFail(node2.node, node3.accountID);
+
+    expect(() => {
+      childGroupOnNode2.addMember(accountToAdd, "reader");
+    }).toThrow();
+
+    expect(childGroupOnNode2.roleOf(node3.accountID)).toEqual(undefined);
+  });
+
+  test("non-inheritable roles should not give access to the child group when role mapping is used", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writeOnly",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "reader");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from the admin");
+
+    await map.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual(undefined);
+  });
+
+  test("invite roles should not give write access to the child group when role mapping is used", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writerInvite",
+    );
+
+    const childGroup = node1.node.createGroup();
+    childGroup.extend(group, "writer");
+
+    expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
+
+    const map = childGroup.createMap();
+    map.set("test", "Written from the admin");
+
+    await map.core.waitForSync();
+
+    const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
+
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin"); // The invite roles have access to the readKey hence can read the values on inherited groups
+
+    mapOnNode2.set("test", "Should not be visible");
+
+    await mapOnNode2.core.waitForSync();
+
+    expect(map.get("test")).toEqual("Written from the admin");
+    expect(mapOnNode2.get("test")).toEqual("Written from the admin");
+  });
+});