cojson 0.6.7 → 0.7.0-alpha.1

package/src/tests/coValue.test.ts

@@ -1,11 +1,18 @@
+import { expect, test, beforeEach } from "vitest";
 import { expectList, expectMap, expectStream } from "../coValue.js";
-import { BinaryCoStream } from "../coValues/coStream.js";
+import { RawBinaryCoStream } from "../coValues/coStream.js";
 import { createdNowUnique } from "../crypto.js";
 import { MAX_RECOMMENDED_TX_SIZE, cojsonReady } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.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;
 });
@@ -41,15 +48,13 @@ test("Can insert and delete CoMap entries in edit()", () => {
 
     expect(content.type).toEqual("comap");
 
-    content.edit((editable) => {
-        editable.set("hello", "world", "trusting");
-        expect(editable.get("hello")).toEqual("world");
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-        expect([...editable.keys()]).toEqual(["hello", "foo"]);
-        editable.delete("foo", "trusting");
-        expect(editable.get("foo")).toEqual(undefined);
-    });
+    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);
 });
 
 test("Can get CoMap entry values at different points in time", () => {
@@ -66,22 +71,20 @@ test("Can get CoMap entry values at different points in time", () => {
 
     expect(content.type).toEqual("comap");
 
-    content.edit((editable) => {
-        const beforeA = Date.now();
-        while (Date.now() < beforeA + 10) {}
-        editable.set("hello", "A", "trusting");
-        const beforeB = Date.now();
-        while (Date.now() < beforeB + 10) {}
-        editable.set("hello", "B", "trusting");
-        const beforeC = Date.now();
-        while (Date.now() < beforeC + 10) {}
-        editable.set("hello", "C", "trusting");
-        expect(editable.get("hello")).toEqual("C");
-        expect(editable.atTime(Date.now()).get("hello")).toEqual("C");
-        expect(editable.atTime(beforeA).get("hello")).toEqual(undefined);
-        expect(editable.atTime(beforeB).get("hello")).toEqual("A");
-        expect(editable.atTime(beforeC).get("hello")).toEqual("B");
-    });
+    const beforeA = Date.now();
+    while (Date.now() < beforeA + 10) {}
+    content.set("hello", "A", "trusting");
+    const beforeB = Date.now();
+    while (Date.now() < beforeB + 10) {}
+    content.set("hello", "B", "trusting");
+    const beforeC = Date.now();
+    while (Date.now() < beforeC + 10) {}
+    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", () => {
@@ -98,42 +101,40 @@ test("Can get all historic values of key in CoMap", () => {
 
     expect(content.type).toEqual("comap");
 
-    content.edit((editable) => {
-        editable.set("hello", "A", "trusting");
-        const editA = editable.lastEditAt("hello");
-        editable.set("hello", "B", "trusting");
-        const editB = editable.lastEditAt("hello");
-        editable.delete("hello", "trusting");
-        const editDel = editable.lastEditAt("hello");
-        editable.set("hello", "C", "trusting");
-        const editC = editable.lastEditAt("hello");
-        expect([...editable.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,
-            },
-        ]);
-    });
+    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", () => {
@@ -150,19 +151,17 @@ test("Can get last tx ID for a key in CoMap", () => {
 
     expect(content.type).toEqual("comap");
 
-    content.edit((editable) => {
-        expect(editable.lastEditAt("hello")).toEqual(undefined);
-        editable.set("hello", "A", "trusting");
-        const sessionID = editable.lastEditAt("hello")?.tx.sessionID;
-        expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-            node.account.id
-        );
-        expect(editable.lastEditAt("hello")?.tx.txIndex).toEqual(0);
-        editable.set("hello", "B", "trusting");
-        expect(editable.lastEditAt("hello")?.tx.txIndex).toEqual(1);
-        editable.set("hello", "C", "trusting");
-        expect(editable.lastEditAt("hello")?.tx.txIndex).toEqual(2);
-    });
+    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);
 });
 
 test("Empty CoList works", () => {
@@ -181,7 +180,7 @@ test("Empty CoList works", () => {
     expect(content.toJSON()).toEqual([]);
 });
 
-test("Can append, prepend and delete items to CoList", () => {
+test("Can append, prepend, delete and replace items in CoList", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -193,23 +192,18 @@ test("Can append, prepend and delete items to CoList", () => {
 
     const content = expectList(coValue.getCurrentContent());
 
-    content.edit((editable) => {
-        editable.append("hello", 0, "trusting");
-        expect(editable.toJSON()).toEqual(["hello"]);
-        editable.append("world", 0, "trusting");
-        expect(editable.toJSON()).toEqual(["hello", "world"]);
-        editable.prepend("beautiful", 1, "trusting");
-        expect(editable.toJSON()).toEqual(["hello", "beautiful", "world"]);
-        editable.prepend("hooray", 3, "trusting");
-        expect(editable.toJSON()).toEqual([
-            "hello",
-            "beautiful",
-            "world",
-            "hooray",
-        ]);
-        editable.delete(2, "trusting");
-        expect(editable.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
-    });
+    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", () => {
@@ -226,14 +220,12 @@ test("Push is equivalent to append after last item", () => {
 
     expect(content.type).toEqual("colist");
 
-    content.edit((editable) => {
-        editable.append("hello", 0, "trusting");
-        expect(editable.toJSON()).toEqual(["hello"]);
-        editable.append("world", undefined, "trusting");
-        expect(editable.toJSON()).toEqual(["hello", "world"]);
-        editable.append("hooray", undefined, "trusting");
-        expect(editable.toJSON()).toEqual(["hello", "world", "hooray"]);
-    });
+    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", () => {
@@ -250,10 +242,8 @@ test("Can push into empty list", () => {
 
     expect(content.type).toEqual("colist");
 
-    content.edit((editable) => {
-        editable.append("hello", undefined, "trusting");
-        expect(editable.toJSON()).toEqual(["hello"]);
-    });
+    content.append("hello", undefined, "trusting");
+    expect(content.toJSON()).toEqual(["hello"]);
 });
 
 test("Empty CoStream works", () => {
@@ -285,23 +275,21 @@ test("Can push into CoStream", () => {
 
     const content = expectStream(coValue.getCurrentContent());
 
-    content.edit((editable) => {
-        editable.push({ hello: "world" }, "trusting");
-        expect(editable.toJSON()).toEqual({
-            [node.currentSessionID]: [{ hello: "world" }],
-        });
-        editable.push({ foo: "bar" }, "trusting");
-        expect(editable.toJSON()).toEqual({
-            [node.currentSessionID]: [{ hello: "world" }, { foo: "bar" }],
-        });
-        expect(editable.getSingleStream()).toEqual([
-            { hello: "world" },
-            { foo: "bar" },
-        ]);
+    content.push({ hello: "world" }, "trusting");
+    expect(content.toJSON()).toEqual({
+        [node.currentSessionID]: [{ hello: "world" }],
+    });
+    content.push({ foo: "bar" }, "trusting");
+    expect(content.toJSON()).toEqual({
+        [node.currentSessionID]: [{ hello: "world" }, { foo: "bar" }],
     });
+    expect(content.getSingleStream()).toEqual([
+        { hello: "world" },
+        { foo: "bar" },
+    ]);
 });
 
-test("Empty BinaryCoStream works", () => {
+test("Empty RawBinaryCoStream works", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -316,7 +304,7 @@ test("Empty BinaryCoStream works", () => {
     if (
         content.type !== "costream" ||
         content.headerMeta?.type !== "binary" ||
-        !(content instanceof BinaryCoStream)
+        !(content instanceof RawBinaryCoStream)
     ) {
         throw new Error("Expected binary stream");
     }
@@ -327,7 +315,7 @@ test("Empty BinaryCoStream works", () => {
     expect(content.getBinaryChunks()).toEqual(undefined);
 });
 
-test("Can push into BinaryCoStream", () => {
+test("Can push into RawBinaryCoStream", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -342,45 +330,36 @@ test("Can push into BinaryCoStream", () => {
     if (
         content.type !== "costream" ||
         content.headerMeta?.type !== "binary" ||
-        !(content instanceof BinaryCoStream)
+        !(content instanceof RawBinaryCoStream)
     ) {
         throw new Error("Expected binary stream");
     }
 
-    content.edit((editable) => {
-        editable.startBinaryStream(
-            { mimeType: "text/plain", fileName: "test.txt" },
-            "trusting"
-        );
-        expect(editable.getBinaryChunks(true)).toEqual({
-            mimeType: "text/plain",
-            fileName: "test.txt",
-            chunks: [],
-            finished: false,
-        });
-        editable.pushBinaryStreamChunk(new Uint8Array([1, 2, 3]), "trusting");
-        expect(editable.getBinaryChunks(true)).toEqual({
-            mimeType: "text/plain",
-            fileName: "test.txt",
-            chunks: [new Uint8Array([1, 2, 3])],
-            finished: false,
-        });
-        editable.pushBinaryStreamChunk(new Uint8Array([4, 5, 6]), "trusting");
-
-        expect(editable.getBinaryChunks(true)).toEqual({
-            mimeType: "text/plain",
-            fileName: "test.txt",
-            chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
-            finished: false,
-        });
-
-        editable.endBinaryStream("trusting");
-        expect(editable.getBinaryChunks()).toEqual({
-            mimeType: "text/plain",
-            fileName: "test.txt",
-            chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
-            finished: true,
-        });
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting"
+    );
+    expect(content.getBinaryChunks(true)).toEqual({
+        mimeType: "text/plain",
+        fileName: "test.txt",
+        chunks: [],
+        finished: false,
+    });
+    content.pushBinaryStreamChunk(new Uint8Array([1, 2, 3]), "trusting");
+    expect(content.getBinaryChunks(true)).toEqual({
+        mimeType: "text/plain",
+        fileName: "test.txt",
+        chunks: [new Uint8Array([1, 2, 3])],
+        finished: false,
+    });
+    content.pushBinaryStreamChunk(new Uint8Array([4, 5, 6]), "trusting");
+
+    content.endBinaryStream("trusting");
+    expect(content.getBinaryChunks()).toEqual({
+        mimeType: "text/plain",
+        fileName: "test.txt",
+        chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
+        finished: true,
     });
 });
 
@@ -399,29 +378,23 @@ test("When adding large transactions (small fraction of MAX_RECOMMENDED_TX_SIZE)
     if (
         content.type !== "costream" ||
         content.headerMeta?.type !== "binary" ||
-        !(content instanceof BinaryCoStream)
+        !(content instanceof RawBinaryCoStream)
     ) {
         throw new Error("Expected binary stream");
     }
 
-    content.edit((editable) => {
-        editable.startBinaryStream(
-            { mimeType: "text/plain", fileName: "test.txt" },
-            "trusting"
-        );
-    });
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting"
+    );
 
     for (let i = 0; i < 10; i++) {
         const chunk = new Uint8Array(MAX_RECOMMENDED_TX_SIZE / 3 + 100);
 
-        content.edit((editable) => {
-            editable.pushBinaryStreamChunk(chunk, "trusting");
-        });
+        content.pushBinaryStreamChunk(chunk, "trusting");
     }
 
-    content.edit((editable) => {
-        editable.endBinaryStream("trusting");
-    });
+    content.endBinaryStream("trusting");
 
     const sessionEntry = coValue.sessionLogs.get(node.currentSessionID)!;
     expect(sessionEntry.transactions.length).toEqual(12);
@@ -475,29 +448,23 @@ test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we s
     if (
         content.type !== "costream" ||
         content.headerMeta?.type !== "binary" ||
-        !(content instanceof BinaryCoStream)
+        !(content instanceof RawBinaryCoStream)
     ) {
         throw new Error("Expected binary stream");
     }
 
-    content.edit((editable) => {
-        editable.startBinaryStream(
-            { mimeType: "text/plain", fileName: "test.txt" },
-            "trusting"
-        );
-    });
+    content.startBinaryStream(
+        { mimeType: "text/plain", fileName: "test.txt" },
+        "trusting"
+    );
 
     const chunk = new Uint8Array(MAX_RECOMMENDED_TX_SIZE + 100);
 
     for (let i = 0; i < 3; i++) {
-        content.edit((editable) => {
-            editable.pushBinaryStreamChunk(chunk, "trusting");
-        });
+        content.pushBinaryStreamChunk(chunk, "trusting");
     }
 
-    content.edit((editable) => {
-        editable.endBinaryStream("trusting");
-    });
+    content.endBinaryStream("trusting");
 
     const sessionEntry = coValue.sessionLogs.get(node.currentSessionID)!;
     expect(sessionEntry.transactions.length).toEqual(5);

package/src/tests/coValueCore.test.ts

@@ -1,3 +1,4 @@
+import { expect, test, beforeEach } from "vitest";
 import { Transaction } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { createdNowUnique, getAgentSignerSecret, newRandomAgentSecret, sign } from "../crypto.js";
@@ -7,6 +8,12 @@ import { Role } from "../permissions.js";
 import { cojsonReady } from "../index.js";
 import { stableStringify } from "../jsonStringify.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;
 });
@@ -142,9 +149,7 @@ test("New transactions in a group correctly update owned values, including subsc
 
     let map = group.createMap();
 
-    let mapAfterEdit = map.edit((map) => {
-        map.set("hello", "world");
-    });
+    map.set("hello", "world");
 
     const listener = jest.fn().mockImplementation();
 

package/src/tests/crypto.test.ts

@@ -1,3 +1,4 @@
+import { expect, test, beforeEach } from "vitest";
 import {
     getSealerID,
     getSignerID,
@@ -23,6 +24,12 @@ import stableStringify from "fast-json-stable-stringify";
 import { SessionID } from "../ids.js";
 import { cojsonReady } from "../index.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;
 });

package/src/tests/group.test.ts

@@ -1,11 +1,18 @@
-import { LocalNode, CoMap, CoList, CoStream, BinaryCoStream, cojsonReady } from "../index";
+import { expect, test, beforeEach } from "vitest";
+import { LocalNode, RawCoMap, RawCoList, RawCoStream, RawBinaryCoStream, cojsonReady } from "../index";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.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;
 });
 
-test("Can create a CoMap in a group", () => {
+test("Can create a RawCoMap in a group", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const group = node.createGroup();
@@ -13,7 +20,7 @@ test("Can create a CoMap in a group", () => {
     const map = group.createMap();
 
     expect(map.core.getCurrentContent().type).toEqual("comap");
-    expect(map instanceof CoMap).toEqual(true);
+    expect(map instanceof RawCoMap).toEqual(true);
 });
 
 test("Can create a CoList in a group", () => {
@@ -24,7 +31,7 @@ test("Can create a CoList in a group", () => {
     const list = group.createList();
 
     expect(list.core.getCurrentContent().type).toEqual("colist");
-    expect(list instanceof CoList).toEqual(true);
+    expect(list instanceof RawCoList).toEqual(true);
 })
 
 test("Can create a CoStream in a group", () => {
@@ -35,7 +42,7 @@ test("Can create a CoStream in a group", () => {
     const stream = group.createStream();
 
     expect(stream.core.getCurrentContent().type).toEqual("costream");
-    expect(stream instanceof CoStream).toEqual(true);
+    expect(stream instanceof RawCoStream).toEqual(true);
 });
 
 test("Can create a BinaryCoStream in a group", () => {
@@ -47,5 +54,5 @@ test("Can create a BinaryCoStream in a group", () => {
 
     expect(stream.core.getCurrentContent().type).toEqual("costream");
     expect(stream.headerMeta.type).toEqual("binary");
-    expect(stream instanceof BinaryCoStream).toEqual(true);
+    expect(stream instanceof RawBinaryCoStream).toEqual(true);
 })