cojson 0.18.5 → 0.18.6

package/src/tests/coList.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, expect, test } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 import { expectList } from "../coValue.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
@@ -428,3 +428,531 @@ test("Should ignore unknown meta transactions", () => {
 
   expect(content.toJSON()).toEqual(["first"]);
 });
+
+describe("CoList Branching", () => {
+  test("should handle concurrent appends from multiple branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches append grocery items
+    aliceBranch.append("bread", undefined, "trusting");
+    aliceBranch.append("butter", undefined, "trusting");
+    bobBranch.append("eggs", undefined, "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain all items from both branches
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "milk",
+        "eggs",
+        "bread",
+        "butter",
+      ]
+    `);
+  });
+
+  test("should handle concurrent prepends from multiple branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches prepend grocery items
+    aliceBranch.prepend("bread", undefined, "trusting");
+    aliceBranch.prepend("butter", undefined, "trusting");
+    bobBranch.prepend("eggs", undefined, "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain all items from both branches
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "eggs",
+        "butter",
+        "bread",
+        "milk",
+      ]
+    `);
+  });
+
+  test("should handle concurrent deletes from multiple branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "bread", "eggs", "cheese"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches delete different grocery items
+    aliceBranch.delete(aliceBranch.asArray().indexOf("bread"), "trusting");
+    bobBranch.delete(bobBranch.asArray().indexOf("eggs"), "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should reflect both deletions
+    expect(groceryList.toJSON()).toEqual(["milk", "cheese"]);
+  });
+
+  test("should handle concurrent insertions at different positions from branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "cheese", "butter"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches insert grocery items at position 1
+    aliceBranch.append("bread", 0, "trusting");
+    bobBranch.append("eggs", 0, "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain both insertions
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "milk",
+        "eggs",
+        "bread",
+        "cheese",
+        "butter",
+      ]
+    `);
+  });
+
+  test("should handle multiple branches modifying different list items", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "bread", "eggs"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+    const charlieBranch = expectList(
+      groceryList.core
+        .createBranch("charlie-branch", group.id)
+        .getCurrentContent(),
+    );
+
+    // Each branch modifies different grocery items
+    aliceBranch.replace(0, "organic milk", "trusting");
+    bobBranch.replace(1, "whole wheat bread", "trusting");
+    charlieBranch.replace(2, "free-range eggs", "trusting");
+
+    // Merge all branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+    charlieBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain all modifications
+    const expected = ["organic milk", "whole wheat bread", "free-range eggs"];
+    expect(groceryList.toJSON()).toEqual(expected);
+  });
+
+  test("should handle appendItems from multiple branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches append multiple grocery items
+    aliceBranch.appendItems(["bread", "butter"], undefined, "trusting");
+    bobBranch.appendItems(["eggs", "cheese"], undefined, "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain all items
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "milk",
+        "eggs",
+        "cheese",
+        "bread",
+        "butter",
+      ]
+    `);
+  });
+
+  test("should handle complex operations from multiple branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+    const client2 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "bread", "eggs"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Alice performs multiple operations
+    aliceBranch.delete(1, "trusting"); // Remove "bread"
+    aliceBranch.append("cheese", undefined, "trusting");
+    aliceBranch.prepend("yogurt", undefined, "trusting");
+
+    // Bob performs different operations
+    bobBranch.replace(0, "organic milk", "trusting");
+    bobBranch.append("butter", undefined, "trusting");
+    bobBranch.delete(2, "trusting"); // Remove "eggs"
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain the combined result
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "yogurt",
+        "organic milk",
+        "butter",
+        "cheese",
+      ]
+    `);
+  });
+
+  test("should handle multiple branch merges with incremental changes", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+    const charlieBranch = expectList(
+      groceryList.core
+        .createBranch("charlie-branch", group.id)
+        .getCurrentContent(),
+    );
+
+    // Each branch adds grocery items
+    aliceBranch.append("bread", undefined, "trusting");
+    bobBranch.append("eggs", undefined, "trusting");
+    charlieBranch.append("cheese", undefined, "trusting");
+
+    // Merge branches one by one
+    aliceBranch.core.mergeBranch();
+    await groceryList.core.waitForSync();
+    expect(groceryList.toJSON()).toEqual(["milk", "bread"]);
+
+    bobBranch.core.mergeBranch();
+    await groceryList.core.waitForSync();
+    expect(groceryList.toJSON()).toEqual(["milk", "eggs", "bread"]);
+
+    charlieBranch.core.mergeBranch();
+    await groceryList.core.waitForSync();
+    expect(groceryList.toJSON()).toEqual(["milk", "cheese", "eggs", "bread"]);
+  });
+
+  test("should resolve conflicts when multiple branches modify the same position", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "bread", "eggs"]);
+
+    // Create branches for each client
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-branch", group.id)
+        .getCurrentContent(),
+    );
+    const bobBranch = expectList(
+      groceryList.core.createBranch("bob-branch", group.id).getCurrentContent(),
+    );
+
+    // Both branches try to replace the same item at position 1
+    aliceBranch.replace(1, "whole wheat bread", "trusting");
+    bobBranch.replace(1, "sourdough bread", "trusting");
+
+    // Merge both branches back to source
+    aliceBranch.core.mergeBranch();
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should have a consistent state after conflict resolution
+    expect(groceryList.toJSON()).toContain("whole wheat bread");
+    expect(groceryList.toJSON()).toContain("sourdough bread");
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "milk",
+        "sourdough bread",
+        "whole wheat bread",
+        "eggs",
+      ]
+    `);
+  });
+
+  test("should handle concurrent deletions at overlapping positions across branches", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const list = group.createList(["milk", "bread", "eggs"]);
+
+    // Create branches for each client
+    const mondayShoppingBranch = expectList(
+      list.core.createBranch("monday-shopping", group.id).getCurrentContent(),
+    );
+    const tuesdayShoppingBranch = expectList(
+      list.core.createBranch("tuesday-shopping", group.id).getCurrentContent(),
+    );
+
+    mondayShoppingBranch.delete(list.asArray().indexOf("milk"), "trusting");
+    tuesdayShoppingBranch.delete(list.asArray().indexOf("eggs"), "trusting");
+
+    // Merge both branches back to source
+    mondayShoppingBranch.core.mergeBranch();
+    tuesdayShoppingBranch.core.mergeBranch();
+
+    // Source list should reflect all deletions
+    expect(list.toJSON()).toEqual(["bread"]);
+  });
+
+  test("should handle branching from different sessions and merging back", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+    const client2 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk", "bread"]);
+
+    // Client1 creates a branch
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-shopping-branch", group.id)
+        .getCurrentContent(),
+    );
+
+    // Client1 adds items to the branch
+    aliceBranch.append("eggs", undefined, "trusting");
+
+    // Client2 loads the branch from a different session
+    const branchOnClient2 = await loadCoValueOrFail(
+      client2.node,
+      aliceBranch.id,
+    );
+
+    // Client2 adds more items and removes some existing ones
+    branchOnClient2.append("cheese", undefined, "trusting");
+    branchOnClient2.delete(
+      branchOnClient2.asArray().indexOf("bread"),
+      "trusting",
+    );
+
+    // Merge the branch back to source
+    branchOnClient2.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain the final state
+    expect(groceryList.toJSON()).toEqual(["milk", "eggs", "cheese"]);
+  });
+
+  test("should handle multiple branches from different sessions with complex operations", async () => {
+    const client1 = setupTestNode({
+      connected: true,
+    });
+    const client2 = setupTestNode({
+      connected: true,
+    });
+
+    const group = client1.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const groceryList = group.createList(["milk"]);
+
+    // Client1 creates first branch
+    const aliceBranch = expectList(
+      groceryList.core
+        .createBranch("alice-shopping-branch", group.id)
+        .getCurrentContent(),
+    );
+
+    // Client1 adds items to first branch
+    aliceBranch.append("bread", undefined, "trusting");
+
+    // Client2 creates second branch
+    const bobBranch = expectList(
+      groceryList.core
+        .createBranch("bob-shopping-branch", group.id)
+        .getCurrentContent(),
+    );
+
+    // Client2 adds different items to second branch
+    bobBranch.append("eggs", undefined, "trusting");
+
+    // Client2 loads first branch and modifies it
+    const aliceBranchOnClient2 = await loadCoValueOrFail(
+      client2.node,
+      aliceBranch.id,
+    );
+    aliceBranchOnClient2.append("butter", undefined, "trusting");
+
+    // Merge all branches back to source
+    aliceBranchOnClient2.core.mergeBranch();
+
+    // Make the second merge happen later than the previous one, so the ordering is not based on the random sessionIDs
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    bobBranch.core.mergeBranch();
+
+    // Wait for sync
+    await groceryList.core.waitForSync();
+
+    // Source list should contain all changes
+    expect(groceryList.toJSON()).toMatchInlineSnapshot(`
+      [
+        "milk",
+        "eggs",
+        "bread",
+        "butter",
+      ]
+    `);
+  });
+});

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

