jazz-tools 0.7.0-alpha.26 → 0.7.0-alpha.28

package/src/coValues/coStream.ts

@@ -275,22 +275,24 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
                 get: () => {
                     const allRawEntries = target._raw.itemsBy(key as AccountID);
                     return (function* () {
-                        const rawEntry = allRawEntries.next();
-                        if (rawEntry.done) return;
-                        yield entryFromRawEntry(
-                            receiver,
-                            rawEntry.value,
-                            target._loadedAs,
-                            key as unknown as ID<Account>,
-                            target._schema[ItemsSym]
-                        );
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                receiver,
+                                rawEntry.value,
+                                target._loadedAs,
+                                key as unknown as ID<Account>,
+                                target._schema[ItemsSym]
+                            );
+                        }
                     })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
                 },
             });
 
             return entry;
         } else if (key === "perSession") {
-            return new Proxy(receiver, CoStreamPerSessionProxyHandler);
+            return new Proxy({}, CoStreamPerSessionProxyHandler(target, receiver));
         } else {
             return Reflect.get(target, key, receiver);
         }
@@ -348,50 +350,66 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
     },
 };
 
-const CoStreamPerSessionProxyHandler: ProxyHandler<CoStream> = {
-    get(target, key, receiver) {
+const CoStreamPerSessionProxyHandler = (innerTarget: CoStream, accessFrom: CoStream): ProxyHandler<Record<string, never>> => ({
+    get(_target, key, receiver) {
         if (typeof key === "string" && key.includes("session")) {
             const sessionID = key as SessionID;
-            const rawEntry = target._raw.lastItemIn(sessionID);
+            const rawEntry = innerTarget._raw.lastItemIn(sessionID);
 
             if (!rawEntry) return;
             const by = cojsonInternals.accountOrAgentIDfromSessionID(sessionID);
 
             const entry = entryFromRawEntry(
-                target,
+                accessFrom,
                 rawEntry,
-                target._loadedAs,
+                innerTarget._loadedAs,
                 cojsonInternals.isAccountID(by)
                     ? (by as unknown as ID<Account>)
                     : undefined,
-                target._schema[ItemsSym]
+                innerTarget._schema[ItemsSym]
             );
 
             Object.defineProperty(entry, "all", {
                 get: () => {
-                    const allRawEntries = target._raw.itemsIn(sessionID);
+                    const allRawEntries = innerTarget._raw.itemsIn(sessionID);
                     return (function* () {
-                        const rawEntry = allRawEntries.next();
-                        if (rawEntry.done) return;
-                        yield entryFromRawEntry(
-                            receiver,
-                            rawEntry.value,
-                            target._loadedAs,
-                            cojsonInternals.isAccountID(by)
-                                ? (by as unknown as ID<Account>)
-                                : undefined,
-                            target._schema[ItemsSym]
-                        );
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                accessFrom,
+                                rawEntry.value,
+                                innerTarget._loadedAs,
+                                cojsonInternals.isAccountID(by)
+                                    ? (by as unknown as ID<Account>)
+                                    : undefined,
+                                innerTarget._schema[ItemsSym]
+                            );
+                        }
                     })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
                 },
             });
 
             return entry;
         } else {
-            return Reflect.get(target, key, receiver);
+            return Reflect.get(innerTarget, key, receiver);
         }
     },
-};
+    ownKeys() {
+        return innerTarget._raw.sessions();
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: false,
+            };
+        } else {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        }
+    },
+});
 
 export class BinaryCoStream
     extends CoValueBase

package/src/coValues/group.ts

