cojson 0.19.4 → 0.19.6

package/src/crypto/PureJSCrypto.ts

@@ -29,7 +29,11 @@ import {
 } from "./crypto.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
 
-type Blake3State = ReturnType<typeof blake3.create>;
+export type Blake3State = {
+  update: (buf: Uint8Array) => Blake3State;
+  digest: () => Uint8Array;
+  clone: () => Blake3State;
+};
 
 const x25519SharedSecretCache = new Map<string, Uint8Array>();
 
@@ -67,6 +71,10 @@ export class PureJSCrypto extends CryptoProvider<Blake3State> {
     return new PureJSCrypto();
   }
 
+  createStreamingHash(): Blake3State {
+    return blake3.create({});
+  }
+
   blake3HashOnce(data: Uint8Array) {
     return blake3(data);
   }
@@ -75,7 +83,7 @@ export class PureJSCrypto extends CryptoProvider<Blake3State> {
     data: Uint8Array,
     { context }: { context: Uint8Array },
   ) {
-    return blake3.create({}).update(context).update(data).digest();
+    return this.createStreamingHash().update(context).update(data).digest();
   }
 
   generateNonce(input: Uint8Array): Uint8Array {
@@ -224,7 +232,7 @@ export class PureJSSessionLog implements SessionLogImpl {
     private readonly signerID: SignerID | undefined,
     private readonly crypto: PureJSCrypto,
   ) {
-    this.streamingHash = blake3.create({});
+    this.streamingHash = crypto.createStreamingHash();
   }
 
   clone(): SessionLogImpl {
@@ -271,7 +279,7 @@ export class PureJSSessionLog implements SessionLogImpl {
 
       if (!this.crypto.verify(newSignature, newHashEncoded, this.signerID)) {
         // Rebuild the streaming hash to the original state
-        this.streamingHash = blake3.create({});
+        this.streamingHash = this.crypto.createStreamingHash();
         for (const tx of this.transactions) {
           this.streamingHash.update(textEncoder.encode(tx));
         }

package/src/tests/account.test.ts

@@ -1,12 +1,17 @@
-import { expect, test } from "vitest";
+import { beforeEach, expect, test } from "vitest";
 import { expectAccount } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
 import { createAsyncStorage } from "./testStorage.js";
+import { setupTestAccount, setupTestNode } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
+beforeEach(async () => {
+  await setupTestNode({ isSyncServer: true });
+});
+
 test("Can create a node while creating a new account with profile", async () => {
   const { node, accountID, accountSecret, sessionID } =
     await LocalNode.withNewlyCreatedAccount({
@@ -75,66 +80,42 @@ test("Can create account with one node, and then load it on another", async () =
 });
 
 test("Should migrate the root from private to trusting", async () => {
-  const { node, accountID, accountSecret } =
-    await LocalNode.withNewlyCreatedAccount({
-      creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
-    });
+  const session1 = await setupTestAccount({ connected: true });
 
-  const group = await node.createGroup();
+  const group = session1.node.createGroup();
   expect(group).not.toBeNull();
 
   const map = group.createMap();
   map.set("foo", "bar", "private");
   expect(map.get("foo")).toEqual("bar");
 
-  const peers1 = connectedPeers("node1", "node2", {
-    peer1role: "server",
-    peer2role: "client",
-  });
-
-  const account = await node.load(accountID);
+  const account = await session1.node.load(session1.accountID);
   if (account === "unavailable") throw new Error("Account unavailable");
 
   account.set("root", map.id, "private");
 
-  node.syncManager.addPeer(peers1[1]);
+  // Waiting to ensure that the migration is always applied on a different timestamp
+  // to make the test more stable
+  await new Promise((resolve) => setTimeout(resolve, 4));
 
-  const node2 = await LocalNode.withLoadedAccount({
-    accountID,
-    accountSecret,
-    sessionID: Crypto.newRandomSessionID(accountID),
-    peers: [peers1[0]],
-    crypto: Crypto,
-  });
+  const session2 = await session1.spawnNewSession();
 
-  const account2 = await node2.load(accountID);
-  if (account2 === "unavailable") throw new Error("Account unavailable");
+  const accountInNewSession = await session2.node.load(session1.accountID);
+  if (accountInNewSession === "unavailable")
+    throw new Error("Account unavailable");
 
-  expect(account2.getRaw("root")?.trusting).toEqual(true);
-
-  node2.gracefulShutdown(); // Stop getting updates from node1
-
-  const peers2 = connectedPeers("node2", "node3", {
-    peer1role: "server",
-    peer2role: "client",
-  });
+  expect(accountInNewSession.getRaw("root")?.trusting).toEqual(true);
 
-  node.syncManager.addPeer(peers2[1]);
+  await accountInNewSession.core.waitForSync();
 
-  const node3 = await LocalNode.withLoadedAccount({
-    accountID,
-    accountSecret,
-    sessionID: Crypto.newRandomSessionID(accountID),
-    peers: [peers2[0]],
-    crypto: Crypto,
-  });
+  const session3 = await session2.spawnNewSession();
 
-  const account3 = await node3.load(accountID);
-  if (account3 === "unavailable") throw new Error("Account unavailable");
+  const accountInNewSession2 = await session3.node.load(session1.accountID);
+  if (accountInNewSession2 === "unavailable")
+    throw new Error("Account unavailable");
 
-  expect(account3.getRaw("root")?.trusting).toEqual(true);
-  expect(account3.ops).toEqual(account2.ops); // No new transactions were made
+  expect(accountInNewSession2.getRaw("root")?.trusting).toEqual(true);
+  expect(accountInNewSession2.ops).toEqual(accountInNewSession.ops); // No new transactions were made
 });
 
 test("myRole returns 'admin' for the current account", async () => {

package/src/tests/group.parentGroupCache.test.ts

@@ -0,0 +1,293 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import {
+  setupTestAccount,
+  setupTestNode,
+  hotSleep,
+  loadCoValueOrFail,
+} from "./testUtils";
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+beforeEach(async () => {
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("Parent Group Cache", () => {
+  describe("Property 1: Parent group cache update correctness", () => {
+    test("cache contains correct entries after processing parent group reference transactions", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      // Initially no parent groups
+      expect(childGroup.getParentGroups()).toEqual([]);
+
+      // Extend parent group
+      childGroup.extend(parentGroup);
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+
+    test("cache handles multiple updates to same parent group", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      childGroup.extend(parentGroup);
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+
+      // Revoke and re-extend
+      childGroup.revokeExtend(parentGroup);
+      expect(childGroup.getParentGroups()).toEqual([]);
+
+      childGroup.extend(parentGroup, "admin");
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+
+    test("cache correctly handles empty state (no parent groups)", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const group = account.node.createGroup();
+
+      expect(group.getParentGroups()).toEqual([]);
+    });
+
+    test("cache only contains parent groups that have reference transactions", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup1 = account.node.createGroup();
+      const parentGroup2 = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      // Only extend one parent group
+      childGroup.extend(parentGroup1);
+
+      const parentGroups = childGroup.getParentGroups();
+      expect(parentGroups).toHaveLength(1);
+      expect(parentGroups[0]?.id).toEqual(parentGroup1.id);
+    });
+
+    test("cache handles multiple parent groups", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup1 = account.node.createGroup();
+      const parentGroup2 = account.node.createGroup();
+      const parentGroup3 = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      childGroup.extend(parentGroup1);
+      childGroup.extend(parentGroup2);
+      childGroup.extend(parentGroup3);
+
+      const parentGroups = childGroup.getParentGroups();
+      expect(parentGroups).toHaveLength(3);
+      expect(parentGroups.map((g) => g.id).sort()).toEqual(
+        [parentGroup1.id, parentGroup2.id, parentGroup3.id].sort(),
+      );
+    });
+  });
+
+  describe("Property 2: Parent group cache chronological ordering", () => {
+    test("multiple parent group changes are stored in chronological order", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      const t1 = hotSleep(10);
+      childGroup.extend(parentGroup, "reader");
+      const t2 = hotSleep(10);
+      childGroup.extend(parentGroup, "writer");
+      const t3 = hotSleep(10);
+      childGroup.extend(parentGroup, "admin");
+
+      // Check time travel queries return correct historical states
+      expect(childGroup.atTime(t1).getParentGroups()).toEqual([]);
+      expect(childGroup.atTime(t2).getParentGroups()).toEqual([
+        parentGroup.atTime(t2),
+      ]);
+      expect(childGroup.atTime(t3).getParentGroups()).toEqual([
+        parentGroup.atTime(t3),
+      ]);
+
+      // Current state should have admin role
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+
+    test("out-of-order transaction processing maintains chronological order", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      // Create transactions with different timestamps
+      const t1 = hotSleep(10);
+      const t2 = hotSleep(10);
+
+      childGroup.core.makeTransaction(
+        [
+          {
+            op: "set",
+            key: `parent_${parentGroup.id}`,
+            value: "revoked",
+          },
+        ],
+        "private",
+        undefined,
+        t2,
+      );
+
+      childGroup.core.makeTransaction(
+        [
+          {
+            op: "set",
+            key: `parent_${parentGroup.id}`,
+            value: "extend",
+          },
+        ],
+        "private",
+        undefined,
+        t1,
+      );
+      // Verify chronological ordering through time travel
+      const groupAtT1 = childGroup.atTime(t1);
+      const groupAtT2 = childGroup.atTime(t2);
+
+      expect(groupAtT1.getParentGroups()).toEqual([parentGroup.atTime(t1)]);
+      expect(groupAtT2.getParentGroups()).toEqual([]);
+    });
+
+    test("chronological ordering after rebuild", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      const t1 = hotSleep(10);
+      childGroup.extend(parentGroup, "reader");
+      const t2 = hotSleep(10);
+      childGroup.extend(parentGroup, "writer");
+
+      // Rebuild should maintain chronological order
+      childGroup.rebuildFromCore();
+
+      const groupAtT1 = childGroup.atTime(t1);
+      const groupAtT2 = childGroup.atTime(t2);
+
+      expect(groupAtT1.getParentGroups()).toEqual([]);
+      expect(groupAtT2.getParentGroups()).toEqual([parentGroup.atTime(t2)]);
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+  });
+
+  describe("Property 3: Rebuild round-trip", () => {
+    test("cache is cleared after rebuildFromCore", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      childGroup.extend(parentGroup);
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+
+      // Rebuild should clear cache and rebuild it
+      childGroup.rebuildFromCore();
+
+      // Cache should be rebuilt and still work
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+
+    test("cache is rebuilt correctly after clear", async () => {
+      const account = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup1 = account.node.createGroup();
+      const parentGroup2 = account.node.createGroup();
+      const childGroup = account.node.createGroup();
+
+      childGroup.extend(parentGroup1);
+      childGroup.extend(parentGroup2);
+
+      expect(childGroup.getParentGroups()).toHaveLength(2);
+
+      // Rebuild
+      childGroup.rebuildFromCore();
+
+      // Cache should be rebuilt with all parent groups
+      const parentGroups = childGroup.getParentGroups();
+      expect(parentGroups).toHaveLength(2);
+      expect(parentGroups.map((g) => g.id).sort()).toEqual(
+        [parentGroup1.id, parentGroup2.id].sort(),
+      );
+    });
+
+    test("parent group lookups work correctly after rebuild", async () => {
+      const alice = await setupTestAccount({
+        connected: true,
+      });
+      const bob = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = alice.node.createGroup();
+      const childGroup = alice.node.createGroup();
+
+      parentGroup.addMember(
+        await loadCoValueOrFail(alice.node, bob.accountID),
+        "writer",
+      );
+
+      childGroup.extend(parentGroup);
+
+      // Check role inheritance before rebuild
+      expect(childGroup.roleOf(bob.accountID)).toEqual("writer");
+
+      // Rebuild
+      childGroup.rebuildFromCore();
+
+      // Role inheritance should still work after rebuild
+      expect(childGroup.roleOf(bob.accountID)).toEqual("writer");
+      expect(childGroup.getParentGroups()).toEqual([parentGroup]);
+    });
+
+    test("rebuild maintains chronological ordering", async () => {
+      const alice = await setupTestAccount({
+        connected: true,
+      });
+      const bob = await setupTestAccount({
+        connected: true,
+      });
+      const parentGroup = alice.node.createGroup();
+      const childGroup = alice.node.createGroup();
+
+      parentGroup.addMember(
+        await loadCoValueOrFail(alice.node, bob.accountID),
+        "writer",
+      );
+
+      const t1 = hotSleep(10);
+      childGroup.extend(parentGroup, "reader");
+      const t2 = hotSleep(10);
+      childGroup.extend(parentGroup, "writer");
+
+      // Rebuild
+      childGroup.rebuildFromCore();
+
+      // Chronological ordering should be maintained
+      expect(childGroup.atTime(t1).roleOf(bob.accountID)).toEqual(undefined);
+      expect(childGroup.atTime(t2).roleOf(bob.accountID)).toEqual("reader");
+      expect(childGroup.atTime(Date.now()).roleOf(bob.accountID)).toEqual(
+        "writer",
+      );
+    });
+  });
+});