jazz-tools 0.7.0-alpha.8 → 0.7.1

package/src/tests/coMap.test.ts

@@ -1,48 +1,46 @@
-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, jazzReady, Encoders, CoMap } from "..";
-import { val } from "../internal";
-
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
+import {
+    Account,
+    Encoders,
+    CoMap,
+    co,
+    WasmCrypto,
+    isControlledAccount,
+} from "../index.js";
 
-beforeEach(async () => {
-    await jazzReady;
-});
+const Crypto = await WasmCrypto.create();
 
 describe("Simple CoMap operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
-    class TestMap extends CoMap<TestMap> {
-        color = val.string;
-        _height = val.number;
-        birthday = val.encoded(Encoders.Date);
-        name? = val.string;
+    class TestMap extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
 
         get roughColor() {
             return this.color + "ish";
         }
     }
 
-    console.log("TestMap schema", TestMap.prototype._encoding);
+    console.log("TestMap schema", TestMap.prototype._schema);
 
     const birthday = new Date();
 
-    const map = new TestMap(
+    const map = TestMap.create(
         {
             color: "red",
             _height: 10,
             birthday: birthday,
         },
-        { owner: me }
+        { owner: me },
     );
 
     test("Construction", () => {
@@ -51,16 +49,11 @@ describe("Simple CoMap operations", async () => {
         expect(map._height).toEqual(10);
         expect(map.birthday).toEqual(birthday);
         expect(map._raw.get("birthday")).toEqual(birthday.toISOString());
-        expect(Object.keys(map)).toEqual([
-            "color",
-            "_height",
-            "birthday",
-            "name",
-        ]);
+        expect(Object.keys(map)).toEqual(["color", "_height", "birthday"]);
     });
 
     describe("Mutation", () => {
-        test("assignment", () => {
+        test("assignment & deletion", () => {
             map.color = "blue";
             expect(map.color).toEqual("blue");
             expect(map._raw.get("color")).toEqual("blue");
@@ -79,31 +72,35 @@ describe("Simple CoMap operations", async () => {
             expect(map.name).toEqual("Secret name");
             map.name = undefined;
             expect(map.name).toEqual(undefined);
+            expect(Object.keys(map)).toContain("name");
+            delete map.name;
+            expect(map.name).toEqual(undefined);
+            expect(Object.keys(map)).not.toContain("name");
         });
     });
 
-    class RecursiveMap extends CoMap<RecursiveMap> {
-        name = val.string;
-        next: val<RecursiveMap | null> = val.ref(() => RecursiveMap);
+    class RecursiveMap extends CoMap {
+        name = co.string;
+        next?: co<RecursiveMap | null> = co.ref(RecursiveMap);
     }
 
-    const recursiveMap = new RecursiveMap(
+    const recursiveMap = RecursiveMap.create(
         {
             name: "first",
-            next: new RecursiveMap(
+            next: RecursiveMap.create(
                 {
                     name: "second",
-                    next: new RecursiveMap(
+                    next: RecursiveMap.create(
                         {
                             name: "third",
                         },
-                        { owner: me }
+                        { owner: me },
                     ),
                 },
-                { owner: me }
+                { owner: me },
             ),
         },
-        { owner: me }
+        { owner: me },
     );
 
     describe("Recursive CoMap", () => {
@@ -114,35 +111,35 @@ describe("Simple CoMap operations", async () => {
         });
     });
 
-    class MapWithEnumOfMaps extends CoMap<MapWithEnumOfMaps> {
-        name = val.string;
-        child = val.ref<typeof ChildA | typeof ChildB>((raw) =>
-            raw.get("type") === "a" ? ChildA : ChildB
+    class MapWithEnumOfMaps extends CoMap {
+        name = co.string;
+        child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
+            raw.get("type") === "a" ? ChildA : ChildB,
         );
     }
 
-    class ChildA extends CoMap<ChildA> {
-        type = val.literal("a");
-        value = val.number;
+    class ChildA extends CoMap {
+        type = co.literal("a");
+        value = co.number;
     }
 
-    class ChildB extends CoMap<ChildB> {
-        type = val.literal("b");
-        value = val.string;
+    class ChildB extends CoMap {
+        type = co.literal("b");
+        value = co.string;
     }
 
-    const mapWithEnum = new MapWithEnumOfMaps(
+    const mapWithEnum = MapWithEnumOfMaps.create(
         {
             name: "enum",
-            child: new ChildA(
+            child: ChildA.create(
                 {
                     type: "a",
                     value: 5,
                 },
-                { owner: me }
+                { owner: me },
             ),
         },
-        { owner: me }
+        { owner: me },
     );
 
     test("Enum of maps", () => {
@@ -152,35 +149,45 @@ describe("Simple CoMap operations", async () => {
         expect(mapWithEnum.child?.id).toBeDefined();
     });
 
-    class SuperClassMap extends CoMap<SuperClassMap> {
-        name = val.string;
+    class SuperClassMap extends CoMap {
+        name = co.string;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     class SubClassMap extends SuperClassMap {
-        name = val.literal("specificString")
-        value = val.number;
+        name = co.literal("specificString");
+        value = co.number;
+        extra = co.ref(TestMap);
+    }
+
+    class GenericMapWithLoose<out T extends string = string> extends CoMap {
+        name = co.json<T>();
     }
-    interface SubClassMap extends CoMap<SubClassMap> {}
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const loose: GenericMapWithLoose<string> = {} as GenericMapWithLoose<
+        "a" | "b"
+    >;
 });
 
 describe("CoMap resolution", async () => {
-    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
-        taste = val.string;
+    class TwiceNestedMap extends CoMap {
+        taste = co.string;
     }
 
-    class NestedMap extends CoMap<NestedMap> {
-        name = val.string;
-        twiceNested = val.ref(() => TwiceNestedMap);
+    class NestedMap extends CoMap {
+        name = co.string;
+        twiceNested = co.ref(TwiceNestedMap);
 
         get _fancyName() {
             return "Sir " + this.name;
         }
     }
 
-    class TestMap extends CoMap<TestMap> {
-        color = val.string;
-        height = val.number;
-        nested = val.ref(() => NestedMap);
+    class TestMap extends CoMap {
+        color = co.string;
+        height = co.number;
+        nested = co.ref(NestedMap);
 
         get _roughColor() {
             return this.color + "ish";
@@ -189,25 +196,26 @@ describe("CoMap resolution", async () => {
 
     const initNodeAndMap = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
-        const map = new TestMap(
+        const map = TestMap.create(
             {
                 color: "red",
                 height: 10,
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "nested",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
-                            { owner: me }
+                            { owner: me },
                         ),
                     },
-                    { owner: me }
+                    { owner: me },
                 ),
             },
-            { owner: me }
+            { owner: me },
         );
 
         return { me, map };
@@ -232,17 +240,22 @@ describe("CoMap 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 loadedMap = await TestMap.load(map.id, { as: meOnSecondPeer });
+        const loadedMap = await TestMap.load(map.id, meOnSecondPeer, {});
 
         expect(loadedMap?.color).toEqual("red");
         expect(loadedMap?.height).toEqual(10);
@@ -250,9 +263,11 @@ describe("CoMap resolution", async () => {
         expect(loadedMap?._refs.nested?.id).toEqual(map.nested?.id);
         expect(loadedMap?._refs.nested?.value).toEqual(null);
 
-        const loadedNestedMap = await NestedMap.load(map.nested!.id, {
-            as: meOnSecondPeer,
-        });
+        const loadedNestedMap = await NestedMap.load(
+            map.nested!.id,
+            meOnSecondPeer,
+            {},
+        );
 
         expect(loadedMap?.nested?.name).toEqual("nested");
         expect(loadedMap?.nested?._fancyName).toEqual("Sir nested");
@@ -261,23 +276,24 @@ describe("CoMap resolution", async () => {
 
         const loadedTwiceNestedMap = await TwiceNestedMap.load(
             map.nested!.twiceNested!.id,
-            { as: meOnSecondPeer }
+            meOnSecondPeer,
+            {},
         );
 
         expect(loadedMap?.nested?.twiceNested?.taste).toEqual("sour");
         expect(loadedMap?.nested?._refs.twiceNested?.value).toEqual(
-            loadedTwiceNestedMap
+            loadedTwiceNestedMap,
         );
 
-        const otherNestedMap = new NestedMap(
+        const otherNestedMap = NestedMap.create(
             {
                 name: "otherNested",
-                twiceNested: new TwiceNestedMap(
+                twiceNested: TwiceNestedMap.create(
                     { taste: "sweet" },
-                    { owner: meOnSecondPeer }
+                    { owner: meOnSecondPeer },
                 ),
             },
-            { owner: meOnSecondPeer }
+            { owner: meOnSecondPeer },
         );
 
         loadedMap!.nested = otherNestedMap;
@@ -294,16 +310,19 @@ describe("CoMap resolution", async () => {
         const [initialAsPeer, secondAsPeer] = 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(secondAsPeer);
-
         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(
@@ -312,14 +331,17 @@ describe("CoMap resolution", async () => {
 
                 TestMap.subscribe(
                     map.id,
-                    { as: meOnSecondPeer },
+                    meOnSecondPeer,
+                    {},
                     (subscribedMap) => {
                         console.log(
                             "subscribedMap.nested?.twiceNested?.taste",
-                            subscribedMap.nested?.twiceNested?.taste
+                            subscribedMap.nested?.twiceNested?.taste,
+                        );
+                        void Effect.runPromise(
+                            Queue.offer(queue, subscribedMap),
                         );
-                        Effect.runPromise(Queue.offer(queue, subscribedMap));
-                    }
+                    },
                 );
 
                 const update1 = yield* $(Queue.take(queue));
@@ -338,19 +360,19 @@ describe("CoMap resolution", async () => {
                 expect(oldTwiceNested?.taste).toEqual("sour");
 
                 // When assigning a new nested value, we get an update
-                const newTwiceNested = new TwiceNestedMap(
+                const newTwiceNested = TwiceNestedMap.create(
                     {
                         taste: "sweet",
                     },
-                    { owner: meOnSecondPeer }
+                    { owner: meOnSecondPeer },
                 );
 
-                const newNested = new NestedMap(
+                const newNested = NestedMap.create(
                     {
                         name: "newNested",
                         twiceNested: newTwiceNested,
                     },
-                    { owner: meOnSecondPeer }
+                    { owner: meOnSecondPeer },
                 );
 
                 update3.nested = newNested;
@@ -370,45 +392,46 @@ describe("CoMap resolution", async () => {
                 newTwiceNested.taste = "umami";
                 const update6 = yield* $(Queue.take(queue));
                 expect(update6.nested?.twiceNested?.taste).toEqual("umami");
-            })
+            }),
         );
     });
 
-    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
-        color = val.string;
-        nested? = val.ref(() => NestedMap);
+    class TestMapWithOptionalRef extends CoMap {
+        color = co.string;
+        nested = co.ref(NestedMap, { optional: true });
     }
 
     test("Construction with optional", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
-        const mapWithout = new TestMapWithOptionalRef(
+        const mapWithout = TestMapWithOptionalRef.create(
             {
                 color: "red",
             },
-            { owner: me }
+            { owner: me },
         );
 
         expect(mapWithout.color).toEqual("red");
         expect(mapWithout.nested).toEqual(undefined);
 
-        const mapWith = new TestMapWithOptionalRef(
+        const mapWith = TestMapWithOptionalRef.create(
             {
                 color: "red",
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "wow!",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
-                            { owner: me }
+                            { owner: me },
                         ),
                     },
-                    { owner: me }
+                    { owner: me },
                 ),
             },
-            { owner: me }
+            { owner: me },
         );
 
         expect(mapWith.color).toEqual("red");
@@ -417,22 +440,54 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends CoMap<TestRecord> {
-        [val.items] = val.number;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+    class TestRecord extends CoMap {
+        [co.items] = co.number;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
     interface TestRecord extends Record<string, number> {}
 
     test("Construction with index signature", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
+
+        const record = TestRecord.create(
+            {
+                height: 5,
+                other: 3,
+            },
+            { owner: me },
+        );
+
+        expect(record.height).toEqual(5);
+        expect(record._raw.get("height")).toEqual(5);
+        expect(record.other).toEqual(3);
+        expect(record._raw.get("other")).toEqual(3);
+        expect(Object.keys(record)).toEqual(["height", "other"]);
+        expect(record.toJSON()).toMatchObject({
+            _type: "CoMap",
+            height: 5,
+            id: expect.any(String),
+            other: 3,
+        });
+    });
+
+    class TestRecord2 extends CoMap.Record(co.number) {}
+
+    test("Construction with index signature (shorthand)", async () => {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
-        const record = new TestRecord(
+        const record = TestRecord2.create(
             {
                 height: 5,
                 other: 3,
             },
-            { owner: me }
+            { owner: me },
         );
 
         expect(record.height).toEqual(5);
@@ -441,4 +496,37 @@ describe("CoMap resolution", async () => {
         expect(record._raw.get("other")).toEqual(3);
         expect(Object.keys(record)).toEqual(["height", "other"]);
     });
+
+    class TestRecordRef extends CoMap.Record(co.ref(TwiceNestedMap)) {}
+
+    test("Construction with index signature ref", async () => {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
+
+        const record = TestRecordRef.create(
+            {
+                firstNested: TwiceNestedMap.create(
+                    { taste: "sour" },
+                    { owner: me },
+                ),
+                secondNested: TwiceNestedMap.create(
+                    { taste: "sweet" },
+                    { owner: me },
+                ),
+            },
+            { owner: me },
+        );
+
+        expect(record.firstNested?.taste).toEqual("sour");
+        expect(record.firstNested?.id).toBeDefined();
+        expect(record.secondNested?.taste).toEqual("sweet");
+        expect(record.secondNested?.id).toBeDefined();
+        expect(Object.keys(record)).toEqual(["firstNested", "secondNested"]);
+        expect(Object.keys(record._refs)).toEqual([
+            "firstNested",
+            "secondNested",
+        ]);
+    });
 });