cojson 0.9.0 → 0.9.10

package/src/coValues/coList.ts

@@ -7,9 +7,9 @@ import { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";
 import { RawGroup } from "./group.js";
 
-type OpID = TransactionID & { changeIdx: number };
+export type OpID = TransactionID & { changeIdx: number };
 
-type InsertionOpPayload<T extends JsonValue> =
+export type InsertionOpPayload<T extends JsonValue> =
   | {
       op: "pre";
       value: T;
@@ -21,7 +21,7 @@ type InsertionOpPayload<T extends JsonValue> =
       after: OpID | "start";
     };
 
-type DeletionOpPayload = {
+export type DeletionOpPayload = {
   op: "del";
   insertion: OpID;
 };
@@ -49,7 +49,7 @@ export class RawCoListView<
   /** @category 6. Meta */
   id: CoID<this>;
   /** @category 6. Meta */
-  type = "colist" as const;
+  type: "colist" | "coplaintext" = "colist" as const;
   /** @category 6. Meta */
   core: CoValueCore;
   /** @internal */
@@ -457,13 +457,7 @@ export class RawCoList<
 
     this.core.makeTransaction(changes, privacy);
 
-    const listAfter = new RawCoList(this.core) as this;
-
-    this.afterStart = listAfter.afterStart;
-    this.beforeEnd = listAfter.beforeEnd;
-    this.insertions = listAfter.insertions;
-    this.deletionsByInsertion = listAfter.deletionsByInsertion;
-    this._cachedEntries = undefined;
+    this.rebuildFromCore();
   }
 
   /**
@@ -510,13 +504,7 @@ export class RawCoList<
       privacy,
     );
 
-    const listAfter = new RawCoList(this.core) as this;
-
-    this.afterStart = listAfter.afterStart;
-    this.beforeEnd = listAfter.beforeEnd;
-    this.insertions = listAfter.insertions;
-    this.deletionsByInsertion = listAfter.deletionsByInsertion;
-    this._cachedEntries = undefined;
+    this.rebuildFromCore();
   }
 
   /** Deletes the item at index `at`.
@@ -543,13 +531,7 @@ export class RawCoList<
       privacy,
     );
 
-    const listAfter = new RawCoList(this.core) as this;
-
-    this.afterStart = listAfter.afterStart;
-    this.beforeEnd = listAfter.beforeEnd;
-    this.insertions = listAfter.insertions;
-    this.deletionsByInsertion = listAfter.deletionsByInsertion;
-    this._cachedEntries = undefined;
+    this.rebuildFromCore();
   }
 
   replace(
@@ -577,6 +559,11 @@ export class RawCoList<
       ],
       privacy,
     );
+    this.rebuildFromCore();
+  }
+
+  /** @internal */
+  rebuildFromCore() {
     const listAfter = new RawCoList(this.core) as this;
 
     this.afterStart = listAfter.afterStart;

package/src/coValues/coPlainText.ts

@@ -0,0 +1,128 @@
+import { CoValueCore } from "../coValueCore.js";
+import { JsonObject } from "../jsonValue.js";
+import { DeletionOpPayload, OpID, RawCoList } from "./coList.js";
+
+export type StringifiedOpID = string & { __stringifiedOpID: true };
+
+export function stringifyOpID(opID: OpID): StringifiedOpID {
+  return `${opID.sessionID}:${opID.txIndex}:${opID.changeIdx}` as StringifiedOpID;
+}
+
+type PlaintextIdxMapping = {
+  opIDbeforeIdx: OpID[];
+  opIDafterIdx: OpID[];
+  idxAfterOpID: { [opID: StringifiedOpID]: number };
+  idxBeforeOpID: { [opID: StringifiedOpID]: number };
+};
+
+export class RawCoPlainText<
+  Meta extends JsonObject | null = JsonObject | null,
+> extends RawCoList<string, Meta> {
+  /** @category 6. Meta */
+  type = "coplaintext" as const;
+
+  private _segmenter: Intl.Segmenter;
+
+  _cachedMapping: WeakMap<
+    NonNullable<typeof this._cachedEntries>,
+    PlaintextIdxMapping
+  >;
+
+  constructor(core: CoValueCore) {
+    super(core);
+    this._cachedMapping = new WeakMap();
+    if (!Intl.Segmenter) {
+      throw new Error(
+        "Intl.Segmenter is not supported. Use a polyfill to get coPlainText support in Jazz. (eg. https://formatjs.github.io/docs/polyfills/intl-segmenter/)",
+      );
+    }
+    this._segmenter = new Intl.Segmenter("en", {
+      granularity: "grapheme",
+    });
+  }
+
+  get mapping() {
+    const entries = this.entries();
+    let mapping = this._cachedMapping.get(entries);
+    if (mapping) {
+      return mapping;
+    }
+
+    mapping = {
+      opIDbeforeIdx: [],
+      opIDafterIdx: [],
+      idxAfterOpID: {},
+      idxBeforeOpID: {},
+    };
+
+    let idxBefore = 0;
+
+    for (const entry of entries) {
+      const idxAfter = idxBefore + entry.value.length;
+
+      mapping.opIDafterIdx[idxBefore] = entry.opID;
+      mapping.opIDbeforeIdx[idxAfter] = entry.opID;
+      mapping.idxAfterOpID[stringifyOpID(entry.opID)] = idxAfter;
+      mapping.idxBeforeOpID[stringifyOpID(entry.opID)] = idxBefore;
+
+      idxBefore = idxAfter;
+    }
+
+    this._cachedMapping.set(entries, mapping);
+    return mapping;
+  }
+
+  toString() {
+    return this.entries()
+      .map((entry) => entry.value)
+      .join("");
+  }
+
+  insertAfter(
+    idx: number,
+    text: string,
+    privacy: "private" | "trusting" = "private",
+  ) {
+    const graphemes = [...this._segmenter.segment(text)].map((g) => g.segment);
+
+    if (idx === 0) {
+      // For insertions at start, just prepend each character, in reverse
+      for (const grapheme of graphemes.reverse()) {
+        this.prepend(grapheme, 0, privacy);
+      }
+    } else {
+      // For other insertions, use append after the specified index
+      // We append in forward order to maintain the text order
+      let after = idx - 1;
+      for (const grapheme of graphemes) {
+        this.append(grapheme, after, privacy);
+        after++; // Move the insertion point forward for each grapheme
+      }
+    }
+  }
+
+  deleteRange(
+    { from, to }: { from: number; to: number },
+    privacy: "private" | "trusting" = "private",
+  ) {
+    const ops: DeletionOpPayload[] = [];
+    for (let idx = from; idx < to; ) {
+      const insertion = this.mapping.opIDafterIdx[idx];
+      if (!insertion) {
+        throw new Error("Invalid idx to delete " + idx);
+      }
+      ops.push({
+        op: "del",
+        insertion,
+      });
+      let nextIdx = idx + 1;
+      while (!this.mapping.opIDbeforeIdx[nextIdx] && nextIdx < to) {
+        nextIdx++;
+      }
+      idx = nextIdx;
+    }
+    this.core.makeTransaction(ops, privacy);
+
+    this.rebuildFromCore();
+  }
+}

package/src/coValues/group.ts

@@ -22,6 +22,7 @@ import {
 } from "./account.js";
 import { RawCoList } from "./coList.js";
 import { RawCoMap } from "./coMap.js";
+import { RawCoPlainText } from "./coPlainText.js";
 import { RawBinaryCoStream, RawCoStream } from "./coStream.js";
 
 export const EVERYONE = "everyone" as const;
@@ -699,6 +700,36 @@ export class RawGroup<
     return list;
   }
 
+  /**
+   * Creates a new `CoPlainText` within this group, with the specified specialized
+   * `CoPlainText` type `T` and optional static metadata.
+   *
+   * @category 3. Value creation
+   */
+  createPlainText<T extends RawCoPlainText>(
+    init?: string,
+    meta?: T["headerMeta"],
+    initPrivacy: "trusting" | "private" = "private",
+  ): T {
+    const text = this.core.node
+      .createCoValue({
+        type: "coplaintext",
+        ruleset: {
+          type: "ownedByGroup",
+          group: this.id,
+        },
+        meta: meta || null,
+        ...this.core.crypto.createdNowUnique(),
+      })
+      .getCurrentContent() as T;
+
+    if (init) {
+      text.insertAfter(0, init, initPrivacy);
+    }
+
+    return text;
+  }
+
   /** @category 3. Value creation */
   createStream<C extends RawCoStream>(
     meta?: C["headerMeta"],

package/src/coreToCoValue.ts

@@ -1,9 +1,10 @@
+import { RawUnknownCoValue } from "./coValue.js";
 import type { CoValueCore } from "./coValueCore.js";
 import { RawAccount, RawControlledAccount } from "./coValues/account.js";
 import { RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
-import { RawCoStream } from "./coValues/coStream.js";
-import { RawBinaryCoStream } from "./coValues/coStream.js";
+import { RawCoPlainText } from "./coValues/coPlainText.js";
+import { RawBinaryCoStream, RawCoStream } from "./coValues/coStream.js";
 import { RawGroup } from "./coValues/group.js";
 
 export function coreToCoValue(
@@ -27,6 +28,8 @@ export function coreToCoValue(
     } else {
       return new RawCoMap(core);
     }
+  } else if (core.header.type === "coplaintext") {
+    return new RawCoPlainText(core);
   } else if (core.header.type === "colist") {
     return new RawCoList(core);
   } else if (core.header.type === "costream") {
@@ -36,6 +39,6 @@ export function coreToCoValue(
       return new RawCoStream(core);
     }
   } else {
-    throw new Error(`Unknown coValue type ${core.header.type}`);
+    return new RawUnknownCoValue(core);
   }
 }

package/src/exports.ts

@@ -6,14 +6,16 @@ import {
   MAX_RECOMMENDED_TX_SIZE,
   idforHeader,
 } from "./coValueCore.js";
-import { ControlledAgent, RawControlledAccount } from "./coValues/account.js";
 import {
+  ControlledAgent,
   RawAccount,
+  RawControlledAccount,
   RawProfile,
   accountHeaderForInitialAgentSecret,
 } from "./coValues/account.js";
-import { RawCoList } from "./coValues/coList.js";
+import { OpID, RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoPlainText, stringifyOpID } from "./coValues/coPlainText.js";
 import {
   CoStreamItem,
   RawBinaryCoStream,
@@ -137,6 +139,8 @@ export {
   isRawCoID,
   LSMStorage,
   emptyKnownState,
+  RawCoPlainText,
+  stringifyOpID,
 };
 
 export type {
@@ -151,6 +155,7 @@ export type {
   CoValueUniqueness,
   Stringified,
   CoStreamItem,
+  OpID,
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace

package/src/tests/coList.test.ts

@@ -132,3 +132,22 @@ test("init the list correctly", () => {
     "hello",
   ]);
 });
+
+test("Items prepended to start appear with latest first", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectList(coValue.getCurrentContent());
+
+  content.prepend("first", 0, "trusting");
+  content.prepend("second", 0, "trusting");
+  content.prepend("third", 0, "trusting");
+
+  expect(content.toJSON()).toEqual(["third", "second", "first"]);
+});

package/src/tests/coPlainText.test.ts

@@ -0,0 +1,133 @@
+import { afterEach, expect, test, vi } from "vitest";
+import { expectPlainText } from "../coValue.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } 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 = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  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 = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+  expect(content.toString()).toEqual("");
+});
+
+test("Can insert into empty CoPlainText", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+
+  content.insertAfter(0, "a", "trusting");
+  expect(content.toString()).toEqual("a");
+});
+
+test("Can insert and delete in CoPlainText", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+
+  content.insertAfter(0, "hello", "trusting");
+  expect(content.toString()).toEqual("hello");
+
+  content.insertAfter(5, " world", "trusting");
+  expect(content.toString()).toEqual("hello world");
+
+  content.insertAfter(0, "Hello, ", "trusting");
+  expect(content.toString()).toEqual("Hello, hello world");
+
+  console.log("first delete");
+  content.deleteRange({ from: 6, to: 12 }, "trusting");
+  expect(content.toString()).toEqual("Hello, world");
+
+  content.insertAfter(2, "😍", "trusting");
+  expect(content.toString()).toEqual("He😍llo, world");
+
+  console.log("second delete");
+  content.deleteRange({ from: 2, to: 4 }, "trusting");
+  expect(content.toString()).toEqual("Hello, world");
+});
+
+test("Multiple items appended after start appear in correct order", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Add multiple items in a single transaction, all after start
+  content.insertAfter(0, "h", "trusting");
+  content.insertAfter(1, "e", "trusting");
+  content.insertAfter(2, "y", "trusting");
+
+  // They should appear in insertion order (hey), not reversed (yeh)
+  expect(content.toString()).toEqual("hey");
+});
+
+test("Items inserted at start appear with latest first", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Insert multiple items at the start
+  content.insertAfter(0, "first", "trusting");
+  content.insertAfter(0, "second", "trusting");
+  content.insertAfter(0, "third", "trusting");
+
+  // They should appear in reverse chronological order
+  // because newer items should appear before older items
+  expect(content.toString()).toEqual("thirdsecondfirst");
+});

