cojson 0.18.6 → 0.18.7

package/src/tests/branching.test.ts

@@ -1,10 +1,11 @@
-import { beforeEach, describe, expect, test } from "vitest";
+import { assert, beforeEach, describe, expect, test } from "vitest";
 import {
   createTestNode,
   setupTestNode,
   loadCoValueOrFail,
 } from "./testUtils.js";
 import { expectList, expectMap, expectPlainText } from "../coValue.js";
+import { RawCoMap } from "../exports.js";
 
 let jazzCloud: ReturnType<typeof setupTestNode>;
 
@@ -94,7 +95,7 @@ describe("Branching Logic", () => {
       const result = expectMap(branch.core.mergeBranch().getCurrentContent());
 
       // Verify only one merge commit was created
-      expect(result.core.mergeCommits.length).toBe(1);
+      expect(branch.core.mergeCommits.length).toBe(1);
 
       // Verify source contains branch transactions
       expect(result.get("key1")).toBe("branchValue1");
@@ -154,7 +155,7 @@ describe("Branching Logic", () => {
       branch.core.mergeBranch();
 
       // Verify two merge commits exist
-      expect(originalMap.core.mergeCommits.length).toBe(2);
+      expect(branch.core.mergeCommits.length).toBe(2);
 
       // Verify both changes are now in original map
       expect(originalMap.get("key1")).toBe("branchValue1");
@@ -210,6 +211,8 @@ describe("Branching Logic", () => {
           .getCurrentContent(),
       );
 
+      await new Promise((resolve) => setTimeout(resolve, 5));
+
       // Add different items to second branch
       branch2.appendItems(["apples", "oranges", "carrots"]);
 
@@ -233,18 +236,20 @@ describe("Branching Logic", () => {
 
       expect(list.toJSON()).toEqual([
         "bread",
-        "cheese",
         "apples",
         "oranges",
         "carrots",
         "tomatoes",
         "cucumber",
+        "cheese",
       ]);
     });
 
-    test("should work with co.plainText when branching from different session", async () => {
-      const node = createTestNode();
-      const group = node.createGroup();
+    test("should work with co.plainText when merging the same branch twice on different sessions", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
       const plainText = group.createPlainText();
 
       plainText.insertAfter(0, "hello");
@@ -255,12 +260,28 @@ describe("Branching Logic", () => {
           .getCurrentContent(),
       );
 
+      branch.insertAfter("hello".length, " world");
+
+      const anotherSession = client.spawnNewSession();
+
+      const loadedBranch = await loadCoValueOrFail(
+        anotherSession.node,
+        branch.id,
+      );
+      assert(loadedBranch);
+
+      anotherSession.connectToSyncServer().peerState.gracefulShutdown();
+
       // Add more items to the branch
-      branch.insertAfter("hello".length, "world");
+      loadedBranch.insertAfter("hello world".length, " people");
 
       branch.core.mergeBranch();
+      const loadedBranchMergeResult = loadedBranch.core.mergeBranch();
 
-      expect(plainText.toString()).toEqual("helloworld");
+      anotherSession.connectToSyncServer();
+      await loadedBranchMergeResult.waitForSync();
+
+      expect(plainText.toString()).toEqual("hello world people");
     });
   });
 
@@ -527,4 +548,132 @@ describe("Branching Logic", () => {
       expect(aliceBranch.get("bob")).toBe(true);
     });
   });
+
+  test("should alias the txID when a transaction comes from a merge", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.set("key", "value");
+
+    const branch = map.core
+      .createBranch("feature-branch", group.id)
+      .getCurrentContent() as RawCoMap;
+    branch.set("branchKey", "branchValue");
+
+    const originalTxID = branch.core
+      .getValidTransactions({
+        skipBranchSource: true,
+        ignorePrivateTransactions: false,
+      })
+      .at(-1)?.txID;
+
+    branch.core.mergeBranch();
+
+    map.set("key2", "value2");
+
+    const validSortedTransactions = map.core.getValidSortedTransactions();
+
+    // Only the merged transaction should have the txId changed
+    const mergedTransactionIdx = validSortedTransactions.findIndex(
+      (tx) => tx.txID.branch,
+    );
+
+    expect(validSortedTransactions[mergedTransactionIdx - 1]?.txID.branch).toBe(
+      undefined,
+    );
+    expect(validSortedTransactions[mergedTransactionIdx]?.txID).toEqual(
+      originalTxID,
+    );
+    expect(validSortedTransactions[mergedTransactionIdx + 1]?.txID.branch).toBe(
+      undefined,
+    );
+  });
+
+  describe("hasBranch", () => {
+    test("should work when the branch owner is the source owner", () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const map = group.createMap();
+
+      map.set("key", "value");
+
+      const branch = map.core.createBranch("feature-branch", group.id);
+
+      expect(map.core.hasBranch("feature-branch")).toBe(true);
+      expect(map.core.hasBranch("feature-branch", group.id)).toBe(true);
+      expect(branch.hasBranch("feature-branch")).toBe(false);
+    });
+
+    test("should work when the branch onwer is implicit", () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const map = group.createMap();
+
+      map.set("key", "value");
+
+      const branch = map.core.createBranch("feature-branch");
+
+      expect(map.core.hasBranch("feature-branch")).toBe(true);
+      expect(map.core.hasBranch("feature-branch", group.id)).toBe(true);
+      expect(branch.hasBranch("feature-branch")).toBe(false);
+    });
+
+    test("should return false for non-existent branch name", () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const map = group.createMap();
+
+      map.set("key", "value");
+
+      expect(map.core.hasBranch("non-existent-branch")).toBe(false);
+    });
+
+    test("should work with explicit ownerId parameter", () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const map = group.createMap();
+
+      map.set("key", "value");
+
+      const differentGroup = client.node.createGroup();
+
+      map.core.createBranch("feature-branch", differentGroup.id);
+
+      // Test with explicit ownerId
+      expect(map.core.hasBranch("feature-branch", differentGroup.id)).toBe(
+        true,
+      );
+      expect(map.core.hasBranch("feature-branch")).toBe(false);
+    });
+
+    test("should work when the transactions have not been parsed yet", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const map = group.createMap();
+
+      map.set("key", "value");
+
+      map.core.createBranch("feature-branch", group.id);
+
+      await map.core.waitForSync();
+
+      const newSession = client.spawnNewSession();
+      const loadedMapCore = await newSession.node.loadCoValueCore(map.core.id);
+
+      expect(loadedMapCore.hasBranch("feature-branch", group.id)).toBe(true);
+    });
+  });
 });

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);

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

