jazz-tools 0.7.0-alpha.9 → 0.7.3

package/src/coValues/deepLoading.ts

@@ -0,0 +1,229 @@
+import { SessionID } from "cojson";
+import {
+    Account,
+    CoList,
+    CoStream,
+    CoStreamEntry,
+    ItemsSym,
+    Ref,
+    RefEncoded,
+    UnCo,
+} from "../internal.js";
+import { CoKeys, CoMap } from "./coMap.js";
+import { CoValue, ID } from "./interfaces.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fulfillsDepth(depth: any, value: CoValue): boolean {
+    if (
+        value._type === "CoMap" ||
+        value._type === "Group" ||
+        value._type === "Account"
+    ) {
+        if (Array.isArray(depth) && depth.length === 1) {
+            return Object.entries(value).every(([key, item]) => {
+                return (
+                    value as unknown as {
+                        _refs: { [key: string]: Ref<CoValue> | undefined };
+                    }
+                )._refs[key]
+                    ? item && fulfillsDepth(depth[0], item)
+                    : ((value as CoMap)._schema[
+                          ItemsSym
+                      ] as RefEncoded<CoValue>)!.optional;
+            });
+        } else {
+            for (const key of Object.keys(depth)) {
+                const map = value as unknown as {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    [key: string]: any;
+                    _refs: { [key: string]: Ref<CoValue> | undefined };
+                };
+                if (!map._refs[key] && map._schema[key].optional) {
+                    continue;
+                }
+                if (!map[key]) {
+                    return false;
+                }
+                if (!fulfillsDepth(depth[key], map[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    } else if (value._type === "CoList") {
+        if (depth.length === 0) {
+            return true;
+        } else {
+            const itemDepth = depth[0];
+            return (value as CoList).every((item, i) =>
+                (value as CoList)._refs[i]
+                    ? item && fulfillsDepth(itemDepth, item)
+                    : (
+                          (value as CoList)._schema[
+                              ItemsSym
+                          ] as RefEncoded<CoValue>
+                      ).optional,
+            );
+        }
+    } else if (value._type === "CoStream") {
+        if (depth.length === 0) {
+            return true;
+        } else {
+            const itemDepth = depth[0];
+            return Object.values((value as CoStream).perSession).every(
+                (entry) =>
+                    entry.ref
+                        ? entry.value && fulfillsDepth(itemDepth, entry.value)
+                        : (
+                              (value as CoStream)._schema[
+                                  ItemsSym
+                              ] as RefEncoded<CoValue>
+                          ).optional,
+            );
+        }
+    } else if (value._type === "BinaryCoStream") {
+        return true;
+    } else {
+        console.error(value);
+        throw new Error("Unexpected value type: " + value._type);
+    }
+}
+
+type UnCoNotNull<T> = UnCo<Exclude<T, null>>;
+type Clean<T> = UnCo<NonNullable<T>>;
+
+export type DepthsIn<
+    V,
+    DepthLimit extends number = 5,
+    CurrentDepth extends number[] = [],
+> =
+    | (DepthLimit extends CurrentDepth["length"]
+          ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            any
+          : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
+            V extends Array<infer Item>
+            ?
+                  | [
+                        DepthsIn<
+                            UnCoNotNull<Item>,
+                            DepthLimit,
+                            [0, ...CurrentDepth]
+                        >,
+                    ]
+                  | never[]
+            : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
+              V extends { _type: "CoMap" | "Group" | "Account" }
+              ?
+                    | {
+                          [Key in CoKeys<V> as Clean<V[Key]> extends CoValue
+                              ? Key
+                              : never]?: DepthsIn<
+                              Clean<V[Key]>,
+                              DepthLimit,
+                              [0, ...CurrentDepth]
+                          >;
+                      }
+                    | (ItemsSym extends keyof V
+                          ? [
+                                DepthsIn<
+                                    Clean<V[ItemsSym]>,
+                                    DepthLimit,
+                                    [0, ...CurrentDepth]
+                                >,
+                            ]
+                          : never)
+                    | never[]
+              : V extends {
+                      _type: "CoStream";
+                      byMe: CoStreamEntry<infer Item> | undefined;
+                  }
+                ?
+                      | [
+                            DepthsIn<
+                                UnCoNotNull<Item>,
+                                DepthLimit,
+                                [0, ...CurrentDepth]
+                            >,
+                        ]
+                      | never[]
+                : never[])
+    | never[];
+
+export type DeeplyLoaded<
+    V,
+    Depth,
+    DepthLimit extends number = 5,
+    CurrentDepth extends number[] = [],
+> = DepthLimit extends CurrentDepth["length"]
+    ? V
+    : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
+      [V] extends [Array<infer Item>]
+      ? Depth extends never[] // []
+          ? V
+          : UnCoNotNull<Item> extends CoValue
+            ? Depth extends Array<infer ItemDepth> // [item-depth]
+                ? (UnCoNotNull<Item> &
+                      DeeplyLoaded<
+                          UnCoNotNull<Item>,
+                          ItemDepth,
+                          DepthLimit,
+                          [0, ...CurrentDepth]
+                      >)[] &
+                      V
+                : never
+            : V
+      : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
+        [V] extends [{ _type: "CoMap" | "Group" | "Account" }]
+        ? Depth extends never[]
+            ? V
+            : Depth extends Array<infer ItemDepth>
+              ? ItemsSym extends keyof V
+                  ? V & {
+                        [key: string]: DeeplyLoaded<
+                            Clean<V[ItemsSym]>,
+                            ItemDepth,
+                            DepthLimit,
+                            [0, ...CurrentDepth]
+                        >;
+                    }
+                  : never
+              : keyof Depth extends never
+                ? V
+                : {
+                      [Key in keyof Depth]-?: Key extends CoKeys<V>
+                          ? Clean<V[Key]> extends CoValue
+                              ?
+                                    | DeeplyLoaded<
+                                          Clean<V[Key]>,
+                                          Depth[Key],
+                                          DepthLimit,
+                                          [0, ...CurrentDepth]
+                                      >
+                                    | (undefined extends V[Key]
+                                          ? undefined
+                                          : never)
+                              : never
+                          : never;
+                  } & V
+        : [V] extends [
+                {
+                    _type: "CoStream";
+                    byMe: CoStreamEntry<infer Item> | undefined;
+                },
+            ]
+          ? Depth extends never[]
+              ? V
+              : V & {
+                    byMe?: { value: UnCoNotNull<Item> };
+                    inCurrentSession?: { value: UnCoNotNull<Item> };
+                    perSession: {
+                        [key: SessionID]: { value: UnCoNotNull<Item> };
+                    };
+                } & { [key: ID<Account>]: { value: UnCoNotNull<Item> } }
+          : [V] extends [
+                  {
+                      _type: "BinaryCoStream";
+                  },
+              ]
+            ? V
+            : never;

package/src/coValues/extensions/imageDef.ts

@@ -1,28 +1,32 @@
 import {
     BinaryCoStream,
     CoMap,
-    val,
+    co,
     subscriptionsScopes,
 } from "../../internal.js";
 
-export class ImageDefinition extends CoMap<ImageDefinition> {
-    originalSize = val.json<[number, number]>();
-    placeholderDataURL? = val.string;
+/** @category Media */
+export class ImageDefinition extends CoMap {
+    originalSize = co.json<[number, number]>();
+    placeholderDataURL? = co.string;
 
-    [val.items] = val.ref(() => BinaryCoStream);
-    [res: `${number}x${number}`]: val<BinaryCoStream | null>;
+    [co.items] = co.ref(BinaryCoStream);
+    [res: `${number}x${number}`]: co<BinaryCoStream | null>;
 
-    get highestResAvailable():
-        | { res: `${number}x${number}`; stream: BinaryCoStream }
-        | undefined {
+    highestResAvailable(options?: {
+        maxWidth?: number;
+    }): { res: `${number}x${number}`; stream: BinaryCoStream } | undefined {
         if (!subscriptionsScopes.get(this)) {
             console.warn(
-                "highestResAvailable() only makes sense when used within a subscription."
+                "highestResAvailable() only makes sense when used within a subscription.",
             );
         }
 
-        const resolutions = Object.keys(this).filter((key) =>
-            key.match(/^\d+x\d+$/)
+        const resolutions = Object.keys(this).filter(
+            (key) =>
+                key.match(/^\d+x\d+$/) &&
+                (options?.maxWidth === undefined ||
+                    Number(key.split("x")[0]) <= options.maxWidth),
         ) as `${number}x${number}`[];
 
         resolutions.sort((a, b) => {
@@ -52,4 +56,4 @@ export class ImageDefinition extends CoMap<ImageDefinition> {
             }
         );
     }
-}
+}

package/src/coValues/group.ts

@@ -1,71 +1,81 @@
-import type { Everyone, RawGroup, Role } from "cojson";
-import type { CoValue, ID, JsonEncoded, RefEncoded } from "../internal.js";
+import type { AccountID, Everyone, RawGroup, Role } from "cojson";
+import type {
+    CoValue,
+    ID,
+    RefEncoded,
+    Schema,
+    AccountCtx,
+    CoValueClass,
+    DeeplyLoaded,
+    DepthsIn,
+    UnavailableError,
+} from "../internal.js";
 import {
     Account,
     CoMap,
     CoValueBase,
     Ref,
-    val,
+    co,
     isControlledAccount,
     AccountAndGroupProxyHandler,
+    MembersSym,
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    ensureCoValueLoaded,
+    subscribeToExistingCoValue,
 } from "../internal.js";
+import { Effect, Stream } from "effect";
 
-export class Profile extends CoMap<{ name: val<string> }> {
-    name = val.string;
+/** @category Identity & Permissions */
+export class Profile extends CoMap {
+    name = co.string;
 }
 
-export class Group<
-        Def extends { profile: Profile | null; root: CoMap | null } = {
-            profile: Profile | null;
-            root: CoMap | null;
-        },
-    >
-    extends CoValueBase
-    implements CoValue<"Group", RawGroup>
-{
-    id!: ID<this>;
-    _type!: "Group";
+/** @category Identity & Permissions */
+export class Group extends CoValueBase implements CoValue {
+    declare id: ID<this>;
+    declare _type: "Group";
     static {
         this.prototype._type = "Group";
     }
-    _raw!: RawGroup;
-
-    static _encoding: any;
-    get _encoding(): {
-        profile: Def["profile"] extends CoValue
-            ? RefEncoded<Def["profile"]>
-            : JsonEncoded;
-        root: Def["root"] extends CoValue
-            ? RefEncoded<Def["root"]>
-            : JsonEncoded;
+    declare _raw: RawGroup;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _schema: any;
+    get _schema(): {
+        profile: Schema;
+        root: Schema;
+        [MembersSym]: RefEncoded<Account>;
     } {
-        return (this.constructor as typeof Group)._encoding;
+        return (this.constructor as typeof Group)._schema;
     }
     static {
-        this._encoding = {
-            profile: { json: true },
-            root: { json: true },
+        this._schema = {
+            profile: "json" satisfies Schema,
+            root: "json" satisfies Schema,
+            [MembersSym]: {
+                ref: () => Account,
+                optional: false,
+            } satisfies RefEncoded<Account>,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any;
-        Object.defineProperty(this.prototype, "_encoding", {
-            get: () => this._encoding,
+        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: Profile | null;
+    declare root: CoMap | null;
+    declare [MembersSym]: Account | null;
 
-    get _refs(): {
-        profile: Def["profile"] extends Profile ? Ref<Def["profile"]> : never;
-        root: Def["root"] extends CoMap ? Ref<Def["root"]> : never;
-    } {
+    get _refs() {
         const profileID = this._raw.get("profile") as unknown as
-            | ID<NonNullable<Def["profile"]>>
+            | ID<NonNullable<this["profile"]>>
             | undefined;
         const rootID = this._raw.get("root") as unknown as
-            | ID<NonNullable<Def["root"]>>
+            | ID<NonNullable<this["root"]>>
             | undefined;
         return {
             profile:
@@ -73,34 +83,35 @@ export class Group<
                 (new Ref(
                     profileID,
                     this._loadedAs,
-                    this._encoding.profile as RefEncoded<
-                        NonNullable<Def["profile"]>
-                    >
-                ) as any),
+                    this._schema.profile as RefEncoded<
+                        NonNullable<this["profile"]>
+                    >,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as this["profile"] extends Profile
+                    ? Ref<this["profile"]>
+                    : never),
             root:
                 rootID &&
                 (new Ref(
                     rootID,
                     this._loadedAs,
-                    this._encoding.root as RefEncoded<NonNullable<Def["root"]>>
-                ) as any),
+                    this._schema.root as RefEncoded<NonNullable<this["root"]>>,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as this["root"] extends CoMap
+                    ? Ref<this["root"]>
+                    : never),
         };
     }
 
-    constructor(options: { owner: Account | Group });
-    constructor(init: any, options: { fromRaw: RawGroup });
-    constructor(init: undefined, options: { owner: Account | Group });
-    constructor(
-        init: undefined | { owner: Account | Group },
-        options?: { fromRaw: RawGroup } | { owner: Account | Group }
-    ) {
+    /** @deprecated Don't use constructor directly, use .create */
+    constructor(options: { fromRaw: RawGroup } | { owner: Account | Group }) {
         super();
         let raw: RawGroup;
 
         if (options && "fromRaw" in options) {
             raw = options.fromRaw;
         } else {
-            const initOwner = options?.owner || init?.owner;
+            const initOwner = options.owner;
             if (!initOwner) throw new Error("No owner provided");
             if (
                 initOwner instanceof Account &&
@@ -110,7 +121,7 @@ export class Group<
                 raw = rawOwner.createGroup();
             } else {
                 throw new Error(
-                    "Can only construct group as a controlled account"
+                    "Can only construct group as a controlled account",
                 );
             }
         }
@@ -125,15 +136,111 @@ export class Group<
 
         return new Proxy(
             this,
-            AccountAndGroupProxyHandler as ProxyHandler<this>
+            AccountAndGroupProxyHandler as ProxyHandler<this>,
         );
     }
 
+    static create<G extends Group>(
+        this: CoValueClass<G>,
+        options: { owner: Account },
+    ) {
+        return new this(options);
+    }
+
     myRole(): Role | undefined {
         return this._raw.myRole();
     }
 
     addMember(member: Everyone | Account, role: Role) {
         this._raw.addMember(member === "everyone" ? member : member._raw, role);
+        return this;
+    }
+
+    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, "members." + id);
+
+                return {
+                    id: id as unknown as Everyone | ID<this[MembersSym]>,
+                    role,
+                    ref,
+                    get account() {
+                        return accessRef();
+                    },
+                };
+            });
+    }
+
+    /** @category Subscription & Loading */
+    static load<G extends Group, Depth>(
+        this: CoValueClass<G>,
+        id: ID<G>,
+        as: Account,
+        depth: Depth & DepthsIn<G>,
+    ): Promise<DeeplyLoaded<G, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<G extends Group, Depth>(
+        this: CoValueClass<G>,
+        id: ID<G>,
+        depth: Depth & DepthsIn<G>,
+    ): Effect.Effect<DeeplyLoaded<G, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<G, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<G extends Group, Depth>(
+        this: CoValueClass<G>,
+        id: ID<G>,
+        as: Account,
+        depth: Depth & DepthsIn<G>,
+        listener: (value: DeeplyLoaded<G, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<G, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<G extends Group, Depth>(
+        this: CoValueClass<G>,
+        id: ID<G>,
+        depth: Depth & DepthsIn<G>,
+    ): Stream.Stream<DeeplyLoaded<G, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<G, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<G extends Group, Depth>(
+        this: G,
+        depth: Depth & DepthsIn<G>,
+    ): Promise<DeeplyLoaded<G, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<G extends Group, Depth>(
+        this: G,
+        depth: Depth & DepthsIn<G>,
+        listener: (value: DeeplyLoaded<G, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
     }
 }