cojson 0.13.7 → 0.13.11

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");
+});

package/src/tests/coValueCore.test.ts

@@ -287,12 +287,30 @@ test("creating a coValue with a group should't trigger automatically a content c
   });
 
   // It's called once for the group and never for the coValue
-  expect(getCurrentContentSpy).toHaveBeenCalledTimes(1);
-  expect(groupSpy).toHaveBeenCalledTimes(1);
+  expect(getCurrentContentSpy).toHaveBeenCalledTimes(0);
+  expect(groupSpy).toHaveBeenCalledTimes(0);
 
   getCurrentContentSpy.mockRestore();
 });
 
+test("loading a coValue core without having the owner group available doesn't crash", () => {
+  const [account, sessionID] = randomAnonymousAccountAndSessionID();
+  const node = new LocalNode(account, sessionID, Crypto);
+
+  const otherNode = createTestNode();
+
+  const group = otherNode.createGroup();
+
+  const coValue = node.createCoValue({
+    type: "costream",
+    ruleset: { type: "ownedByGroup", group: group.id },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  expect(coValue.id).toBeDefined();
+});
+
 test("listeners are notified even if the previous listener threw an error", async () => {
   const { node1, node2 } = await createTwoConnectedNodes("server", "server");
 

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

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
 
+import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
   loadCoValueOrFail,
@@ -8,9 +9,7 @@ import {
 } from "./testUtils";
 
 function setupMesh() {
-  const coreServer = setupTestNode({
-    isSyncServer: true,
-  });
+  const coreServer = setupTestNode();
 
   coreServer.addStoragePeer({
     ourName: "core",
@@ -20,12 +19,14 @@ function setupMesh() {
   edgeItaly.connectToSyncServer({
     ourName: "edge-italy",
     syncServerName: "core",
+    syncServer: coreServer.node,
   });
 
   const edgeFrance = setupTestNode();
   edgeFrance.connectToSyncServer({
     ourName: "edge-france",
     syncServerName: "core",
+    syncServer: coreServer.node,
   });
 
   return { coreServer, edgeItaly, edgeFrance };
@@ -161,6 +162,83 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
     `);
   });
 
+  test("syncs corrections from multiple peers", async () => {
+    const client = setupTestNode();
+
+    client.connectToSyncServer({
+      syncServerName: "edge-italy",
+      syncServer: mesh.edgeItaly.node,
+    });
+
+    const group = mesh.edgeItaly.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const map = group.createMap({
+      fromServer: "initial",
+      fromClient: "initial",
+    });
+
+    // Load the coValue on the client
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    const mapOnCoreServer = await loadCoValueOrFail(
+      mesh.coreServer.node,
+      map.id,
+    );
+
+    // Forcefully delete the coValue from the edge (simulating some data loss)
+    mesh.edgeItaly.node.coValuesStore.coValues.delete(map.id);
+
+    mapOnClient.set("fromClient", "updated", "trusting");
+    mapOnCoreServer.set("fromServer", "updated", "trusting");
+
+    await waitFor(() => {
+      const coValue = expectMap(
+        mesh.edgeItaly.node.expectCoValueLoaded(map.id).getCurrentContent(),
+      );
+      expect(coValue.get("fromServer")).toEqual("updated");
+      expect(coValue.get("fromClient")).toEqual("updated");
+    });
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> edge-italy | LOAD Map sessions: empty",
+        "edge-italy -> core | CONTENT Group header: true new: After: 0 New: 5",
+        "edge-italy -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "core -> edge-italy | KNOWN Group sessions: header/5",
+        "client -> edge-italy | KNOWN Group sessions: header/5",
+        "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
+        "edge-italy -> core | CONTENT Map header: true new: After: 0 New: 1",
+        "edge-italy -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "storage -> core | KNOWN Group sessions: header/5",
+        "core -> edge-italy | KNOWN Map sessions: header/1",
+        "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> edge-italy | KNOWN Map sessions: header/1",
+        "storage -> core | KNOWN Map sessions: header/1",
+        "client -> edge-italy | CONTENT Map header: false new: After: 0 New: 1",
+        "core -> storage | CONTENT Map header: false new: After: 0 New: 1",
+        "edge-italy -> client | KNOWN CORRECTION Map sessions: empty",
+        "storage -> core | KNOWN Map sessions: header/2",
+        "core -> edge-italy | CONTENT Map header: false new: After: 0 New: 1",
+        "client -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
+        "edge-italy -> core | KNOWN CORRECTION Map sessions: empty",
+        "edge-italy -> client | KNOWN Map sessions: header/2",
+        "core -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
+        "edge-italy -> core | CONTENT Map header: false new: After: 0 New: 1",
+        "edge-italy -> client | CONTENT Map header: false new: After: 0 New: 1",
+        "core -> edge-italy | KNOWN Map sessions: header/3",
+        "edge-italy -> core | KNOWN Map sessions: header/3",
+        "client -> edge-italy | KNOWN Map sessions: header/3",
+        "core -> storage | CONTENT Map header: false new: After: 0 New: 1",
+        "storage -> core | KNOWN Map sessions: header/3",
+      ]
+    `);
+  });
+
   test("sync of changes of a coValue with bad signatures should be blocked", async () => {
     const italianClient = setupTestNode();
     const frenchClient = setupTestNode();

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

@@ -1,6 +1,7 @@
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue";
 import { WasmCrypto } from "../crypto/WasmCrypto";
+import { CoValueCore, RawCoMap } from "../exports";
 import { LocalNode } from "../localNode";
 import { toSimplifiedMessages } from "./messagesTestUtils";
 import {
@@ -156,6 +157,55 @@ describe("peer reconciliation", () => {
     `);
   });
 
+  test("correctly handle server restarts in the middle of a sync", async () => {
+    const client = setupTestNode();
+
+    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.coValuesStore.get(map.id);
+
+      expect(mapOnSyncServer.state.type).toBe("available");
+    });
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "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 Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "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.skip("handle peer reconnections with data loss", async () => {
     const client = setupTestNode();
 

package/src/tests/testUtils.ts

@@ -472,13 +472,13 @@ export function setupTestNode(
     connectToSyncServer();
   }
 
-  return {
+  const ctx = {
     node,
     connectToSyncServer,
     addStoragePeer,
     restart: () => {
       node.gracefulShutdown();
-      node = new LocalNode(admin, session, Crypto);
+      ctx.node = node = new LocalNode(admin, session, Crypto);
 
       if (opts.isSyncServer) {
         syncServer.current = node;
@@ -487,6 +487,8 @@ export function setupTestNode(
       return node;
     },
   };
+
+  return ctx;
 }
 
 export async function setupTestAccount(