cojson 0.7.0-alpha.7 → 0.7.0

package/src/sync.ts

@@ -1,4 +1,4 @@
-import { Signature } from "./crypto.js";
+import { Signature } from "./crypto/crypto.js";
 import { CoValueHeader, Transaction } from "./coValueCore.js";
 import { CoValueCore } from "./coValueCore.js";
 import { LocalNode } from "./localNode.js";
@@ -82,7 +82,7 @@ export interface PeerState {
 
 export function combinedKnownStates(
     stateA: CoValueKnownState,
-    stateB: CoValueKnownState
+    stateB: CoValueKnownState,
 ): CoValueKnownState {
     const sessionStates: CoValueKnownState["sessions"] = {};
 
@@ -108,7 +108,11 @@ export function combinedKnownStates(
 export class SyncManager {
     peers: { [key: PeerID]: PeerState } = {};
     local: LocalNode;
-    requestedSyncs: { [id: RawCoID]: {done: Promise<void>, nRequestsThisTick: number} | undefined } = {};
+    requestedSyncs: {
+        [id: RawCoID]:
+            | { done: Promise<void>; nRequestsThisTick: number }
+            | undefined;
+    } = {};
 
     constructor(local: LocalNode) {
         this.local = local;
@@ -151,31 +155,31 @@ export class SyncManager {
                 throw new Error("Expected firstPeerState to be waiting " + id);
             }
             await new Promise<void>((resolve) => {
-                const timeout = setTimeout(() => {
-                    if (this.local.coValues[id]?.state === "loading") {
-                        // console.warn(
-                        //     "Timeout waiting for peer to load",
-                        //     id,
-                        //     "from",
-                        //     peer.id,
-                        //     "and it hasn't loaded from other peers yet"
-                        // );
-                    }
-                    resolve();
-                }, 1000);
+                // const timeout = setTimeout(() => {
+                //     if (this.local.coValues[id]?.state === "loading") {
+                //         console.warn(
+                //             "Timeout waiting for peer to load",
+                //             id,
+                //             "from",
+                //             peer.id,
+                //             "and it hasn't loaded from other peers yet"
+                //         );
+                //     }
+                //     resolve();
+                // }, 1000);
                 firstStateEntry.done
                     .then(() => {
-                        clearTimeout(timeout);
+                        // clearTimeout(timeout);
                         resolve();
                     })
                     .catch((e) => {
-                        clearTimeout(timeout);
+                        // clearTimeout(timeout);
                         console.error(
                             "Error waiting for peer to load",
                             id,
                             "from",
                             peer.id,
-                            e
+                            e,
                         );
                         resolve();
                     });
@@ -203,7 +207,7 @@ export class SyncManager {
                 throw new Error(
                     `Unknown message type ${
                         (msg as { action: "string" }).action
-                    }`
+                    }`,
                 );
         }
     }
@@ -243,15 +247,21 @@ export class SyncManager {
     async tellUntoldKnownStateIncludingDependencies(
         id: RawCoID,
         peer: PeerState,
-        asDependencyOf?: RawCoID
+        asDependencyOf?: RawCoID,
     ) {
         const coValue = this.local.expectCoValueLoaded(id);
 
-        await Promise.all(coValue.getDependedOnCoValues().map(dependentCoID => this.tellUntoldKnownStateIncludingDependencies(
-            dependentCoID,
-            peer,
-            asDependencyOf || id
-        )));
+        await Promise.all(
+            coValue
+                .getDependedOnCoValues()
+                .map((dependentCoID) =>
+                    this.tellUntoldKnownStateIncludingDependencies(
+                        dependentCoID,
+                        peer,
+                        asDependencyOf || id,
+                    ),
+                ),
+        );
 
         if (!peer.toldKnownState.has(id)) {
             await this.trySendToPeer(peer, {
@@ -267,10 +277,16 @@ export class SyncManager {
     async sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
         const coValue = this.local.expectCoValueLoaded(id);
 
-        await Promise.all(coValue.getDependedOnCoValues().map(id => this.sendNewContentIncludingDependencies(id, peer)));
+        await Promise.all(
+            coValue
+                .getDependedOnCoValues()
+                .map((id) =>
+                    this.sendNewContentIncludingDependencies(id, peer),
+                ),
+        );
 
         const newContentPieces = coValue.newContentSince(
-            peer.optimisticKnownStates[id]
+            peer.optimisticKnownStates[id],
         );
 
         if (newContentPieces) {
@@ -302,7 +318,7 @@ export class SyncManager {
 
             peer.optimisticKnownStates[id] = combinedKnownStates(
                 optimisticKnownStateBefore,
-                coValue.knownState()
+                coValue.knownState(),
             );
         }
     }
@@ -323,7 +339,7 @@ export class SyncManager {
         if (peer.role === "server") {
             const initialSync = async () => {
                 for (const id of Object.keys(
-                    this.local.coValues
+                    this.local.coValues,
                 ) as RawCoID[]) {
                     // console.log("subscribing to after peer added", id, peer.id)
                     await this.subscribeToIncludingDependencies(id, peerState);
@@ -350,9 +366,9 @@ export class SyncManager {
                                 JSON.stringify(msg, (k, v) =>
                                     k === "changes" || k === "encryptedChanges"
                                         ? v.slice(0, 20) + "..."
-                                        : v
+                                        : v,
                                 ),
-                                e
+                                e,
                             );
                         });
                         // await new Promise<void>((resolve) => {
@@ -365,9 +381,9 @@ export class SyncManager {
                             JSON.stringify(msg, (k, v) =>
                                 k === "changes" || k === "encryptedChanges"
                                     ? v.slice(0, 20) + "..."
-                                    : v
+                                    : v,
                             ),
-                            e
+                            e,
                         );
                         if (peerState.delayOnError) {
                             await new Promise<void>((resolve) => {
@@ -417,8 +433,8 @@ export class SyncManager {
                             `Error writing to peer ${peer.id}, disconnecting`,
                             {
                                 cause: e,
-                            }
-                        )
+                            },
+                        ),
                     );
                     delete this.peers[peer.id];
                 });
@@ -470,7 +486,7 @@ export class SyncManager {
 
         peer.optimisticKnownStates[msg.id] = combinedKnownStates(
             peer.optimisticKnownStates[msg.id] || emptyKnownState(msg.id),
-            knownStateIn(msg)
+            knownStateIn(msg),
         );
 
         if (!entry) {
@@ -481,18 +497,18 @@ export class SyncManager {
                         .catch((e) => {
                             console.error(
                                 `Error loading coValue ${msg.id} to create loading state, as dependency of ${msg.asDependencyOf}`,
-                                e
+                                e,
                             );
                         });
                     entry = this.local.coValues[msg.id]!; // must exist after loadCoValueCore
                 } else {
                     throw new Error(
-                        "Expected coValue dependency entry to be created, missing subscribe?"
+                        "Expected coValue dependency entry to be created, missing subscribe?",
                     );
                 }
             } else {
                 throw new Error(
-                    "Expected coValue entry to be created, missing subscribe?"
+                    "Expected coValue entry to be created, missing subscribe?",
                 );
             }
         }
@@ -516,7 +532,7 @@ export class SyncManager {
             // );
             if (
                 Object.values(entry.firstPeerState).every(
-                    (s) => s.type === "unavailable"
+                    (s) => s.type === "unavailable",
                 )
             ) {
                 entry.resolve("unavailable");
@@ -533,7 +549,7 @@ export class SyncManager {
 
         if (!entry) {
             throw new Error(
-                "Expected coValue entry to be created, missing subscribe?"
+                "Expected coValue entry to be created, missing subscribe?",
             );
         }
 
@@ -543,7 +559,7 @@ export class SyncManager {
 
         if (!peerOptimisticKnownState) {
             throw new Error(
-                "Expected optimisticKnownState to be set for coValue we receive new content for"
+                "Expected optimisticKnownState to be set for coValue we receive new content for",
             );
         }
 
@@ -578,7 +594,7 @@ export class SyncManager {
         let invalidStateAssumed = false;
 
         for (const [sessionID, newContentForSession] of Object.entries(
-            msg.new
+            msg.new,
         ) as [SessionID, SessionNewContent][]) {
             const ourKnownTxIdx =
                 coValue.sessionLogs.get(sessionID)?.transactions.length;
@@ -605,7 +621,7 @@ export class SyncManager {
                 sessionID,
                 newTransactions,
                 undefined,
-                newContentForSession.lastSignature
+                newContentForSession.lastSignature,
             );
             const after = performance.now();
             if (after - before > 80) {
@@ -613,7 +629,7 @@ export class SyncManager {
                     .map((t) =>
                         t.privacy === "private"
                             ? t.encryptedChanges.length
-                            : t.changes.length
+                            : t.changes.length,
                     )
                     .reduce((a, b) => a + b, 0);
                 console.log(
@@ -623,16 +639,16 @@ export class SyncManager {
                         (1000 * totalTxLength) /
                         (after - before) /
                         (1024 * 1024)
-                    ).toFixed(2)} MB/s`
+                    ).toFixed(2)} MB/s`,
                 );
             }
 
             const theirTotalnTxs = Object.values(
-                peer.optimisticKnownStates[msg.id]?.sessions || {}
+                peer.optimisticKnownStates[msg.id]?.sessions || {},
             ).reduce((sum, nTxs) => sum + nTxs, 0);
             const ourTotalnTxs = [...coValue.sessionLogs.values()].reduce(
                 (sum, session) => sum + session.transactions.length,
-                0
+                0,
             );
 
             entry.onProgress?.(ourTotalnTxs / theirTotalnTxs);
@@ -644,8 +660,8 @@ export class SyncManager {
                     JSON.stringify(newTransactions, (k, v) =>
                         k === "changes" || k === "encryptedChanges"
                             ? v.slice(0, 20) + "..."
-                            : v
-                    )
+                            : v,
+                    ),
                 );
                 continue;
             }
@@ -653,7 +669,7 @@ export class SyncManager {
             peerOptimisticKnownState.sessions[sessionID] = Math.max(
                 peerOptimisticKnownState.sessions[sessionID] || 0,
                 newContentForSession.after +
-                    newContentForSession.newTransactions.length
+                    newContentForSession.newTransactions.length,
             );
         }
 
@@ -688,14 +704,14 @@ export class SyncManager {
             return this.requestedSyncs[coValue.id]!.done;
         } else {
             const done = new Promise<void>((resolve) => {
-                setTimeout(async () => {
+                queueMicrotask(async () => {
                     delete this.requestedSyncs[coValue.id];
                     // if (entry.nRequestsThisTick >= 2) {
                     //     console.log("Syncing", coValue.id, "for", entry.nRequestsThisTick, "requests");
                     // }
                     await this.actuallySyncCoValue(coValue);
                     resolve();
-                }, 0);
+                });
             });
             const entry = {
                 done,
@@ -707,30 +723,30 @@ export class SyncManager {
     }
 
     async actuallySyncCoValue(coValue: CoValueCore) {
-        let blockingSince = performance.now();
+        // let blockingSince = performance.now();
         for (const peer of this.peersInPriorityOrder()) {
-            if (performance.now() - blockingSince > 5) {
-                await new Promise<void>((resolve) => {
-                    setTimeout(resolve, 0);
-                });
-                blockingSince = performance.now();
-            }
+            // if (performance.now() - blockingSince > 5) {
+            //     await new Promise<void>((resolve) => {
+            //         setTimeout(resolve, 0);
+            //     });
+            //     blockingSince = performance.now();
+            // }
             const optimisticKnownState = peer.optimisticKnownStates[coValue.id];
 
             if (optimisticKnownState) {
                 await this.tellUntoldKnownStateIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
                 await this.sendNewContentIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
             } else if (peer.role === "server") {
                 await this.subscribeToIncludingDependencies(coValue.id, peer);
                 await this.sendNewContentIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
             }
         }

package/src/tests/account.test.ts

@@ -1,22 +1,17 @@
-import { expect, test, beforeEach } from "vitest";
+import { expect, test } from "vitest";
 import { newRandomSessionID } from "../coValueCore.js";
-import { cojsonReady } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
-import { webcrypto } from "node:crypto";
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
-
-beforeEach(async () => {
-    await cojsonReady;
-});
+const Crypto = await WasmCrypto.create();
 
 test("Can create a node while creating a new account with profile", async () => {
     const { node, accountID, accountSecret, sessionID } =
-        await LocalNode.withNewlyCreatedAccount({ name: "Hermes Puggington" });
+        await LocalNode.withNewlyCreatedAccount({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
 
     expect(node).not.toBeNull();
     expect(accountID).not.toBeNull();
@@ -24,13 +19,14 @@ test("Can create a node while creating a new account with profile", async () =>
     expect(sessionID).not.toBeNull();
 
     expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
-        "Hermes Puggington"
+        "Hermes Puggington",
     );
 });
 
 test("A node with an account can create groups and and objects within them", async () => {
     const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
     const group = await node.createGroup();
@@ -44,7 +40,10 @@ test("A node with an account can create groups and and objects within them", asy
 
 test("Can create account with one node, and then load it on another", async () => {
     const { node, accountID, accountSecret } =
-        await LocalNode.withNewlyCreatedAccount({ name: "Hermes Puggington" });
+        await LocalNode.withNewlyCreatedAccount({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
 
     const group = await node.createGroup();
     expect(group).not.toBeNull();
@@ -66,6 +65,7 @@ test("Can create account with one node, and then load it on another", async () =
         accountSecret,
         sessionID: newRandomSessionID(accountID),
         peersToLoadFrom: [node1asPeer],
+        crypto: Crypto,
     });
 
     const map2 = await node2.load(map.id);

package/src/tests/coList.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "vitest";
+import { expectList } from "../coValue.js";
+import { WasmCrypto } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+
+const Crypto = await WasmCrypto.create();
+
+test("Empty CoList works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectList(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("colist");
+    expect(content.toJSON()).toEqual([]);
+});
+
+test("Can append, prepend, delete and replace items in CoList", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectList(coValue.getCurrentContent());
+
+    content.append("hello", 0, "trusting");
+    expect(content.toJSON()).toEqual(["hello"]);
+    content.append("world", 0, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "world"]);
+    content.prepend("beautiful", 1, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "beautiful", "world"]);
+    content.prepend("hooray", 3, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
+    content.replace(2, "universe", "trusting");
+    expect(content.toJSON()).toEqual([
+        "hello",
+        "beautiful",
+        "universe",
+        "hooray",
+    ]);
+    content.delete(2, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
+});
+
+test("Push is equivalent to append after last item", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectList(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("colist");
+
+    content.append("hello", 0, "trusting");
+    expect(content.toJSON()).toEqual(["hello"]);
+    content.append("world", undefined, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "world"]);
+    content.append("hooray", undefined, "trusting");
+    expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
+});
+
+test("Can push into empty list", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectList(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("colist");
+
+    content.append("hello", undefined, "trusting");
+    expect(content.toJSON()).toEqual(["hello"]);
+});

package/src/tests/coMap.test.ts

@@ -0,0 +1,162 @@
+import { expect, test } from "vitest";
+import { expectMap } from "../coValue.js";
+import { WasmCrypto } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+
+const Crypto = await WasmCrypto.create();
+
+test("Empty CoMap works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+    expect([...content.keys()]).toEqual([]);
+    expect(content.toJSON()).toEqual({});
+});
+
+test("Can insert and delete CoMap entries in edit()", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    content.set("hello", "world", "trusting");
+    expect(content.get("hello")).toEqual("world");
+    content.set("foo", "bar", "trusting");
+    expect(content.get("foo")).toEqual("bar");
+    expect([...content.keys()]).toEqual(["hello", "foo"]);
+    content.delete("foo", "trusting");
+    expect(content.get("foo")).toEqual(undefined);
+    expect(content.keys()).toEqual(["hello"]);
+});
+
+test("Can get CoMap entry values at different points in time", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    const beforeA = Date.now();
+    while (Date.now() < beforeA + 10) {
+        /* hot sleep */
+    }
+    content.set("hello", "A", "trusting");
+    const beforeB = Date.now();
+    while (Date.now() < beforeB + 10) {
+        /* hot sleep */
+    }
+    content.set("hello", "B", "trusting");
+    const beforeC = Date.now();
+    while (Date.now() < beforeC + 10) {
+        /* hot sleep */
+    }
+    content.set("hello", "C", "trusting");
+    expect(content.get("hello")).toEqual("C");
+    expect(content.atTime(Date.now()).get("hello")).toEqual("C");
+    expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
+    expect(content.atTime(beforeB).get("hello")).toEqual("A");
+    expect(content.atTime(beforeC).get("hello")).toEqual("B");
+});
+
+test("Can get all historic values of key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    content.set("hello", "A", "trusting");
+    const editA = content.lastEditAt("hello");
+    content.set("hello", "B", "trusting");
+    const editB = content.lastEditAt("hello");
+    content.delete("hello", "trusting");
+    const editDel = content.lastEditAt("hello");
+    content.set("hello", "C", "trusting");
+    const editC = content.lastEditAt("hello");
+    expect([...content.editsAt("hello")]).toEqual([
+        {
+            tx: editA!.tx,
+            by: node.account.id,
+            value: "A",
+            at: editA?.at,
+        },
+        {
+            tx: editB!.tx,
+            by: node.account.id,
+            value: "B",
+            at: editB?.at,
+        },
+        {
+            tx: editDel!.tx,
+            by: node.account.id,
+            value: undefined,
+            at: editDel?.at,
+        },
+        {
+            tx: editC!.tx,
+            by: node.account.id,
+            value: "C",
+            at: editC?.at,
+        },
+    ]);
+});
+
+test("Can get last tx ID for a key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    expect(content.lastEditAt("hello")).toEqual(undefined);
+    content.set("hello", "A", "trusting");
+    const sessionID = content.lastEditAt("hello")?.tx.sessionID;
+    expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+        node.account.id,
+    );
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
+    content.set("hello", "B", "trusting");
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
+    content.set("hello", "C", "trusting");
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
+});