jazz-tools 0.7.0-alpha.36 → 0.7.0-alpha.38

package/src/tests/coStream.test.ts

@@ -1,26 +1,25 @@
-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 { BinaryCoStream, ID, Account, jazzReady, CoStream, co } from "..";
-import { Simplify } from "effect/Types";
-
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
-
-beforeEach(async () => {
-    await jazzReady;
-});
+import {
+    BinaryCoStream,
+    ID,
+    Account,
+    CoStream,
+    co,
+    WasmCrypto,
+    isControlledAccount,
+} from "../index.js";
+
+const Crypto = await WasmCrypto.create();
 
 describe("Simple CoStream operations", async () => {
     const me = await Account.create({
         creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
-
+    if (!isControlledAccount(me)) { throw("me is not a controlled account") }
     class TestStream extends CoStream.Of(co.string) {}
 
     const stream = TestStream.create(["milk"], { owner: me });
@@ -57,16 +56,17 @@ describe("CoStream resolution", async () => {
     const initNodeAndStream = async () => {
         const me = await Account.create({
             creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
         const stream = TestStream.create(
             [
                 NestedStream.create(
                     [TwiceNestedStream.create(["milk"], { owner: me })],
-                    { owner: me }
+                    { owner: me },
                 ),
             ],
-            { owner: me }
+            { owner: me },
         );
 
         return { me, stream };
@@ -75,7 +75,7 @@ describe("CoStream resolution", async () => {
     test("Construction", async () => {
         const { me, stream } = await initNodeAndStream();
         expect(stream[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toEqual(
-            "milk"
+            "milk",
         );
     });
 
@@ -84,80 +84,87 @@ describe("CoStream 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 loadedStream = await TestStream.load(stream.id, {
-            as: meOnSecondPeer,
-        });
+        const loadedStream = await TestStream.load(
+            stream.id,
+            meOnSecondPeer,
+            []
+        );
 
         expect(loadedStream?.[me.id]?.value).toEqual(null);
         expect(loadedStream?.[me.id]?.ref?.id).toEqual(
-            stream[me.id]?.value?.id
+            stream[me.id]?.value?.id,
         );
 
         const loadedNestedStream = await NestedStream.load(
             stream[me.id]!.value!.id,
-            { as: meOnSecondPeer }
+            meOnSecondPeer,
+            []
         );
 
         // expect(loadedStream?.[me.id]?.value).toEqual(loadedNestedStream);
         expect(loadedStream?.[me.id]?.value?.id).toEqual(
-            loadedNestedStream?.id
+            loadedNestedStream?.id,
         );
         expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(null);
         // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
         expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
-            loadedNestedStream?.id
+            loadedNestedStream?.id,
         );
         expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.id).toEqual(
-            stream[me.id]?.value?.[me.id]?.value?.id
+            stream[me.id]?.value?.[me.id]?.value?.id,
         );
 
         const loadedTwiceNestedStream = await TwiceNestedStream.load(
             stream[me.id]!.value![me.id]!.value!.id,
-            { as: meOnSecondPeer }
+            meOnSecondPeer,
+            []
         );
 
         // expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(
         //     loadedTwiceNestedStream
         // );
         expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
-            loadedTwiceNestedStream?.id
+            loadedTwiceNestedStream?.id,
         );
         expect(
-            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id)
+            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id),
         ).toEqual("Sir milk");
         // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
         expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
-            loadedNestedStream?.id
+            loadedNestedStream?.id,
         );
         expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.value?.id).toEqual(
-            loadedTwiceNestedStream?.id
+            loadedTwiceNestedStream?.id,
         );
 
         const otherNestedStream = NestedStream.create(
             [TwiceNestedStream.create(["butter"], { owner: meOnSecondPeer })],
-            { owner: meOnSecondPeer }
+            { owner: meOnSecondPeer },
         );
         loadedStream?.push(otherNestedStream);
         // expect(loadedStream?.[me.id]?.value).toEqual(otherNestedStream);
         expect(loadedStream?.[me.id]?.value?.id).toEqual(otherNestedStream?.id);
         expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
-            otherNestedStream?.id
+            otherNestedStream?.id,
         );
         expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
-            otherNestedStream[me.id]?.value?.id
+            otherNestedStream[me.id]?.value?.id,
         );
         expect(
-            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id)
+            loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id),
         ).toEqual("Sir butter");
     });
 
