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

package/src/tests/coMap.test.ts

@@ -1,65 +1,52 @@
-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, indexSignature, CoMap } from "..";
-
-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> {
-        declare color: string;
-        declare height: number;
-        declare birthday: Date;
-        declare name?: string;
+    class TestMap extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
 
-        get _roughColor() {
+        get roughColor() {
             return this.color + "ish";
         }
     }
-    TestMap.encoding({
-        color: "json",
-        height: "json",
-        birthday: { encoded: Encoders.Date },
-        name: "json",
-    });
 
-    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,
+            _height: 10,
             birthday: birthday,
         },
-        { owner: me }
+        { owner: me },
     );
 
     test("Construction", () => {
         expect(map.color).toEqual("red");
-        expect(map._roughColor).toEqual("redish");
-        expect(map.height).toEqual(10);
+        expect(map.roughColor).toEqual("redish");
+        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"]);
     });
 
     describe("Mutation", () => {
-        test("assignment", () => {
+        test("assignment & deletion", () => {
             map.color = "blue";
             expect(map.color).toEqual("blue");
             expect(map._raw.get("color")).toEqual("blue");
@@ -68,45 +55,45 @@ describe("Simple CoMap operations", async () => {
             expect(map.birthday).toEqual(newBirthday);
             expect(map._raw.get("birthday")).toEqual(newBirthday.toISOString());
 
-            Object.assign(map, { color: "green", height: 20 });
+            Object.assign(map, { color: "green", _height: 20 });
             expect(map.color).toEqual("green");
             expect(map._raw.get("color")).toEqual("green");
-            expect(map.height).toEqual(20);
-            expect(map._raw.get("height")).toEqual(20);
+            expect(map._height).toEqual(20);
+            expect(map._raw.get("_height")).toEqual(20);
 
             map.name = "Secret name";
             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> {
-        declare name: string;
-        declare next: RecursiveMap | null;
+    class RecursiveMap extends CoMap {
+        name = co.string;
+        next?: co<RecursiveMap | null> = co.ref(RecursiveMap);
     }
-    RecursiveMap.encoding({
-        name: "json",
-        next: { 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", () => {
@@ -116,65 +103,112 @@ describe("Simple CoMap operations", async () => {
             expect(recursiveMap.next?.next?.name).toEqual("third");
         });
     });
+
+    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 {
+        type = co.literal("a");
+        value = co.number;
+    }
+
+    class ChildB extends CoMap {
+        type = co.literal("b");
+        value = co.string;
+    }
+
+    const mapWithEnum = MapWithEnumOfMaps.create(
+        {
+            name: "enum",
+            child: ChildA.create(
+                {
+                    type: "a",
+                    value: 5,
+                },
+                { owner: me },
+            ),
+        },
+        { owner: me },
+    );
+
+    test("Enum of maps", () => {
+        expect(mapWithEnum.name).toEqual("enum");
+        expect(mapWithEnum.child?.type).toEqual("a");
+        expect(mapWithEnum.child?.value).toEqual(5);
+        expect(mapWithEnum.child?.id).toBeDefined();
+    });
+
+    class SuperClassMap extends CoMap {
+        name = co.string;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    class SubClassMap extends SuperClassMap {
+        name = co.literal("specificString");
+        value = co.number;
+        extra = co.ref(TestMap);
+    }
+
+    class GenericMapWithLoose<out T extends string = string> extends CoMap {
+        name = co.json<T>();
+    }
+
+    // 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!: string;
+    class TwiceNestedMap extends CoMap {
+        taste = co.string;
     }
-    TwiceNestedMap.encoding({
-        taste: "json",
-    });
 
-    class NestedMap extends CoMap<NestedMap> {
-        name!: string;
-        twiceNested!: TwiceNestedMap | null;
+    class NestedMap extends CoMap {
+        name = co.string;
+        twiceNested = co.ref(TwiceNestedMap);
 
         get _fancyName() {
             return "Sir " + this.name;
         }
     }
-    NestedMap.encoding({
-        name: "json",
-        twiceNested: { ref: () => TwiceNestedMap },
-    });
 
-    class TestMap extends CoMap<TestMap> {
-        declare color: string;
-        declare height: number;
-        declare nested: NestedMap | null;
+    class TestMap extends CoMap {
+        color = co.string;
+        height = co.number;
+        nested = co.ref(NestedMap);
 
         get _roughColor() {
             return this.color + "ish";
         }
     }
-    TestMap.encoding({
-        color: "json",
-        height: "json",
-        nested: { ref: () => NestedMap },
-    });
 
     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 };
@@ -199,17 +233,20 @@ 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);
@@ -217,9 +254,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");
@@ -228,23 +267,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;
@@ -261,16 +301,17 @@ 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(
@@ -279,14 +320,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));
@@ -305,19 +349,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;
@@ -337,49 +381,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> {
-        declare color: string;
-        declare nested?: NestedMap | null;
+    class TestMapWithOptionalRef extends CoMap {
+        color = co.string;
+        nested? = co.ref(NestedMap);
     }
-    TestMapWithOptionalRef.encoding({
-        color: "json",
-        nested: { ref: () => NestedMap },
-    });
 
     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");
@@ -388,25 +429,25 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends CoMap<TestRecord> {
-        declare [indexSignature]: 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> {}
-    TestRecord.encoding({
-        [indexSignature]: "json",
-    });
 
     test("Construction with index signature", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
-        const record = new TestRecord(
+        const record = TestRecord.create(
             {
                 height: 5,
                 other: 3,
             },
-            { owner: me }
+            { owner: me },
         );
 
         expect(record.height).toEqual(5);
@@ -414,5 +455,67 @@ describe("CoMap resolution", async () => {
         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 = TestRecord2.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"]);
+    });
+
+    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",
+        ]);
     });
 });