cojson 0.13.10 → 0.13.12

package/src/sync.ts

@@ -163,7 +163,7 @@ export class SyncManager {
   }
 
   async handleSyncMessage(msg: SyncMessage, peer: PeerState) {
-    if (peer.erroredCoValues.has(msg.id)) {
+    if (this.local.coValuesStore.get(msg.id).isErroredInPeer(peer.id)) {
       logger.warn(
         `Skipping message ${msg.action} on errored coValue ${msg.id} from peer ${peer.id}`,
       );
@@ -223,11 +223,7 @@ export class SyncManager {
       }
 
       peer.toldKnownState.add(id);
-      peer.optimisticKnownStates.dispatch({
-        type: "COMBINE_WITH",
-        id: id,
-        value: coValue.knownState(),
-      });
+      peer.combineOptimisticWith(id, coValue.knownState());
     } else if (!peer.toldKnownState.has(id)) {
       this.trySendToPeer(peer, {
         action: "known",
@@ -255,8 +251,8 @@ export class SyncManager {
       for (const id of coValue.getDependedOnCoValues()) {
         const entry = this.local.coValuesStore.get(id);
 
-        if (entry.state.type === "available") {
-          buildOrderedCoValueList(entry.state.coValue);
+        if (entry.isAvailable()) {
+          buildOrderedCoValueList(entry.core);
         }
       }
 
@@ -264,31 +260,25 @@ export class SyncManager {
     };
 
     for (const entry of this.local.coValuesStore.getValues()) {
-      switch (entry.state.type) {
-        case "unavailable":
-          // If the coValue is unavailable and we never tried this peer
-          // we try to load it from the peer
-          if (!peer.toldKnownState.has(entry.id)) {
-            await entry.loadFromPeers([peer]).catch((e: unknown) => {
-              logger.error("Error sending load", { err: e });
-            });
-          }
-          break;
-        case "available":
-          const coValue = entry.state.coValue;
-
-          // Build the list of coValues ordered by dependency
-          // so we can send the load message in the correct order
-          buildOrderedCoValueList(coValue);
-          break;
+      if (!entry.isAvailable()) {
+        // If the coValue is unavailable and we never tried this peer
+        // we try to load it from the peer
+        if (!peer.toldKnownState.has(entry.id)) {
+          await entry.loadFromPeers([peer]).catch((e: unknown) => {
+            logger.error("Error sending load", { err: e });
+          });
+        }
+      } else {
+        const coValue = entry.core;
+
+        // Build the list of coValues ordered by dependency
+        // so we can send the load message in the correct order
+        buildOrderedCoValueList(coValue);
       }
 
       // Fill the missing known states with empty known states
       if (!peer.optimisticKnownStates.has(entry.id)) {
-        peer.optimisticKnownStates.dispatch({
-          type: "SET_AS_EMPTY",
-          id: entry.id,
-        });
+        peer.setOptimisticKnownState(entry.id, "empty");
       }
     }
 
@@ -403,14 +393,13 @@ export class SyncManager {
      * This way we can track part of the data loss that may occur when the other peer is restarted
      *
      */
-    peer.dispatchToKnownStates({
-      type: "SET",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.setKnownState(msg.id, knownStateIn(msg));
     const entry = this.local.coValuesStore.get(msg.id);
 
-    if (entry.state.type === "unknown" || entry.state.type === "unavailable") {
+    if (
+      entry.highLevelState === "unknown" ||
+      entry.highLevelState === "unavailable"
+    ) {
       const eligiblePeers = this.getServerAndStoragePeers(peer.id);
 
       if (eligiblePeers.length === 0) {
@@ -437,7 +426,7 @@ export class SyncManager {
       }
     }
 
-    if (entry.state.type === "loading") {
+    if (entry.highLevelState === "loading") {
       // 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
@@ -467,7 +456,7 @@ export class SyncManager {
             err: e,
           });
         });
-    } else if (entry.state.type === "available") {
+    } else if (entry.isAvailable()) {
       await this.sendNewContentIncludingDependencies(msg.id, peer);
     } else {
       this.trySendToPeer(peer, {
@@ -482,28 +471,17 @@ export class SyncManager {
   async handleKnownState(msg: KnownStateMessage, peer: PeerState) {
     const entry = this.local.coValuesStore.get(msg.id);
 
-    peer.dispatchToKnownStates({
-      type: "COMBINE_WITH",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.combineWith(msg.id, knownStateIn(msg));
 
     // The header is a boolean value that tells us if the other peer do have information about the header.
     // If it's false in this point it means that the coValue is unavailable on the other peer.
-    if (entry.state.type !== "available") {
-      const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
-
-      if (!availableOnPeer) {
-        entry.dispatch({
-          type: "not-found-in-peer",
-          peerId: peer.id,
-        });
-      }
+    const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
 
-      return;
+    if (!availableOnPeer) {
+      entry.markNotFoundInPeer(peer.id);
     }
 
-    if (entry.state.type === "available") {
+    if (entry.isAvailable()) {
       await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
   }
@@ -526,23 +504,7 @@ export class SyncManager {
 
     let coValue: CoValueCore;
 
-    /**
-     * The new content might come while the coValue is loading or is not loaded yet.
-     *
-     * This might happen when we restart the server because:
-     * - The client known state assumes that the coValue is available on the server
-     * - The server might not have loaded the coValue yet because it was not requested
-     *
-     * In this case we need to load the coValue from the storage or other peers.
-     *
-     * If this load fails we send a correction request, because the client has the wrong assumption that
-     * we have the coValue while we don't.
-     */
-    if (entry.state.type !== "available" && !msg.header) {
-      await this.local.loadCoValueCore(msg.id, peer.id);
-    }
-
-    if (entry.state.type !== "available") {
+    if (!entry.isAvailable()) {
       if (!msg.header) {
         this.trySendToPeer(peer, {
           action: "known",
@@ -560,20 +522,13 @@ export class SyncManager {
         return;
       }
 
-      peer.dispatchToKnownStates({
-        type: "UPDATE_HEADER",
-        id: msg.id,
-        header: true,
-      });
+      peer.updateHeader(msg.id, true);
 
       coValue = new CoValueCore(msg.header, this.local);
 
-      entry.dispatch({
-        type: "available",
-        coValue,
-      });
+      entry.markAvailable(coValue, peer.id);
     } else {
-      coValue = entry.state.coValue;
+      coValue = entry.core;
     }
 
     let invalidStateAssumed = false;
@@ -616,20 +571,18 @@ export class SyncManager {
           id: msg.id,
           err: result.error,
         });
-        peer.erroredCoValues.set(msg.id, result.error);
+        entry.markErrored(peer.id, result.error);
         continue;
       }
 
       this.recordTransactionsSize(newTransactions, peer.role);
 
-      peer.dispatchToKnownStates({
-        type: "UPDATE_SESSION_COUNTER",
-        id: msg.id,
-        sessionId: sessionID,
-        value:
-          newContentForSession.after +
+      peer.updateSessionCounter(
+        msg.id,
+        sessionID,
+        newContentForSession.after +
           newContentForSession.newTransactions.length,
-      });
+      );
     }
 
     if (invalidStateAssumed) {
@@ -675,11 +628,7 @@ export class SyncManager {
   }
 
   async handleCorrection(msg: KnownStateMessage, peer: PeerState) {
-    peer.dispatchToKnownStates({
-      type: "SET",
-      id: msg.id,
-      value: knownStateIn(msg),
-    });
+    peer.setKnownState(msg.id, knownStateIn(msg));
 
     return this.sendNewContentIncludingDependencies(msg.id, peer);
   }
@@ -712,7 +661,8 @@ export class SyncManager {
   async actuallySyncCoValue(coValue: CoValueCore) {
     for (const peer of this.peersInPriorityOrder()) {
       if (peer.closed) continue;
-      if (peer.erroredCoValues.has(coValue.id)) continue;
+      if (this.local.coValuesStore.get(coValue.id).isErroredInPeer(peer.id))
+        continue;
 
       if (peer.optimisticKnownStates.has(coValue.id)) {
         await this.sendNewContentIncludingDependencies(coValue.id, peer);
@@ -767,7 +717,8 @@ export class SyncManager {
     const coValues = this.local.coValuesStore.getValues();
     const validCoValues = Array.from(coValues).filter(
       (coValue) =>
-        coValue.state.type === "available" || coValue.state.type === "loading",
+        coValue.highLevelState === "available" ||
+        coValue.highLevelState === "loading",
     );
 
     return Promise.all(

package/src/tests/PeerKnownStates.test.ts

@@ -9,7 +9,7 @@ describe("PeerKnownStates", () => {
     const id = "test-id" as RawCoID;
     const knownState: CoValueKnownState = emptyKnownState(id);
 
-    peerKnownStates.dispatch({ type: "SET", id, value: knownState });
+    peerKnownStates.set(id, knownState);
 
     expect(peerKnownStates.get(id)).toEqual(knownState);
     expect(peerKnownStates.has(id)).toBe(true);
@@ -19,7 +19,7 @@ describe("PeerKnownStates", () => {
     const peerKnownStates = new PeerKnownStates();
     const id = "test-id" as RawCoID;
 
-    peerKnownStates.dispatch({ type: "UPDATE_HEADER", id, header: true });
+    peerKnownStates.updateHeader(id, true);
 
     const result = peerKnownStates.get(id);
     expect(result?.header).toBe(true);
@@ -30,12 +30,7 @@ describe("PeerKnownStates", () => {
     const id = "test-id" as RawCoID;
     const sessionId = "session-1" as SessionID;
 
-    peerKnownStates.dispatch({
-      type: "UPDATE_SESSION_COUNTER",
-      id,
-      sessionId,
-      value: 5,
-    });
+    peerKnownStates.updateSessionCounter(id, sessionId, 5);
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions[sessionId]).toBe(5);
@@ -55,8 +50,8 @@ describe("PeerKnownStates", () => {
       sessions: { [session2]: 10 },
     };
 
-    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
-    peerKnownStates.dispatch({ type: "COMBINE_WITH", id, value: combineState });
+    peerKnownStates.set(id, initialState);
+    peerKnownStates.combineWith(id, combineState);
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions).toEqual({ [session1]: 5, [session2]: 10 });
@@ -71,8 +66,8 @@ describe("PeerKnownStates", () => {
       sessions: { [sessionId]: 5 },
     };
 
-    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, initialState);
+    peerKnownStates.set(id, "empty");
 
     const result = peerKnownStates.get(id);
     expect(result).toEqual(emptyKnownState(id));
@@ -84,7 +79,7 @@ describe("PeerKnownStates", () => {
     const listener = vi.fn();
 
     peerKnownStates.subscribe(listener);
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, "empty");
 
     expect(listener).toHaveBeenCalledWith(id, emptyKnownState(id));
   });
@@ -97,7 +92,7 @@ describe("PeerKnownStates", () => {
     const unsubscribe = peerKnownStates.subscribe(listener);
     unsubscribe();
 
-    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
+    peerKnownStates.set(id, "empty");
 
     expect(listener).not.toHaveBeenCalled();
   });

package/src/tests/PeerState.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
-import { PeerKnownStateActions } from "../PeerKnownStates.js";
 import { PeerState } from "../PeerState.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
-import { Peer, SyncMessage } from "../sync.js";
+import { CoValueKnownState, Peer, SyncMessage } from "../sync.js";
 
 function setup() {
   const mockPeer: Peer = {
@@ -146,16 +145,11 @@ describe("PeerState", () => {
 
   test("should clone the knownStates into optimisticKnownStates and knownStates when passed as argument", () => {
     const { peerState, mockPeer } = setup();
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    peerState.setKnownState("co_z1", {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
-    };
-    peerState.dispatchToKnownStates(action);
+      header: false,
+      sessions: {},
+    });
 
     const newPeerState = new PeerState(mockPeer, peerState.knownStates);
 
@@ -165,25 +159,26 @@ describe("PeerState", () => {
 
   test("should dispatch to both states", () => {
     const { peerState } = setup();
-    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
+    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
+    if (peerState._optimisticKnownStates === "assumeInfallible") {
+      throw new Error("Expected normal optimisticKnownStates");
+    }
+
     const optimisticKnownStatesSpy = vi.spyOn(
-      peerState.optimisticKnownStates,
-      "dispatch",
+      peerState._optimisticKnownStates,
+      "set",
     );
 
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    const state: CoValueKnownState = {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
+      header: false,
+      sessions: {},
     };
-    peerState.dispatchToKnownStates(action);
 
-    expect(knownStatesSpy).toHaveBeenCalledWith(action);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+    peerState.setKnownState("co_z1", state);
+
+    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith("co_z1", state);
   });
 
   test("should use same reference for knownStates and optimisticKnownStates for storage peers", () => {
@@ -204,28 +199,20 @@ describe("PeerState", () => {
     expect(peerState.knownStates).toBe(peerState.optimisticKnownStates);
 
     // Verify that dispatching only updates one state
-    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
-    const optimisticKnownStatesSpy = vi.spyOn(
-      peerState.optimisticKnownStates,
-      "dispatch",
-    );
+    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
+    expect(peerState._optimisticKnownStates).toBe("assumeInfallible");
 
-    const action: PeerKnownStateActions = {
-      type: "SET",
+    const state: CoValueKnownState = {
       id: "co_z1",
-      value: {
-        id: "co_z1",
-        header: false,
-        sessions: {},
-      },
+      header: false,
+      sessions: {},
     };
-    peerState.dispatchToKnownStates(action);
+
+    peerState.setKnownState("co_z1", state);
 
     // Only one dispatch should happen since they're the same reference
     expect(knownStatesSpy).toHaveBeenCalledTimes(1);
-    expect(knownStatesSpy).toHaveBeenCalledWith(action);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledTimes(1);
-    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
   });
 
   test("should use separate references for knownStates and optimisticKnownStates for non-storage peers", () => {

package/src/tests/coList.test.ts

@@ -95,6 +95,76 @@ test("appendItems add an array of items at the end of the list", () => {
   expect(content.toJSON()).toEqual(["hello", "world", "hooray", "universe"]);
 });
 
+test("appendItems at index", () => {
+  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.append("first", 0, "trusting");
+  content.append("second", 0, "trusting");
+  expect(content.toJSON()).toEqual(["first", "second"]);
+
+  content.appendItems(["third", "fourth"], 1, "trusting");
+  expect(content.toJSON()).toEqual(["first", "second", "third", "fourth"]);
+
+  content.appendItems(["hello", "world"], 0, "trusting");
+  expect(content.toJSON()).toEqual([
+    "first",
+    "hello",
+    "world",
+    "second",
+    "third",
+    "fourth",
+  ]);
+});
+
+test("appendItems at index", () => {
+  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.append("first", 0, "trusting");
+  expect(content.toJSON()).toEqual(["first"]);
+
+  content.appendItems(["second"], 0, "trusting");
+  expect(content.toJSON()).toEqual(["first", "second"]);
+
+  content.appendItems(["third"], 1, "trusting");
+  expect(content.toJSON()).toEqual(["first", "second", "third"]);
+});
+
+test("appendItems with negative index", () => {
+  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.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.appendItems(["world", "hooray", "universe"], -1, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world", "hooray", "universe"]);
+});
+
 test("Can push into empty list", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
@@ -151,3 +221,16 @@ test("Items prepended to start appear with latest first", () => {
 
   expect(content.toJSON()).toEqual(["third", "second", "first"]);
 });
+
+test("should handle large lists", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const group = node.createGroup();
+  const coValue = group.createList();
+
+  for (let i = 0; i < 8_000; i++) {
+    coValue.append(`item ${i}`, undefined, "trusting");
+  }
+
+  expect(coValue.toJSON().length).toEqual(8_000);
+});

package/src/tests/coPlainText.test.ts

@@ -71,25 +71,23 @@ test("Can insert and delete in CoPlainText", () => {
   content.insertAfter(0, "hello", "trusting");
   expect(content.toString()).toEqual("hello");
 
-  content.insertAfter(5, " world", "trusting");
+  content.insertAfter(4, " world", "trusting");
   expect(content.toString()).toEqual("hello world");
 
-  content.insertAfter(0, "Hello, ", "trusting");
+  content.insertBefore(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");
+  content.insertBefore(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", () => {
+test("Multiple items inserted appear in correct order", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
   const coValue = node.createCoValue({
@@ -101,10 +99,10 @@ test("Multiple items appended after start appear in correct order", () => {
 
   const content = expectPlainText(coValue.getCurrentContent());
 
-  // Add multiple items in a single transaction, all after start
+  // Add multiple items in sequence
   content.insertAfter(0, "h", "trusting");
-  content.insertAfter(1, "e", "trusting");
-  content.insertAfter(2, "y", "trusting");
+  content.insertAfter(0, "e", "trusting");
+  content.insertAfter(1, "y", "trusting");
 
   // They should appear in insertion order (hey), not reversed (yeh)
   expect(content.toString()).toEqual("hey");
@@ -124,10 +122,82 @@ test("Items inserted at start appear with latest first", () => {
 
   // Insert multiple items at the start
   content.insertAfter(0, "first", "trusting");
-  content.insertAfter(0, "second", "trusting");
-  content.insertAfter(0, "third", "trusting");
+  content.insertBefore(0, "second", "trusting");
+  content.insertBefore(0, "third", "trusting");
 
   // They should appear in reverse chronological order
   // because newer items should appear before older items
   expect(content.toString()).toEqual("thirdsecondfirst");
 });
+
+test("Handles different locales correctly", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  // Test with explicit locale in meta
+  const coValueJa = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: { locale: "ja-JP" },
+    ...Crypto.createdNowUnique(),
+  });
+
+  const contentJa = expectPlainText(coValueJa.getCurrentContent());
+  contentJa.insertAfter(0, "こんにちは", "trusting");
+  expect(contentJa.toString()).toEqual("こんにちは");
+
+  // Test browser locale fallback
+  vi.stubGlobal("navigator", { language: "fr-FR" });
+
+  const coValueBrowser = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const contentBrowser = expectPlainText(coValueBrowser.getCurrentContent());
+  contentBrowser.insertAfter(0, "bonjour", "trusting");
+  expect(contentBrowser.toString()).toEqual("bonjour");
+
+  // Test fallback to 'en' when no navigator
+  vi.stubGlobal("navigator", undefined);
+
+  const coValueFallback = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const contentFallback = expectPlainText(coValueFallback.getCurrentContent());
+  contentFallback.insertAfter(0, "hello", "trusting");
+  expect(contentFallback.toString()).toEqual("hello");
+});
+
+test("insertBefore and insertAfter work as expected", () => {
+  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 'h' at start
+  content.insertBefore(0, "h", "trusting"); // "h"
+  expect(content.toString()).toEqual("h");
+
+  // Insert 'e' after 'h'
+  content.insertAfter(0, "e", "trusting"); // "he"
+  expect(content.toString()).toEqual("he");
+
+  // Insert 'y' after 'e'
+  content.insertAfter(1, "y", "trusting"); // "hey"
+  expect(content.toString()).toEqual("hey");
+
+  // Insert '!' at start
+  content.insertBefore(0, "!", "trusting"); // "!hey"
+  expect(content.toString()).toEqual("!hey");
+});