cojson 0.17.12 → 0.17.14

package/src/tests/coMap.test.ts

@@ -217,6 +217,27 @@ test("Can set items in bulk with assign", () => {
   });
 });
 
+test("Should ignore unknown meta transactions", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  coValue.makeTransaction([], "trusting", { unknownMeta: 1 });
+
+  const content = expectMap(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("comap");
+
+  content.set("key1", "set1", "trusting");
+
+  expect(content.get("key1")).toEqual("set1");
+});
+
 test("totalValidTransactions should return the number of valid transactions processed", async () => {
   const client = setupTestNode({
     connected: true,

package/src/tests/coPlainText.test.ts

@@ -298,6 +298,24 @@ test("Splits into and from grapheme string arrays", () => {
   expect(text).toEqual("👋 안녕!");
 });
 
+test("Should ignore unknown meta transactions", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  coValue.makeTransaction([], "trusting", { unknownMeta: 1 });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  content.insertAfter(0, "hello", "trusting");
+  expect(content.toString()).toEqual("hello");
+});
+
 test("chunks transactions when when the chars are longer than MAX_RECOMMENDED_TX_SIZE", async () => {
   setMaxRecommendedTxSize(5);
 

package/src/tests/coStream.test.ts

@@ -127,6 +127,42 @@ test("Can push into RawBinaryCoStream", () => {
   });
 });
 
+test("Should ignore meta transactions on RawBinaryCoStream", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+
+  const coValue = node.createCoValue({
+    type: "costream",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: { type: "binary" },
+    ...Crypto.createdNowUnique(),
+  });
+
+  coValue.makeTransaction([], "trusting", { unknownMeta: 1 });
+
+  const content = coValue.getCurrentContent();
+
+  if (
+    content.type !== "costream" ||
+    content.headerMeta?.type !== "binary" ||
+    !(content instanceof RawBinaryCoStream)
+  ) {
+    throw new Error("Expected binary stream");
+  }
+
+  content.startBinaryStream(
+    { mimeType: "text/plain", fileName: "test.txt" },
+    "trusting",
+  );
+  content.pushBinaryStreamChunk(new Uint8Array([1, 2, 3]), "trusting");
+  content.endBinaryStream("trusting");
+  expect(content.getBinaryChunks()).toEqual({
+    mimeType: "text/plain",
+    fileName: "test.txt",
+    chunks: [new Uint8Array([1, 2, 3])],
+    finished: true,
+  });
+});
+
 test("When adding large transactions (small fraction of MAX_RECOMMENDED_TX_SIZE), we store an inbetween signature every time we reach MAX_RECOMMENDED_TX_SIZE and split up newContentSince accordingly", () => {
   const node = nodeWithRandomAgentAndSessionID();
 

package/src/tests/coValueCore.test.ts

@@ -20,9 +20,11 @@ import {
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
   randomAgentAndSessionID,
+  setupTestNode,
   tearDownTestMetricReader,
 } from "./testUtils.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { determineValidTransactions } from "../permissions.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -32,6 +34,7 @@ const agentSecret =
 
 beforeEach(() => {
   metricReader = createTestMetricReader();
+  setupTestNode({ isSyncServer: true });
 });
 
 afterEach(() => {
@@ -53,6 +56,7 @@ test("transactions with wrong signature are rejected", () => {
       node.currentSessionID,
       node.getCurrentAgent(),
       [{ hello: "world" }],
+      undefined,
     );
 
   transaction.madeAt = Date.now() + 1000;
@@ -264,6 +268,51 @@ test("listeners are notified even if the previous listener threw an error", asyn
   errorLog.mockRestore();
 });
 
+test("creates a transaction with trusting meta information", async () => {
+  const client = setupTestNode();
+
+  const group = client.node.createGroup();
+  const map = group.createMap();
+  map.core.makeTransaction([], "trusting", {
+    meta: true,
+  });
+
+  const validTransactions = determineValidTransactions(map.core);
+
+  expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+});
+
+test("creates a transaction with private meta information", async () => {
+  const client = setupTestNode({ connected: true });
+
+  const group = client.node.createGroup();
+  const map = group.createMap();
+  map.core.makeTransaction([], "private", {
+    meta: true,
+  });
+
+  const localTransactionMeta = map.core.verified.decryptTransactionMeta(
+    client.node.currentSessionID,
+    0,
+    map.core.getCurrentReadKey().secret!,
+  );
+
+  expect(localTransactionMeta).toEqual({ meta: true });
+
+  const newSession = client.spawnNewSession();
+
+  const mapOnNewSession = await loadCoValueOrFail(newSession.node, map.id);
+
+  const syncedTransactionMeta =
+    mapOnNewSession.core.verified.decryptTransactionMeta(
+      client.node.currentSessionID,
+      0,
+      mapOnNewSession.core.getCurrentReadKey().secret!,
+    );
+
+  expect(syncedTransactionMeta).toEqual({ meta: true });
+});
+
 test("getValidTransactions should skip private transactions with invalid JSON", () => {
   const [agent, sessionID] = agentAndSessionIDFromSecret(agentSecret);
   const node = new LocalNode(agent.agentSecret, sessionID, Crypto);

package/src/tests/coreWasm.test.ts

@@ -85,6 +85,7 @@ describe("SessionLog WASM", () => {
       key.id,
       key.secret,
       0,
+      undefined,
     );
 
     expect(signature).toMatch(/^signature_z[a-zA-Z0-9]+$/);

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

@@ -1,16 +1,15 @@
 import { beforeEach, describe, expect, test } from "vitest";
-import { setCoValueLoadingRetryDelay } from "../config";
+import { Peer } from "../exports";
+import { hwrServerPeerSelector, ServerPeerSelector } from "../sync";
 import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
-  blockMessageTypeOnOutgoingPeer,
+  connectedPeersWithMessagesTracking,
   getSyncServerConnectedPeer,
-  loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
 } from "./testUtils";
-import { Peer } from "../exports";
-import { ServerPeerSelector } from "../sync";
+import { PeerState } from "../PeerState";
 
 beforeEach(async () => {
   // We want to simulate a real world communication that happens asynchronously
@@ -47,7 +46,6 @@ describe("sharding", () => {
     const firstAlphabetical: ServerPeerSelector = (id, serverPeers) => {
       return serverPeers.sort((a, b) => a.id.localeCompare(b.id)).slice(0, 1);
     };
-
     const { node: client } = setupTestNode({
       connected: false,
     });
@@ -73,4 +71,156 @@ describe("sharding", () => {
       allPeers.sort((a, b) => a.id.localeCompare(b.id))[0]!.id,
     );
   });
+
+  test("getPeers respects the serverPeerSelector", async () => {
+    const firstPeer: ServerPeerSelector = (id, serverPeers) => {
+      return serverPeers.slice(0, 1);
+    };
+    const { node: edge } = setupTestNode({
+      connected: false,
+    });
+    edge.syncManager.serverPeerSelector = firstPeer;
+
+    // Connect 2 clients to edge
+    for (let i = 0; i < 2; i++) {
+      const client = await setupTestAccount({});
+      const { peer1, peer2 } = connectedPeersWithMessagesTracking({
+        peer1: {
+          id: client.node.getCurrentAgent().id,
+          role: "client",
+        },
+        peer2: {
+          id: edge.getCurrentAgent().id,
+          role: "server",
+        },
+      });
+
+      edge.syncManager.addPeer(peer1);
+    }
+
+    // Connect edge to 3 core nodes
+    for (let i = 0; i < 3; i++) {
+      const syncServer = await setupTestAccount({ isSyncServer: true });
+
+      const { peer } = getSyncServerConnectedPeer({
+        peerId: edge.getCurrentAgent().id,
+        syncServer: syncServer.node,
+      });
+
+      edge.syncManager.addPeer(peer);
+    }
+
+    expect(edge.syncManager.getPeers("co_z12345").length).toBe(
+      2 + 1, // 2 clients + 1 selected core
+    );
+  });
+
+  describe("hwrServerPeerSelector", () => {
+    const createMockPeer = (
+      id: string,
+      role: "server" | "client" = "server",
+    ): Peer => ({
+      id,
+      role,
+      incoming: {
+        close: () => {},
+        onMessage: () => {},
+        onClose: () => {},
+      },
+      outgoing: {
+        push: () => {},
+        close: () => {},
+        onClose: () => {},
+      },
+    });
+
+    test("selects top n peers by hash weight", () => {
+      const allPeers = Array.from(
+        { length: 5 },
+        (_, i) => new PeerState(createMockPeer(`peer_${i + 1}`), undefined),
+      );
+
+      // Create selector that picks top 2 peers
+      const selector = hwrServerPeerSelector(2);
+      const selectedPeers = selector("co_ztest123", allPeers);
+
+      // Should return exactly 2 peers (n=2)
+      expect(selectedPeers.length).toBe(2);
+
+      // All returned peers should be from the original set
+      expect(allPeers).toContain(selectedPeers[0]);
+      expect(allPeers).toContain(selectedPeers[1]);
+
+      // The two peers should be different
+      expect(selectedPeers[0]).not.toBe(selectedPeers[1]);
+    });
+
+    test("returns all peers when n >= total peers", () => {
+      const allPeers = Array.from(
+        { length: 3 },
+        (_, i) => new PeerState(createMockPeer(`peer_${i + 1}`), undefined),
+      );
+
+      // Create a selector that picks top 10 peers (more than we'll have)
+      const selector = hwrServerPeerSelector(10);
+      const selectedPeers = selector("co_ztest123", allPeers);
+
+      // Should return all 3 peers since n=10 > 3
+      expect(selectedPeers.length).toBe(3);
+      expect(new Set(selectedPeers.map((p) => p.id))).toEqual(
+        new Set(allPeers.map((p) => p.id)),
+      );
+    });
+
+    test("returns consistent results for same CoValue ID", () => {
+      const allPeers = Array.from(
+        { length: 5 },
+        (_, i) => new PeerState(createMockPeer(`peer_${i + 1}`), undefined),
+      );
+
+      const selector = hwrServerPeerSelector(2);
+
+      // Call the selector multiple times with the same CoValue ID
+      const result1 = selector("co_ztest123", allPeers);
+      const result2 = selector("co_ztest123", allPeers);
+      const result3 = selector("co_ztest123", allPeers);
+
+      // Results should be consistent (same peers selected each time for the same CoValue ID)
+      expect(new Set(result1.map((p) => p.id))).toEqual(
+        new Set(result2.map((p) => p.id)),
+      );
+      expect(new Set(result2.map((p) => p.id))).toEqual(
+        new Set(result3.map((p) => p.id)),
+      );
+    });
+
+    test("returns different results for different CoValue IDs", () => {
+      const allPeers = Array.from(
+        { length: 6 },
+        (_, i) => new PeerState(createMockPeer(`peer_${i + 1}`), undefined),
+      );
+
+      const selector = hwrServerPeerSelector(5);
+
+      // Call the selector with different CoValue IDs
+      const result1 = selector("co_ztest123", allPeers);
+      const result2 = selector("co_ztest456", allPeers);
+      const result3 = selector("co_ztest789", allPeers);
+
+      expect(result1.length).toBe(5);
+      expect(result2.length).toBe(5);
+      expect(result3.length).toBe(5);
+
+      // Results should all be in different orders
+      expect(result1).not.toEqual(result2);
+      expect(result1).not.toEqual(result3);
+      expect(result2).not.toEqual(result3);
+    });
+
+    test("with n=0 throws an error", () => {
+      expect(() => hwrServerPeerSelector(0)).toThrow(
+        "n must be greater than 0",
+      );
+    });
+  });
 });

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

@@ -20,6 +20,7 @@ import {
   waitFor,
 } from "./testUtils";
 import { stableStringify } from "../jsonStringify";
+import { determineValidTransactions } from "../permissions";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -151,6 +152,47 @@ describe("client with storage syncs with server", () => {
     `);
   });
 
+  test("persists meta information", async () => {
+    const client = setupTestNode();
+
+    const { storage } = client.addStorage();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.core.makeTransaction([], "trusting", {
+      meta: true,
+    });
+
+    await map.core.waitForSync();
+
+    client.restart();
+
+    client.addStorage({
+      storage,
+    });
+
+    const loadedValue = await loadCoValueOrFail(client.node, map.id);
+
+    const validTransactions = determineValidTransactions(loadedValue.core);
+
+    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+  });
+
   test("updating a coValue while offline", async () => {
     const client = setupTestNode();
 
@@ -164,7 +206,7 @@ describe("client with storage syncs with server", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
-    client.node.syncManager.getPeers()[0]?.gracefulShutdown();
+    client.node.syncManager.getPeers(map.id)[0]?.gracefulShutdown();
 
     SyncMessagesLog.clear();
     map.set("hello", "updated", "trusting");

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

@@ -156,7 +156,7 @@ describe("client with storage syncs with server", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
-    client.node.syncManager.getPeers()[0]?.gracefulShutdown();
+    client.node.syncManager.getPeers(map.id)[0]?.gracefulShutdown();
 
     SyncMessagesLog.clear();
     map.set("hello", "updated", "trusting");

package/src/tests/sync.test.ts

@@ -599,8 +599,12 @@ describe("SyncManager - knownStates vs optimisticKnownStates", () => {
     // Wait for the full sync to complete
     await mapOnClient.core.waitForSync();
 
-    const peerStateClient = client.syncManager.getPeers()[0]!;
-    const peerStateJazzCloud = jazzCloud.node.syncManager.getPeers()[0]!;
+    const peerStateClient = client.syncManager.getPeers(
+      mapOnClient.core.id,
+    )[0]!;
+    const peerStateJazzCloud = jazzCloud.node.syncManager.getPeers(
+      mapOnClient.core.id,
+    )[0]!;
 
     // The optimisticKnownStates should be the same as the knownStates after the full sync is complete
     expect(

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

@@ -9,6 +9,7 @@ import {
   setupTestNode,
   waitFor,
 } from "./testUtils";
+import { determineValidTransactions } from "../permissions";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -51,6 +52,40 @@ describe("client to server upload", () => {
     `);
   });
 
+  test("syncs meta information", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.core.makeTransaction([], "trusting", {
+      meta: true,
+    });
+
+    await map.core.waitForSync();
+
+    const loadedValue = await loadCoValueOrFail(jazzCloud.node, map.id);
+
+    const validTransactions = determineValidTransactions(loadedValue.core);
+
+    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
   test("coValue with parent groups uploading", async () => {
     const client = setupTestNode({
       connected: true,

package/src/tests/testUtils.ts

@@ -669,9 +669,11 @@ export async function setupTestAccount(
     addStorage,
     addAsyncStorage,
     disconnect: () => {
-      ctx.node.syncManager.getPeers().forEach((peer) => {
+      const allPeers = ctx.node.syncManager.getPeers(ctx.accountID);
+      allPeers.forEach((peer) => {
         peer.gracefulShutdown();
       });
+      ctx.node.syncManager.peers = {};
     },
   };
 }