cojson 0.17.12 → 0.17.13

package/src/tests/PureJSCrypto.test.ts

@@ -126,6 +126,72 @@ describe("PureJSCrypto", () => {
 
     expect(map.get("count")).toEqual(0);
   });
+
+  it("can add a meta to a private transaction", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.core.makeTransaction([], "private", {
+      meta: {
+        count: 1,
+      },
+    });
+
+    await map.core.waitForSync();
+
+    const session2 = client.spawnNewSession();
+
+    const mapInOtherSession = await loadCoValueOrFail(session2.node, map.id);
+
+    const decryptedMeta =
+      mapInOtherSession.core.verified.decryptTransactionMeta(
+        client.node.currentSessionID,
+        0,
+        map.core.getCurrentReadKey().secret!,
+      );
+
+    expect(decryptedMeta).toEqual({
+      meta: {
+        count: 1,
+      },
+    });
+  });
+
+  it("can add a meta to a trusting transaction", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.core.makeTransaction([], "trusting", {
+      meta: {
+        count: 1,
+      },
+    });
+
+    await map.core.waitForSync();
+
+    const session2 = client.spawnNewSession();
+
+    const mapInOtherSession = await loadCoValueOrFail(session2.node, map.id);
+
+    const transferredMeta = JSON.parse(
+      mapInOtherSession.core.verified.sessions.get(client.node.currentSessionID)
+        ?.transactions[0]?.meta!,
+    );
+
+    expect(transferredMeta).toEqual({
+      meta: {
+        count: 1,
+      },
+    });
+  });
 });
 
 describe("PureJSSessionLog", () => {

package/src/tests/WasmCrypto.test.ts

@@ -125,4 +125,92 @@ describe("WasmCrypto", () => {
 
     expect(map.get("count")).toEqual(0);
   });
+
+  it("can add a meta to a private transaction", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.core.makeTransaction([], "private", {
+      meta: {
+        count: 1,
+      },
+    });
+
+    await map.core.waitForSync();
+
+    const session2 = client.spawnNewSession();
+
+    const mapInOtherSession = await loadCoValueOrFail(session2.node, map.id);
+
+    const decryptedMeta =
+      mapInOtherSession.core.verified.decryptTransactionMeta(
+        client.node.currentSessionID,
+        0,
+        mapInOtherSession.core.getCurrentReadKey().secret!,
+      );
+
+    expect(decryptedMeta).toEqual({
+      meta: {
+        count: 1,
+      },
+    });
+  });
+
+  it("can add a meta to a trusting transaction", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.core.makeTransaction([], "trusting", {
+      meta: {
+        count: 1,
+      },
+    });
+
+    await map.core.waitForSync();
+
+    const session2 = client.spawnNewSession();
+
+    const mapInOtherSession = await loadCoValueOrFail(session2.node, map.id);
+
+    const transferredMeta = JSON.parse(
+      mapInOtherSession.core.verified.sessions.get(client.node.currentSessionID)
+        ?.transactions[0]?.meta!,
+    );
+
+    expect(transferredMeta).toEqual({
+      meta: {
+        count: 1,
+      },
+    });
+  });
+
+  it("fails to verify signatures without a signer ID", async () => {
+    const agentSecret = wasmCrypto.newRandomAgentSecret();
+    const sessionID = wasmCrypto.newRandomSessionID(
+      wasmCrypto.getAgentID(agentSecret),
+    );
+
+    const sessionLog = wasmCrypto.createSessionLog("co_z12345678", sessionID);
+    expect(() =>
+      sessionLog.tryAdd(
+        [
+          {
+            privacy: "trusting",
+            changes: stableStringify([{ op: "set", key: "count", value: 1 }]),
+            madeAt: Date.now(),
+          },
+        ],
+        "signature_z12345678",
+        false,
+      ),
+    ).toThrow(expect.stringContaining("Signature verification failed"));
+  });
 });

package/src/tests/coList.test.ts

@@ -409,3 +409,22 @@ test("totalValidTransactions should return the number of valid transactions proc
     listOnOtherClient.core.getCurrentContent().totalValidTransactions,
   ).toEqual(2);
 });
+
+test("Should ignore unknown meta transactions", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  coValue.makeTransaction([], "trusting", { unknownMeta: 1 });
+
+  const content = expectList(coValue.getCurrentContent());
+
+  content.append("first", 0, "trusting");
+
+  expect(content.toJSON()).toEqual(["first"]);
+});

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

@@ -4,6 +4,7 @@ import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
   blockMessageTypeOnOutgoingPeer,
+  connectedPeersWithMessagesTracking,
   getSyncServerConnectedPeer,
   loadCoValueOrFail,
   setupTestAccount,
@@ -47,7 +48,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 +73,47 @@ 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
+    );
+  });
 });

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 = {};
     },
   };
 }