@@ -507,9 +507,9 @@ describe("loading coValues from server", () => {
       connected: true,
     });
 
-    await loadCoValueOrFail(client.node, largeMap.id);
+    const mapOnClient = await loadCoValueOrFail(client.node, largeMap.id);
 
-    await largeMap.core.waitForSync();
+    await mapOnClient.core.waitForFullStreaming();
 
     expect(
       SyncMessagesLog.getMessages({

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

@@ -14,12 +14,15 @@ import { getDbPath } from "./testStorage";
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
 
+beforeEach(async () => {
+  setMaxRecommendedTxSize(100 * 1024);
+});
+
 describe("client with storage syncs with server", () => {
   let jazzCloud: ReturnType<typeof setupTestNode>;
 
   beforeEach(async () => {
     vi.resetAllMocks();
-    setMaxRecommendedTxSize(100 * 1024);
     SyncMessagesLog.clear();
     jazzCloud = setupTestNode({
       isSyncServer: true,
@@ -434,6 +437,8 @@ describe("client syncs with a server with storage", () => {
   });
 
   test("large coValue streaming from cold server", async () => {
+    setMaxRecommendedTxSize(1000);
+
     const server = setupTestNode({
       isSyncServer: true,
     });
@@ -470,8 +475,6 @@ describe("client syncs with a server with storage", () => {
 
     await largeMap.core.waitForSync();
 
-    SyncMessagesLog.clear();
-
     server.restart();
 
     server.addStorage({
@@ -491,9 +494,10 @@ describe("client syncs with a server with storage", () => {
       storage,
     });
 
-    const mapOnClient2 = await loadCoValueOrFail(client.node, largeMap.id);
+    SyncMessagesLog.clear();
 
-    await mapOnClient2.core.waitForSync();
+    const mapOnClient2 = await loadCoValueOrFail(client.node, largeMap.id);
+    await mapOnClient2.core.waitForFullStreaming();
 
     expect(
       SyncMessagesLog.getMessages({
@@ -516,13 +520,6 @@ describe("client syncs with a server with storage", () => {
         "storage -> client | CONTENT Map header: true new: After: 7 New: 1",
         "storage -> client | CONTENT Map header: true new: After: 8 New: 1",
         "storage -> client | CONTENT Map header: true new: After: 9 New: 1",
-        "storage -> client | CONTENT Map header: true new: After: 10 New: 0",
-        "server -> storage | LOAD Group sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
-        "server -> client | KNOWN Group sessions: header/5",
-        "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Map header: true new: After: 0 New: 1 expectContentUntil: header/10",
-        "server -> client | KNOWN Map sessions: header/10",
       ]
     `);
   });