package/src/tests/coValueCore.test.ts

@@ -1,11 +1,14 @@
 import { expect, test, vi } from "vitest";
-import { Transaction } from "../coValueCore.js";
+import { CoValueCore, Transaction } from "../coValueCore.js";
 import { MapOpPayload } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
 import { Role } from "../permissions.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  createTestNode,
+  randomAnonymousAccountAndSessionID,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -191,3 +194,30 @@ test("New transactions in a group correctly update owned values, including subsc
 
   expect(map.core.getValidSortedTransactions().length).toBe(0);
 });
+
+test("creating a coValue with a group should't trigger automatically a content creation (performance)", () => {
+  const node = createTestNode();
+
+  const group = node.createGroup();
+
+  const getCurrentContentSpy = vi.spyOn(
+    CoValueCore.prototype,
+    "getCurrentContent",
+  );
+  const groupSpy = vi.spyOn(group.core, "getCurrentContent");
+
+  getCurrentContentSpy.mockClear();
+
+  node.createCoValue({
+    type: "comap",
+    ruleset: { type: "ownedByGroup", group: group.id },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  // It's called once for the group and never for the coValue
+  expect(getCurrentContentSpy).toHaveBeenCalledTimes(1);
+  expect(groupSpy).toHaveBeenCalledTimes(1);
+
+  getCurrentContentSpy.mockRestore();
+});

package/src/tests/sync.test.ts

@@ -12,8 +12,10 @@ import { connectedPeers, newQueuePair } from "../streamUtils.js";
 import type { SyncMessage } from "../sync.js";
 import {
   blockMessageTypeOnOutgoingPeer,
+  connectTwoPeers,
   createTestMetricReader,
   createTestNode,
+  loadCoValueOrFail,
   randomAnonymousAccountAndSessionID,
   tearDownTestMetricReader,
   waitFor,
@@ -1645,6 +1647,28 @@ function createTwoConnectedNodes() {
   };
 }
 
+test("a value created on one node can be loaded on anotehr node even if not directly connected", async () => {
+  const userA = createTestNode();
+  const userB = createTestNode();
+  const serverA = createTestNode();
+  const serverB = createTestNode();
+  const core = createTestNode();
+
+  connectTwoPeers(userA, serverA, "client", "server");
+  connectTwoPeers(userB, serverB, "client", "server");
+  connectTwoPeers(serverA, core, "client", "server");
+  connectTwoPeers(serverB, core, "client", "server");
+
+  const group = userA.createGroup();
+  const map = group.createMap();
+  map.set("key1", "value1", "trusting");
+
+  await map.core.waitForSync();
+
+  const mapOnUserB = await loadCoValueOrFail(userB, map.id);
+  expect(mapOnUserB.get("key1")).toBe("value1");
+});
+
 describe("SyncManager - knownStates vs optimisticKnownStates", () => {
   test("knownStates and optimisticKnownStates are the same when the coValue is fully synced", async () => {
     const { client, jazzCloud } = createTwoConnectedNodes();
@@ -1961,6 +1985,25 @@ describe("waitForSyncWithPeer", () => {
   });
 });
 
+test("Should not crash when syncing an unknown coValue type", async () => {
+  const { client, jazzCloud } = createTwoConnectedNodes();
+
+  const coValue = client.createCoValue({
+    type: "ooops" as any,
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  await coValue.waitForSync();
+
+  const coValueOnTheOtherNode = await loadCoValueOrFail(
+    jazzCloud,
+    coValue.getCurrentContent().id,
+  );
+  expect(coValueOnTheOtherNode.id).toBe(coValue.id);
+});
+
 describe("metrics", () => {
   afterEach(() => {
     tearDownTestMetricReader();

package/src/tests/testUtils.ts

@@ -33,6 +33,25 @@ export function createTestNode() {
   return new LocalNode(admin, session, Crypto);
 }
 
+export function connectTwoPeers(
+  a: LocalNode,
+  b: LocalNode,
+  aRole: "client" | "server",
+  bRole: "client" | "server",
+) {
+  const [aAsPeer, bAsPeer] = connectedPeers(
+    "peer:" + a.account.id,
+    "peer:" + b.account.id,
+    {
+      peer1role: aRole,
+      peer2role: bRole,
+    },
+  );
+
+  a.syncManager.addPeer(bAsPeer);
+  b.syncManager.addPeer(aAsPeer);
+}
+
 export async function createTwoConnectedNodes(
   node1Role: Peer["role"],
   node2Role: Peer["role"],