@@ -1,5 +1,11 @@
-import type { Everyone, RawGroup, Role } from "cojson";
-import type { CoValue, ID, JsonEncoded, RefEncoded, Schema } from "../internal.js";
+import type { AccountID, Everyone, RawGroup, Role } from "cojson";
+import type {
+    CoValue,
+    ID,
+    JsonEncoded,
+    RefEncoded,
+    Schema,
+} from "../internal.js";
 import {
     Account,
     CoMap,
@@ -8,16 +14,32 @@ import {
     co,
     isControlledAccount,
     AccountAndGroupProxyHandler,
+    MembersSym,
 } from "../internal.js";
 
 export class Profile extends CoMap<{ name: co<string> }> {
     name = co.string;
 }
 
+type GroupSchema<Def extends Group> = {
+    profile: NonNullable<Def["profile"]> extends CoValue
+        ? RefEncoded<NonNullable<Def["profile"]>>
+        : JsonEncoded;
+    root: NonNullable<Def["root"]> extends CoValue
+        ? RefEncoded<NonNullable<Def["root"]>>
+        : JsonEncoded;
+    [MembersSym]: RefEncoded<NonNullable<Def[MembersSym]>>;
+};
+
 export class Group<
-        Def extends { profile: Profile | null; root: CoMap | null } = {
+        Def extends {
             profile: Profile | null;
             root: CoMap | null;
+            [MembersSym]: Account | null;
+        } = {
+            profile: Profile | null;
+            root: CoMap | null;
+            [MembersSym]: Account | null;
         },
     >
     extends CoValueBase
@@ -31,31 +53,23 @@ export class Group<
     declare _raw: RawGroup;
 
     static _schema: any;
-    get _schema(): {
-        profile: Def["profile"] extends CoValue
-            ? RefEncoded<Def["profile"]>
-            : JsonEncoded;
-        root: Def["root"] extends CoValue
-            ? RefEncoded<Def["root"]>
-            : JsonEncoded;
-    } {
+    get _schema(): GroupSchema<this> {
         return (this.constructor as typeof Group)._schema;
     }
     static {
         this._schema = {
             profile: "json" satisfies Schema,
             root: "json" satisfies Schema,
+            [MembersSym]: () => Account satisfies Schema,
         } as any;
         Object.defineProperty(this.prototype, "_schema", {
             get: () => this._schema,
         });
     }
 
-    profile!: Def["profile"] extends Profile
-        ? Def["profile"] | null
-        : undefined;
-
-    root!: Def["root"] extends CoMap ? Def["root"] | null : undefined;
+    declare profile: Def["profile"] | null;
+    declare root: Def["root"] | null;
+    declare [MembersSym]: Def[MembersSym] | null;
 
     get _refs(): {
         profile: Def["profile"] extends Profile ? Ref<Def["profile"]> : never;
@@ -136,4 +150,36 @@ export class Group<
     addMember(member: Everyone | Account, role: Role) {
         this._raw.addMember(member === "everyone" ? member : member._raw, role);
     }
+
+    get members() {
+        return this._raw
+            .keys()
+            .filter((key) => {
+                return key === "everyone" || key.startsWith("co_");
+            })
+            .map((id) => {
+                const role = this._raw.get(id as Everyone | AccountID);
+                const accountID =
+                    id === "everyone"
+                        ? undefined
+                        : (id as unknown as ID<Account>);
+                const ref =
+                    accountID &&
+                    new Ref<NonNullable<this[MembersSym]>>(
+                        accountID,
+                        this._loadedAs,
+                        this._schema[MembersSym]
+                    );
+                const accessRef = () => ref?.accessFrom(this);
+
+                return {
+                    id: id as unknown as Everyone | ID<this[MembersSym]>,
+                    role,
+                    ref,
+                    get account() {
+                        return accessRef();
+                    },
+                };
+            });
+    }
 }

package/src/implementation/schema.ts

@@ -10,15 +10,6 @@ export type IfCo<C, R> = C extends infer _A | infer B
         : 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 co = {
     string: {
         [SchemaInit]: "json" satisfies Schema,
@@ -29,6 +20,9 @@ export const co = {
     boolean: {
         [SchemaInit]: "json" satisfies Schema,
     } as unknown as co<boolean>,
+    null: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<null>,
     literal: <T extends string | number | boolean>(_lit: T): co<T> => {
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
@@ -44,6 +38,7 @@ export const co = {
         return { [SchemaInit]: arg satisfies Schema } as any;
     },
     items: ItemsSym as ItemsSym,
+    members: MembersSym as MembersSym,
 };
 
 export type JsonEncoded = "json";
@@ -89,6 +84,7 @@ export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
 export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
 
 import { Date } from "@effect/schema/Schema";
+import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";
 
 export const Encoders = {
     Date,

package/src/implementation/symbols.ts

@@ -0,0 +1,12 @@
+
+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 MembersSym = Symbol.for("members");
+export type MembersSym = typeof MembersSym;

package/src/internal.ts

@@ -1,3 +1,4 @@
+export * from "./implementation/symbols.js";
 export * from './implementation/inspect.js';
 export * from "./coValues/interfaces.js";
 

package/src/tests/coList.test.ts

@@ -17,7 +17,7 @@ beforeEach(async () => {
 
 describe("Simple CoList operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
     class TestList extends CoList.Of(co.string) {}
@@ -97,19 +97,19 @@ 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 = 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",
+            ]);
+        });
     });
 });
 
@@ -126,7 +126,7 @@ describe("CoList resolution", async () => {
 
     const initNodeAndList = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const list = new TestList(

package/src/tests/coMap.test.ts

@@ -17,7 +17,7 @@ beforeEach(async () => {
 
 describe("Simple CoMap operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
     class TestMap extends CoMap<TestMap> {
@@ -50,11 +50,7 @@ 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",
-        ]);
+        expect(Object.keys(map)).toEqual(["color", "_height", "birthday"]);
     });
 
     describe("Mutation", () => {
@@ -202,7 +198,7 @@ describe("CoMap resolution", async () => {
 
     const initNodeAndMap = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const map = new TestMap(
@@ -394,7 +390,7 @@ describe("CoMap resolution", async () => {
 
     test("Construction with optional", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const mapWithout = new TestMapWithOptionalRef(
@@ -437,7 +433,7 @@ describe("CoMap resolution", async () => {
 
     test("Construction with index signature", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const record = new TestRecord(
@@ -454,18 +450,18 @@ describe("CoMap resolution", async () => {
         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,
-          });
+            _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({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const record = new TestRecord2(
@@ -487,13 +483,19 @@ describe("CoMap resolution", async () => {
 
     test("Construction with index signature ref", async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const record = new TestRecordRef(
             {
-                firstNested: new TwiceNestedMap({ taste: "sour" }, { owner: me }),
-                secondNested: new TwiceNestedMap({ taste: "sweet" }, { owner: me }),
+                firstNested: new TwiceNestedMap(
+                    { taste: "sour" },
+                    { owner: me }
+                ),
+                secondNested: new TwiceNestedMap(
+                    { taste: "sweet" },
+                    { owner: me }
+                ),
             },
             { owner: me }
         );
@@ -503,6 +505,9 @@ describe("CoMap resolution", async () => {
         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"]);
+        expect(Object.keys(record._refs)).toEqual([
+            "firstNested",
+            "secondNested",
+        ]);
     });
 });

package/src/tests/coStream.test.ts

@@ -18,7 +18,7 @@ beforeEach(async () => {
 
 describe("Simple CoStream operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
     class TestStream extends CoStream.Of(co.string) {}
@@ -56,7 +56,7 @@ describe("CoStream resolution", async () => {
 
     const initNodeAndStream = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const stream = new TestStream(
@@ -257,7 +257,7 @@ describe("CoStream resolution", async () => {
 
 describe("Simple BinaryCoStream operations", async () => {
     const me = await Account.create({
-        name: "Hermes Puggington",
+        creationProps: { name: "Hermes Puggington" },
     });
 
     const stream = new BinaryCoStream(undefined, { owner: me });
@@ -285,7 +285,7 @@ describe("Simple BinaryCoStream operations", async () => {
 describe("BinaryCoStream loading & Subscription", async () => {
     const initNodeAndStream = async () => {
         const me = await Account.create({
-            name: "Hermes Puggington",
+            creationProps: { name: "Hermes Puggington" },
         });
 
         const stream = new BinaryCoStream(undefined, { owner: me });

package/src/tests/groupsAndAccounts.test.ts

@@ -0,0 +1,77 @@
+import { expect, describe, test, beforeEach } from "vitest";
+
+import { webcrypto } from "node:crypto";
+import { Account, jazzReady, CoMap, co, Group } from "..";
+
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
+beforeEach(async () => {
+    await jazzReady;
+});
+
+describe("Custom accounts and groups", async () => {
+    class CustomProfile extends CoMap<CustomProfile> {
+        name = co.string;
+        color = co.string;
+    }
+
+    class CustomAccount extends Account<CustomAccount> {
+        profile = co.ref(CustomProfile);
+        root = co.ref(CoMap);
+
+        migrate(creationProps?: { name: string }) {
+            if (creationProps) {
+                const profileGroup = new Group({ owner: this });
+                profileGroup.addMember("everyone", "reader");
+                this.profile = new CustomProfile(
+                    { name: creationProps.name, color: "blue" },
+                    { owner: this }
+                );
+            }
+        }
+    }
+
+    class CustomGroup extends Group<CustomGroup> {
+        profile = co.null;
+        root = co.null;
+        [co.members] = co.ref(CustomAccount);
+    }
+
+    type T = CustomGroup[typeof co.members];
+
+    test("Custom account and group", async () => {
+        const me = await CustomAccount.create({
+            creationProps: { name: "Hermes Puggington" },
+        });
+
+        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" },
+        ]);
+
+        await new Promise<void>((resolve) => {
+            group.subscribe((update) => {
+                const myProfile = update.members.find((member) => {
+                    return member.id === me.id && member.account?.profile;
+                });
+                if (myProfile) {
+                    expect(myProfile.account?.profile?.name).toBe(
+                        "Hermes Puggington"
+                    );
+                    expect(myProfile.account?.profile?.color).toBe("blue");
+                    resolve();
+                }
+            });
+        });
+    });
+});