@@ -0,0 +1,153 @@
+import { beforeEach, describe, expect, test } from "vitest";
+
+import { SyncMessagesLog, TEST_NODE_CONFIG, setupTestNode } from "./testUtils";
+
+// We want to simulate a real world communication that happens asynchronously
+TEST_NODE_CONFIG.withAsyncPeers = true;
+
+describe("handling content messages", () => {
+  beforeEach(async () => {
+    SyncMessagesLog.clear();
+  });
+
+  test("dependencies are included when syncing new content to clients", async () => {
+    /*
+     * Initial Setup:
+     * core <-- edge <-- client1
+     */
+    const core = setupTestNode();
+
+    const edge = setupTestNode();
+    edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core",
+      syncServer: core.node,
+    });
+
+    const client1 = setupTestNode();
+    client1.connectToSyncServer({
+      ourName: "client1",
+      syncServerName: "edge",
+      syncServer: edge.node,
+    });
+
+    // Create a map with a dependency on the client.
+    // Everythig will sync all the way back to core.
+    const group = client1.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+    await map.core.waitForSync();
+
+    /*
+     * Add another client:
+     *
+     *                  |-- client1
+     * core <-- edge <--|
+     *                  |-- client2
+     *
+     */
+    const client2 = setupTestNode();
+    const { peerStateOnServer: client2PeerStateOnEdge } =
+      client2.connectToSyncServer({
+        ourName: "client2",
+        syncServerName: "edge",
+        syncServer: edge.node,
+      });
+
+    client2PeerStateOnEdge.setOptimisticKnownState(map.core.id, {
+      id: map.core.id,
+      header: false,
+      sessions: {},
+    });
+
+    // Update the map on client1.
+    // This should sync the map AND its dependencies to the new client.
+    map.set("hello2", "world2", "trusting");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> client2 | CONTENT Map"),
+      ),
+    ).toBe(true);
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> client2 | CONTENT Group"),
+      ),
+    ).toBe(true);
+  });
+
+  test("dependencies are excluded when syncing new content to servers", async () => {
+    /*
+     * Initial Setup:
+     * core1 <-- edge <-- client
+     */
+    const core1 = setupTestNode();
+
+    const edge = setupTestNode();
+    edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core1",
+      syncServer: core1.node,
+    });
+
+    const client = setupTestNode();
+    client.connectToSyncServer({
+      ourName: "client",
+      syncServerName: "edge",
+      syncServer: edge.node,
+    });
+
+    // Create a map with a dependency on the client.
+    // Everythig will sync all the way back to core1.
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+    await map.core.waitForSync();
+
+    /*
+     * Add another core:
+     *
+     * core1 <--
+     *         |
+     *         |-- edge <-- client
+     *         |
+     * core2 <--
+     */
+    const core2 = setupTestNode();
+    const { peerState: core2PeerStateOnEdge } = edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core2",
+      syncServer: core2.node,
+      skipReconciliation: true,
+    });
+
+    core2PeerStateOnEdge.setOptimisticKnownState(map.core.id, {
+      id: map.core.id,
+      header: false,
+      sessions: {},
+    });
+
+    // Update the map on the client.
+    // This should sync ONLY the map back to both cores.
+    map.set("hello2", "world2", "trusting");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some((msg) => msg.startsWith("edge -> core2 | CONTENT Map")),
+    ).toBe(true);
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> core2 | CONTENT Group"),
+      ),
+    ).toBe(false);
+  });
+});

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

