cojson 0.18.5 → 0.18.7

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/coValueCore.test.ts

@@ -8,7 +8,6 @@ import {
   vi,
 } from "vitest";
 import { CoValueCore } from "../coValueCore/coValueCore.js";
-import { Transaction } from "../coValueCore/verifiedState.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
@@ -24,7 +23,7 @@ import {
   tearDownTestMetricReader,
 } from "./testUtils.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
-import { determineValidTransactions } from "../permissions.js";
+import { setMaxTxSizeBytes } from "../config.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -57,6 +56,7 @@ test("transactions with wrong signature are rejected", () => {
       node.getCurrentAgent(),
       [{ hello: "world" }],
       undefined,
+      Date.now(),
     );
 
   transaction.madeAt = Date.now() + 1000;
@@ -87,6 +87,66 @@ test("transactions with wrong signature are rejected", () => {
   expect(newEntry.getValidSortedTransactions().length).toBe(0);
 });
 
+describe("transactions that exceed the byte size limit are rejected", () => {
+  beforeEach(() => {
+    setMaxTxSizeBytes(1 * 1024);
+  });
+
+  afterEach(() => {
+    setMaxTxSizeBytes(1 * 1024 * 1024);
+  });
+
+  test("makeTransaction should throw error when transaction exceeds byte size limit", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const largeBinaryData = "x".repeat(1024 + 100);
+
+    expect(() => {
+      coValue.makeTransaction(
+        [
+          {
+            data: largeBinaryData,
+          },
+        ],
+        "trusting",
+      );
+    }).toThrow(/Transaction is too large to be synced/);
+  });
+
+  test("makeTransaction should work for transactions under byte size limit", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const smallData = "Hello, world!";
+
+    const success = coValue.makeTransaction(
+      [
+        {
+          data: smallData,
+        },
+      ],
+      "trusting",
+    );
+
+    expect(success).toBe(true);
+  });
+});
+
 test("New transactions in a group correctly update owned values, including subscriptions", async () => {
   const [agent, sessionID] = randomAgentAndSessionID();
   const node = new LocalNode(agent.agentSecret, sessionID, Crypto);