@@ -167,16 +174,17 @@ describe("CoStream resolution", async () => {
         const [initialAsPeer, secondAsPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
-
         me._raw.core.node.syncManager.addPeer(secondAsPeer);
-
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         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(
@@ -184,30 +192,28 @@ describe("CoStream resolution", async () => {
                 const queue = yield* $(Queue.unbounded<TestStream>());
 
                 TestStream.subscribe(
-                    stream.id,
-                    { as: meOnSecondPeer },
+                    stream.id, meOnSecondPeer , [],
                     (subscribedStream) => {
                         console.log(
                             "subscribedStream[me.id]",
-                            subscribedStream[me.id]
+                            subscribedStream[me.id],
                         );
                         console.log(
                             "subscribedStream[me.id]?.value?.[me.id]?.value",
-                            subscribedStream[me.id]?.value?.[me.id]?.value
+                            subscribedStream[me.id]?.value?.[me.id]?.value,
                         );
                         console.log(
                             "subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value",
                             subscribedStream[me.id]?.value?.[me.id]?.value?.[
                                 me.id
-                            ]?.value
+                            ]?.value,
                         );
-                        Effect.runPromise(Queue.offer(queue, subscribedStream));
-                    }
+                        void Effect.runPromise(
+                            Queue.offer(queue, subscribedStream),
+                        );
+                    },
                 );
 
-                type T = Simplify<TestStream>;
-                const te: T = stream;
-
                 const update1 = yield* $(Queue.take(queue));
                 expect(update1[me.id]?.value).toEqual(null);
 
@@ -218,14 +224,14 @@ describe("CoStream resolution", async () => {
                 const update3 = yield* $(Queue.take(queue));
                 expect(update3[me.id]?.value?.[me.id]?.value).toBeDefined();
                 expect(
-                    update3[me.id]?.value?.[me.id]?.value?.[me.id]?.value
+                    update3[me.id]?.value?.[me.id]?.value?.[me.id]?.value,
                 ).toBe("milk");
 
                 update3[me.id]!.value![me.id]!.value!.push("bread");
 
                 const update4 = yield* $(Queue.take(queue));
                 expect(
-                    update4[me.id]?.value?.[me.id]?.value?.[me.id]?.value
+                    update4[me.id]?.value?.[me.id]?.value?.[me.id]?.value,
                 ).toBe("bread");
 
                 // When assigning a new nested stream, we get an update
@@ -241,16 +247,16 @@ describe("CoStream resolution", async () => {
 
                 const update5 = yield* $(Queue.take(queue));
                 expect(
-                    update5[me.id]?.value?.[me.id]?.value?.[me.id]?.value
+                    update5[me.id]?.value?.[me.id]?.value?.[me.id]?.value,
                 ).toBe("butter");
 
                 // we get updates when the new nested stream changes
                 newTwiceNested.push("jam");
                 const update6 = yield* $(Queue.take(queue));
                 expect(
-                    update6[me.id]?.value?.[me.id]?.value?.[me.id]?.value
+                    update6[me.id]?.value?.[me.id]?.value?.[me.id]?.value,
                 ).toBe("jam");
-            })
+            }),
         );
     });
 });