@@ -171,10 +171,10 @@ describe("loading coValues from server", () => {
       [
         "client -> server | LOAD Branch sessions: empty",
         "server -> client | CONTENT Group header: true new: After: 0 New: 5",
-        "server -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 3",
         "server -> client | CONTENT Branch header: true new: After: 0 New: 2",
         "client -> server | KNOWN Group sessions: header/5",
-        "client -> server | KNOWN Map sessions: header/2",
+        "client -> server | KNOWN Map sessions: header/3",
         "client -> server | KNOWN Branch sessions: header/2",
       ]
     `);

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

@@ -238,7 +238,7 @@ describe("client with storage syncs with server", () => {
       [
         "client -> storage | LOAD Branch sessions: empty",
         "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
-        "storage -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 3",
         "storage -> client | CONTENT Branch header: true new: After: 0 New: 2",
       ]
     `);

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

@@ -92,11 +92,11 @@ describe("client to server upload", () => {
         "server -> client | CONTENT Map header: true new: After: 0 New: 2",
         "client -> server | KNOWN Group sessions: header/5",
         "client -> server | KNOWN Map sessions: header/2",
-        "client -> server | LOAD Branch sessions: empty",
-        "server -> client | KNOWN Branch sessions: empty",
         "client -> server | CONTENT Branch header: true new: After: 0 New: 1",
+        "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "client -> server | CONTENT Branch header: false new: After: 1 New: 1",
         "server -> client | KNOWN Branch sessions: header/1",
+        "server -> client | KNOWN Map sessions: header/3",
         "server -> client | KNOWN Branch sessions: header/2",
       ]
     `);