jazz-tools 0.7.0-alpha.4 → 0.7.0-alpha.42

package/src/tests/coList.test.ts

@@ -1,29 +1,20 @@
-import { expect, describe, test, beforeEach } from "vitest";
-
-import { webcrypto } from "node:crypto";
+import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Account, CoList, jazzReady } from "..";
-
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
+import { Account, CoList, WasmCrypto, co, isControlledAccount } from "../index.js";
 
-beforeEach(async () => {
-    await jazzReady;
-});
+const Crypto = await WasmCrypto.create();
 
 describe("Simple CoList operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
-    class TestList extends CoList<string> {}
-    TestList.encoding({ _item: "json" });
+    class TestList extends CoList.Of(co.string) {}
 
-    const list = new TestList(["bread", "butter", "onion"], { owner: me });
+    const list = TestList.create(["bread", "butter", "onion"], { owner: me });
 
     test("Construction", () => {
         expect(list[0]).toBe("bread");
@@ -40,7 +31,7 @@ describe("Simple CoList operations", async () => {
 
     describe("Mutation", () => {
         test("assignment", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list[1] = "margarine";
@@ -53,7 +44,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("push", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.push("cheese");
@@ -67,7 +58,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("unshift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.unshift("lettuce");
@@ -81,7 +72,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("pop", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.pop()).toBe("onion");
@@ -90,7 +81,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("shift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.shift()).toBe("bread");
@@ -98,53 +89,51 @@ describe("Simple CoList operations", async () => {
             expect(list._raw.asArray()).toEqual(["butter", "onion"]);
         });
 
-        // test("splice", () => {
-        //     const list = new TestList(["bread", "butter", "onion"], {
-        //         owner: me,
-        //     });
-        //     list.splice(1, 1, "salt", "pepper");
-        //     expect(list.length).toBe(4);
-        //     expect(list._raw.asArray()).toEqual([
-        //         "bread",
-        //         "salt",
-        //         "pepper",
-        //         "onion",
-        //     ]);
-        // });
+        test("splice", () => {
+            const list = TestList.create(["bread", "butter", "onion"], {
+                owner: me,
+            });
+            list.splice(1, 1, "salt", "pepper");
+            expect(list.length).toBe(4);
+            expect(list._raw.asArray()).toEqual([
+                "bread",
+                "salt",
+                "pepper",
+                "onion",
+            ]);
+        });
     });
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends CoList<string> {
+    class TwiceNestedList extends CoList.Of(co.string) {
         joined() {
             return this.join(",");
         }
     }
-    TwiceNestedList.encoding({ _item: "json" });
 
-    class NestedList extends CoList<TwiceNestedList | null> {}
-    NestedList.encoding({ _item: { ref: () => TwiceNestedList } });
+    class NestedList extends CoList.Of(co.ref(TwiceNestedList)) {}
 
-    class TestList extends CoList<NestedList | null> {}
-    TestList.encoding({ _item: { ref: () => NestedList } });
+    class TestList extends CoList.Of(co.ref(NestedList)) {}
 
     const initNodeAndList = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
-        const list = new TestList(
+        const list = TestList.create(
             [
-                new NestedList(
-                    [new TwiceNestedList(["a", "b"], { owner: me })],
-                    { owner: me }
+                NestedList.create(
+                    [TwiceNestedList.create(["a", "b"], { owner: me })],
+                    { owner: me },
                 ),
-                new NestedList(
-                    [new TwiceNestedList(["c", "d"], { owner: me })],
-                    { owner: me }
+                NestedList.create(
+                    [TwiceNestedList.create(["c", "d"], { owner: me })],
+                    { owner: me },
                 ),
             ],
-            { owner: me }
+            { owner: me },
         );
 
         return { me, list };
@@ -165,24 +154,29 @@ describe("CoList resolution", async () => {
         const [initialAsPeer, secondPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         me._raw.core.node.syncManager.addPeer(secondPeer);
         const meOnSecondPeer = await Account.become({
             accountID: me.id,
             accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sessionID: newRandomSessionID(me.id as any),
+            crypto: Crypto,
         });
 
-        const loadedList = await TestList.load(list.id, { as: meOnSecondPeer });
+        const loadedList = await TestList.load(list.id, meOnSecondPeer, []);
 
         expect(loadedList?.[0]).toBe(null);
         expect(loadedList?._refs[0]?.id).toEqual(list[0]!.id);
 
-        const loadedNestedList = await NestedList.load(list[0]!.id, {
-            as: meOnSecondPeer,
-        });
+        const loadedNestedList = await NestedList.load(
+            list[0]!.id,
+            meOnSecondPeer,
+            [],
+        );
 
         expect(loadedList?.[0]).toBeDefined();
         expect(loadedList?.[0]?.[0]).toBe(null);
@@ -191,7 +185,8 @@ describe("CoList resolution", async () => {
 
         const loadedTwiceNestedList = await TwiceNestedList.load(
             list[0]![0]!.id,
-            { as: meOnSecondPeer }
+            meOnSecondPeer,
+            [],
         );
 
         expect(loadedList?.[0]?.[0]).toBeDefined();
@@ -200,9 +195,9 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
         expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
-        const otherNestedList = new NestedList(
-            [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
-            { owner: meOnSecondPeer }
+        const otherNestedList = NestedList.create(
+            [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
+            { owner: meOnSecondPeer },
         );
 
         loadedList![0] = otherNestedList;
@@ -216,14 +211,17 @@ describe("CoList resolution", async () => {
         const [initialAsPeer, secondPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         me._raw.core.node.syncManager.addPeer(secondPeer);
         const meOnSecondPeer = await Account.become({
             accountID: me.id,
             accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sessionID: newRandomSessionID(me.id as any),
+            crypto: Crypto,
         });
 
         await Effect.runPromise(
@@ -232,14 +230,17 @@ describe("CoList resolution", async () => {
 
                 TestList.subscribe(
                     list.id,
-                    { as: meOnSecondPeer },
+                    meOnSecondPeer,
+                    [],
                     (subscribedList) => {
                         console.log(
                             "subscribedList?.[0]?.[0]?.[0]",
-                            subscribedList?.[0]?.[0]?.[0]
+                            subscribedList?.[0]?.[0]?.[0],
+                        );
+                        void Effect.runPromise(
+                            Queue.offer(queue, subscribedList),
                         );
-                        Effect.runPromise(Queue.offer(queue, subscribedList));
-                    }
+                    },
                 );
 
                 const update1 = yield* $(Queue.take(queue));
@@ -261,11 +262,11 @@ describe("CoList resolution", async () => {
 
                 // When assigning a new nested value, we get an update
 
-                const newTwiceNestedList = new TwiceNestedList(["y", "z"], {
+                const newTwiceNestedList = TwiceNestedList.create(["y", "z"], {
                     owner: meOnSecondPeer,
                 });
 
-                const newNestedList = new NestedList([newTwiceNestedList], {
+                const newNestedList = NestedList.create([newTwiceNestedList], {
                     owner: meOnSecondPeer,
                 });
 
@@ -279,7 +280,7 @@ describe("CoList resolution", async () => {
                 newTwiceNestedList[0] = "w";
                 const update6 = yield* $(Queue.take(queue));
                 expect(update6?.[0]?.[0]?.[0]).toBe("w");
-            })
+            }),
         );
     });
 });