jazz-tools 0.7.0-alpha.9 → 0.7.1

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, { optional: true });
+}
+
+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);
+});

package/src/tests/groupsAndAccounts.test.ts

@@ -0,0 +1,91 @@
+import { expect, describe, test } from "vitest";
+import { Account, CoMap, co, Group, WasmCrypto } from "../index.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("Custom accounts and groups", async () => {
+    class CustomProfile extends CoMap {
+        name = co.string;
+        color = co.string;
+    }
+
+    class CustomAccount extends Account {
+        profile = co.ref(CustomProfile);
+        root = co.ref(CoMap);
+
+        migrate(creationProps?: { name: string }) {
+            if (creationProps) {
+                const profileGroup = Group.create({ owner: this });
+                profileGroup.addMember("everyone", "reader");
+                this.profile = CustomProfile.create(
+                    { name: creationProps.name, color: "blue" },
+                    { owner: this },
+                );
+            }
+        }
+    }
+
+    class CustomGroup extends Group {
+        profile = co.null;
+        root = co.null;
+        [co.members] = co.ref(CustomAccount);
+
+        get nMembers() {
+            return this.members.length;
+        }
+    }
+
+    test("Custom account and group", async () => {
+        const me = await CustomAccount.create({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
+
+        expect(me.profile).toBeDefined();
+        expect(me.profile?.name).toBe("Hermes Puggington");
+        expect(me.profile?.color).toBe("blue");
+
+        const group = new CustomGroup({ owner: me });
+        group.addMember("everyone", "reader");
+
+        expect(group.members).toMatchObject([
+            { id: me.id, role: "admin" },
+            { id: "everyone", role: "reader" },
+        ]);
+
+        expect(group.nMembers).toBe(2);
+
+        await new Promise<void>((resolve) => {
+            CustomGroup.subscribe(group, {}, (update) => {
+                const meAsMember = update.members.find((member) => {
+                    return member.id === me.id && member.account?.profile;
+                });
+                if (meAsMember) {
+                    expect(meAsMember.account?.profile?.name).toBe(
+                        "Hermes Puggington",
+                    );
+                    expect(meAsMember.account?.profile?.color).toBe("blue");
+                    resolve();
+                }
+            });
+        });
+
+        class MyMap extends CoMap {
+            name = co.string;
+        }
+
+        const map = MyMap.create({ name: "test" }, { owner: group });
+
+        const meAsCastMember = map._owner
+            .as(CustomGroup)
+            .members.find((member) => member.id === me.id);
+        expect(meAsCastMember?.account?.profile?.name).toBe(
+            "Hermes Puggington",
+        );
+        expect(meAsCastMember?.account?.profile?.color).toBe("blue");
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect((map._owner as any).nMembers).toBeUndefined();
+        expect(map._owner.as(CustomGroup).nMembers).toBe(2);
+    });
+});

package/dist/implementation/encoding.js

@@ -1,26 +0,0 @@
-export const SchemaInit = Symbol.for("SchemaInit");
-export const InitValues = Symbol.for("InitValues");
-export const ItemsSym = Symbol.for("items");
-export const val = {
-    string: { [SchemaInit]: "json" },
-    number: { [SchemaInit]: "json" },
-    boolean: { [SchemaInit]: "json" },
-    literal: (_lit) => {
-        return { [SchemaInit]: "json" };
-    },
-    json: () => {
-        return { [SchemaInit]: "json" };
-    },
-    encoded: (arg) => {
-        return { [SchemaInit]: { encoded: arg } };
-    },
-    ref: (arg) => {
-        return { [SchemaInit]: { ref: arg } };
-    },
-    items: ItemsSym,
-};
-import { Date } from "@effect/schema/Schema";
-export const Encoders = {
-    Date,
-};
-//# sourceMappingURL=encoding.js.map