@@ -258,6 +264,7 @@ describe("CoStream resolution", async () => {
 describe("Simple BinaryCoStream operations", async () => {
     const me = await Account.create({
         creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
     const stream = BinaryCoStream.create({ owner: me });
@@ -286,6 +293,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
     const initNodeAndStream = async () => {
         const me = await Account.create({
             creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
         const stream = BinaryCoStream.create({ owner: me });
@@ -299,7 +307,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
     };
 
     test("Construction", async () => {
-        const { me, stream } = await initNodeAndStream();
+        const { stream } = await initNodeAndStream();
         expect(stream.getChunks()).toEqual({
             mimeType: "text/plain",
             chunks: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
@@ -312,19 +320,24 @@ describe("BinaryCoStream loading & Subscription", 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,
         });
 
-        const loadedStream = await BinaryCoStream.load(stream.id, {
-            as: meOnSecondPeer,
-        });
+        const loadedStream = await BinaryCoStream.load(
+            stream.id,
+            meOnSecondPeer,
+            []
+        );
 
         expect(loadedStream?.getChunks()).toEqual({
             mimeType: "text/plain",
@@ -341,16 +354,17 @@ describe("BinaryCoStream loading & Subscription", async () => {
         const [initialAsPeer, secondAsPeer] = connectedPeers(
             "initial",
             "second",
-            { peer1role: "server", peer2role: "client" }
+            { peer1role: "server", peer2role: "client" },
         );
-
         me._raw.core.node.syncManager.addPeer(secondAsPeer);
-
+        if (!isControlledAccount(me)) { throw("me is not a controlled account") }
         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(
@@ -358,11 +372,12 @@ describe("BinaryCoStream loading & Subscription", async () => {
                 const queue = yield* $(Queue.unbounded<BinaryCoStream>());
 
                 BinaryCoStream.subscribe(
-                    stream.id,
-                    { as: meOnSecondPeer },
+                    stream.id, meOnSecondPeer, [],
                     (subscribedStream) => {
-                        Effect.runPromise(Queue.offer(queue, subscribedStream));
-                    }
+                        void Effect.runPromise(
+                            Queue.offer(queue, subscribedStream),
+                        );
+                    },
                 );
 
                 const update1 = yield* $(Queue.take(queue));
@@ -417,7 +432,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
                     totalSizeBytes: undefined,
                     finished: true,
                 });
-            })
+            }),
         );
     });
 });

package/src/tests/deepLoading.test.ts

@@ -0,0 +1,301 @@
+const Crypto = await WasmCrypto.create();
+import { expect, describe, test, expectTypeOf } from "vitest";
+import { connectedPeers } from "cojson/src/streamUtils.js";
+import {
+    Account,
+    CoList,
+    CoMap,
+    CoStream,
+    SessionID,
+    WasmCrypto,
+    co,
+    Profile,
+    isControlledAccount,
+    ID,
+} from "../index.js";
+import { newRandomSessionID } from "cojson/src/coValueCore.js";
+
+class TestMap extends CoMap {
+    list = co.ref(TestList);
+    optionalRef? = co.ref(InnermostMap);
+}
+
+class TestList extends CoList.Of(co.ref(() => InnerMap)) {}
+
+class InnerMap extends CoMap {
+    stream = co.ref(TestStream);
+}
+
+class TestStream extends CoStream.Of(co.ref(() => InnermostMap)) {}
+
+class InnermostMap extends CoMap {
+    value = co.string;
+}
+
+describe("Deep loading with depth arg", async () => {
+    const me = await Account.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
+
+    const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+        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,
+    });
+
+    test("loading a deeply nested object will wait until all required refs are loaded", async () => {
+        const map = TestMap.create(
+            {
+                list: TestList.create(
+                    [
+                        InnerMap.create(
+                            {
+                                stream: TestStream.create(
+                                    [
+                                        InnermostMap.create(
+                                            { value: "hello" },
+                                            { owner: me },
+                                        ),
+                                    ],
+                                    { owner: me },
+                                ),
+                            },
+                            { owner: me },
+                        ),
+                    ],
+                    { owner: me },
+                ),
+            },
+            { owner: me },
+        );
+
+        const map1 = await TestMap.load(map.id, meOnSecondPeer, {});
+        expectTypeOf(map1).toEqualTypeOf<TestMap | undefined>();
+        if (map1 === undefined) {
+            throw new Error("map1 is undefined");
+        }
+        expect(map1.list).toBe(null);
+
+        const map2 = await TestMap.load(map.id, meOnSecondPeer, { list: [] });
+        expectTypeOf(map2).toEqualTypeOf<
+            | (TestMap & {
+                  list: TestList;
+              })
+            | undefined
+        >();
+        if (map2 === undefined) {
+            throw new Error("map2 is undefined");
+        }
+        expect(map2.list).not.toBe(null);
+        expect(map2.list[0]).toBe(null);
+
+        const map3 = await TestMap.load(map.id, meOnSecondPeer, { list: [{}] });
+        expectTypeOf(map3).toEqualTypeOf<
+            | (TestMap & {
+                  list: TestList & InnerMap[];
+              })
+            | undefined
+        >();
+        if (map3 === undefined) {
+            throw new Error("map3 is undefined");
+        }
+        expect(map3.list[0]).not.toBe(null);
+        expect(map3.list[0]?.stream).toBe(null);
+
+        const map3a = await TestMap.load(map.id, meOnSecondPeer, {
+            optionalRef: {},
+        });
+        expectTypeOf(map3a).toEqualTypeOf<
+            | (TestMap & {
+                  optionalRef: InnermostMap | undefined;
+              })
+            | undefined
+        >();
+
+        const map4 = await TestMap.load(map.id, meOnSecondPeer, {
+            list: [{ stream: [] }],
+        });
+        expectTypeOf(map4).toEqualTypeOf<
+            | (TestMap & {
+                  list: TestList & (InnerMap & { stream: TestStream })[];
+              })
+            | undefined
+        >();
+        if (map4 === undefined) {
+            throw new Error("map4 is undefined");
+        }
+        expect(map4.list[0]?.stream).not.toBe(null);
+        // TODO: we should expect null here, but apparently we don't even have the id/ref?
+        expect(map4.list[0]?.stream?.[me.id]?.value).not.toBeDefined();
+        expect(map4.list[0]?.stream?.byMe?.value).not.toBeDefined();
+
+        const map5 = await TestMap.load(map.id, meOnSecondPeer, {
+            list: [{ stream: [{}] }],
+        });
+        type ExpectedMap5 =
+            | (TestMap & {
+                  list: TestList &
+                      (InnerMap & {
+                          stream: TestStream & {
+                              byMe?: { value: InnermostMap };
+                              inCurrentSession?: { value: InnermostMap };
+                              perSession: {
+                                  [sessionID: SessionID]: {
+                                      value: InnermostMap;
+                                  };
+                              };
+                          } & {
+                              [key: ID<Account>]: { value: InnermostMap };
+                          };
+                      })[];
+              })
+            | undefined;
+
+        expectTypeOf(map5).toEqualTypeOf<ExpectedMap5>();
+        if (map5 === undefined) {
+            throw new Error("map5 is undefined");
+        }
+        expect(map5.list[0]?.stream?.[me.id]?.value).not.toBe(null);
+        expect(map5.list[0]?.stream?.byMe?.value).not.toBe(null);
+    });
+});
+
+class CustomProfile extends Profile {
+    stream = co.ref(TestStream);
+}
+
+class CustomAccount extends Account {
+    profile = co.ref(CustomProfile);
+    root = co.ref(TestMap);
+
+    async migrate(creationProps?: { name: string } | undefined) {
+        if (creationProps) {
+            this.profile = CustomProfile.create(
+                {
+                    name: creationProps.name,
+                    stream: TestStream.create([], { owner: this }),
+                },
+                { owner: this },
+            );
+            this.root = TestMap.create(
+                { list: TestList.create([], { owner: this }) },
+                { owner: this },
+            );
+        }
+
+        const thisLoaded = await CustomAccount.load(this, {
+            profile: { stream: [] },
+            root: { list: [] },
+        });
+        expectTypeOf(thisLoaded).toEqualTypeOf<
+            | (CustomAccount & {
+                  profile: CustomProfile & {
+                      stream: TestStream;
+                  };
+                  root: TestMap & {
+                      list: TestList;
+                  };
+              })
+            | undefined
+        >();
+    }
+}
+
+test("Deep loading within account", async () => {
+    const me = await CustomAccount.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
+
+    const meLoaded = await CustomAccount.load(me, {
+        profile: { stream: [] },
+        root: { list: [] },
+    });
+    expectTypeOf(meLoaded).toEqualTypeOf<
+        | (CustomAccount & {
+              profile: CustomProfile & {
+                  stream: TestStream;
+              };
+              root: TestMap & {
+                  list: TestList;
+              };
+          })
+        | undefined
+    >();
+    if (meLoaded === undefined) {
+        throw new Error("meLoaded is undefined");
+    }
+    expect(meLoaded.profile.stream).not.toBe(null);
+    expect(meLoaded.root.list).not.toBe(null);
+});
+
+class RecordLike extends CoMap.Record(co.ref(TestMap)) {}
+
+test("Deep loading a record-like coMap", async () => {
+    const me = await Account.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
+
+    const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+        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 record = RecordLike.create(
+        {
+            key1: TestMap.create(
+                { list: TestList.create([], { owner: me }) },
+                { owner: me },
+            ),
+            key2: TestMap.create(
+                { list: TestList.create([], { owner: me }) },
+                { owner: me },
+            ),
+        },
+        { owner: me },
+    );
+
+    const recordLoaded = await RecordLike.load(record.id, meOnSecondPeer, [
+        { list: [{}] },
+    ]);
+    expectTypeOf(recordLoaded).toEqualTypeOf<
+        | (RecordLike & {
+              [key: string]: TestMap & {
+                  list: TestList & InnerMap[];
+              };
+          })
+        | undefined
+    >();
+    if (recordLoaded === undefined) {
+        throw new Error("recordLoaded is undefined");
+    }
+    expect(recordLoaded.key1?.list).not.toBe(null);
+    expect(recordLoaded.key1?.list).not.toBe(undefined);
+    expect(recordLoaded.key2?.list).not.toBe(null);
+    expect(recordLoaded.key2?.list).not.toBe(undefined);
+});