package/dist/implementation/encoding.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../../src/implementation/encoding.ts"],"names":[],"mappings":"AAYA,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAGnD,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAGnD,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAG5C,MAAM,CAAC,MAAM,GAAG,GAAG;IACf,MAAM,EAAE,EAAC,CAAC,UAAU,CAAC,EAAE,MAAyB,EAA4B;IAC5E,MAAM,EAAE,EAAC,CAAC,UAAU,CAAC,EAAE,MAAyB,EAA4B;IAC5E,OAAO,EAAE,EAAC,CAAC,UAAU,CAAC,EAAE,MAAyB,EAA6B;IAC9E,OAAO,EAAE,CACL,IAAO,EACD,EAAE;QACR,OAAO,EAAC,CAAC,UAAU,CAAC,EAAE,MAAyB,EAAS,CAAC;IAC7D,CAAC;IACD,IAAI,EAAE,GAAgC,EAAE;QACpC,OAAO,EAAC,CAAC,UAAU,CAAC,EAAE,MAAyB,EAAS,CAAC;IAC7D,CAAC;IACD,OAAO,EAAE,CAAI,GAAe,EAAU,EAAE;QACpC,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,EAAqB,EAAS,CAAC;IACxE,CAAC;IACD,GAAG,EAAE,CACD,GAAyC,EACd,EAAE;QAC7B,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAqB,EAAS,CAAC;IACpE,CAAC;IACD,KAAK,EAAE,QAAoB;CAC9B,CAAA;AA6BD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE7C,MAAM,CAAC,MAAM,QAAQ,GAAG;IACpB,IAAI;CACP,CAAC"}

package/src/implementation/encoding.ts

@@ -1,105 +0,0 @@
-import type { JsonValue, RawCoValue } from "cojson";
-import type { CoValue, CoValueClass } from "../internal.js";
-import type { Schema, TypeId } from "@effect/schema/Schema";
-
-export type ValMarker = { readonly __field: unique symbol };
-export type val<T> = T | (T & ValMarker);
-export type IsVal<C, R> = C extends infer _A | infer B
-    ? B extends ValMarker
-        ? R
-        : never
-    : never;
-
-export const SchemaInit = Symbol.for("SchemaInit");
-export type SchemaInit = typeof SchemaInit;
-
-export const InitValues = Symbol.for("InitValues");
-export type InitValues = typeof InitValues;
-
-export const ItemsSym = Symbol.for("items");
-export type ItemsSym = typeof ItemsSym;
-
-export const val = {
-    string: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<string>,
-    number: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<number>,
-    boolean: {[SchemaInit]: "json" satisfies Encoding } as unknown as val<boolean>,
-    literal: <T extends string | number | boolean>(
-        _lit: T
-    ): val<T> => {
-        return {[SchemaInit]: "json" satisfies Encoding } as any;
-    },
-    json: <T extends JsonValue>(): val<T> => {
-        return {[SchemaInit]: "json" satisfies Encoding } as any;
-    },
-    encoded: <T>(arg: Encoder<T>): val<T> => {
-        return { [SchemaInit]: { encoded: arg } satisfies Encoding } as any;
-    },
-    ref: <C extends CoValueClass>(
-        arg: (_raw: InstanceType<C>['_raw']) => C
-    ): val<InstanceType<C> | null> => {
-        return { [SchemaInit]: { ref: arg } satisfies Encoding } as any;
-    },
-    items: ItemsSym as ItemsSym,
-}
-
-export type JsonEncoded = "json";
-export type EncodedAs<V> = { encoded: Encoder<V> };
-export type RefEncoded<V extends CoValue> = {
-    ref: (raw: RawCoValue) => CoValueClass<V>;
-};
-
-export type Encoding = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
-
-export type EncodingFor<Field> = NonNullable<Field> extends CoValue
-    ? RefEncoded<NonNullable<Field>>
-    : NonNullable<Field> extends JsonValue
-      ? JsonEncoded
-      : EncodedAs<NonNullable<Field>>;
-
-export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
-    any,
-    any,
-    never
-> & {
-    [TypeId]: {
-        _A: (_: any) => A;
-        _I: (_: any) => I;
-    };
-};
-
-export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
-
-import { Date } from "@effect/schema/Schema";
-
-export const Encoders = {
-    Date,
-};
-
-export type EnsureCoValueNullable<
-    V,
-    Key extends string | ItemsSym,
-> = NonNullable<V> extends CoValue
-    ? null extends V
-        ? V
-        : Key extends string
-          ? [
-                `👋 CoMap fields that are CoValue references should be nullable, declare ${Key} as:`,
-                V | null,
-            ]
-          : [
-                `👋 CoMap fields that are CoValue references should be nullable, declare _item as:`,
-                V | null,
-            ]
-    : V;
-
-export type ValidItem<
-    Item,
-    ContainerType extends string,
-> = NonNullable<Item> extends CoValue
-    ? null extends Item
-        ? any
-        : [
-              `👋 CoList items that are CoValue references should be nullable, make sure the Item generic parameter of ${ContainerType} is:`,
-              Item | null,
-          ]
-    : any;