jazz-tools 0.7.1 → 0.7.6

package/src/coValues/coStream.ts

@@ -16,8 +16,12 @@ import type {
     Group,
     ID,
     IfCo,
-    ClassOf,
     UnCo,
+    AccountCtx,
+    CoValueClass,
+    DeeplyLoaded,
+    DepthsIn,
+    UnavailableError,
 } from "../internal.js";
 import {
     ItemsSym,
@@ -29,8 +33,15 @@ import {
     InitValues,
     SchemaInit,
     isRefEncoded,
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    ensureCoValueLoaded,
+    subscribeToExistingCoValue,
 } from "../internal.js";
 import { encodeSync, decodeSync } from "@effect/schema/Schema";
+import { Effect, Stream } from "effect";
 
 export type CoStreamEntry<Item> = SingleCoStreamEntry<Item> & {
     all: IterableIterator<SingleCoStreamEntry<Item>>;
@@ -46,10 +57,7 @@ export type SingleCoStreamEntry<Item> = {
 
 /** @category CoValues */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class CoStream<Item = any>
-    extends CoValueBase
-    implements CoValue<"CoStream", RawCoStream>
-{
+export class CoStream<Item = any> extends CoValueBase implements CoValue {
     static Of<Item>(item: IfCo<Item, Item>): typeof CoStream<Item> {
         return class CoStreamOf extends CoStream<Item> {
             [co.items] = item;
@@ -114,7 +122,7 @@ export class CoStream<Item = any>
     }
 
     static create<S extends CoStream>(
-        this: ClassOf<S>,
+        this: CoValueClass<S>,
         init: S extends CoStream<infer Item> ? UnCo<Item>[] : never,
         options: { owner: Account | Group },
     ) {
@@ -178,6 +186,62 @@ export class CoStream<Item = any>
         this._schema ||= {};
         Object.assign(this._schema, def);
     }
+
+    /** @category Subscription & Loading */
+    static load<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        as: Account,
+        depth: Depth & DepthsIn<S>,
+    ): Promise<DeeplyLoaded<S, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        depth: Depth & DepthsIn<S>,
+    ): Effect.Effect<DeeplyLoaded<S, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<S, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        as: Account,
+        depth: Depth & DepthsIn<S>,
+        listener: (value: DeeplyLoaded<S, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<S, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        depth: Depth & DepthsIn<S>,
+    ): Stream.Stream<DeeplyLoaded<S, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<S, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<S extends CoStream, Depth>(
+        this: S,
+        depth: Depth & DepthsIn<S>,
+    ): Promise<DeeplyLoaded<S, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<S extends CoStream, Depth>(
+        this: S,
+        depth: Depth & DepthsIn<S>,
+        listener: (value: DeeplyLoaded<S, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
+    }
 }
 
 function entryFromRawEntry<Item>(
@@ -437,10 +501,7 @@ const CoStreamPerSessionProxyHandler = (
 });
 
 /** @category CoValues */
-export class BinaryCoStream
-    extends CoValueBase
-    implements CoValue<"BinaryCoStream", RawBinaryCoStream>
-{
+export class BinaryCoStream extends CoValueBase implements CoValue {
     declare id: ID<this>;
     declare _type: "BinaryCoStream";
     declare _raw: RawBinaryCoStream;
@@ -476,7 +537,7 @@ export class BinaryCoStream
     }
 
     static create<S extends BinaryCoStream>(
-        this: ClassOf<S>,
+        this: CoValueClass<S>,
         options: { owner: Account | Group },
     ) {
         return new this(options);
@@ -584,4 +645,60 @@ export class BinaryCoStream
     [inspect]() {
         return this.toJSON();
     }
+
+    /** @category Subscription & Loading */
+    static load<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        as: Account,
+        depth: Depth & DepthsIn<B>,
+    ): Promise<DeeplyLoaded<B, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        depth: Depth & DepthsIn<B>,
+    ): Effect.Effect<DeeplyLoaded<B, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<B, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        as: Account,
+        depth: Depth & DepthsIn<B>,
+        listener: (value: DeeplyLoaded<B, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<B, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        depth: Depth & DepthsIn<B>,
+    ): Stream.Stream<DeeplyLoaded<B, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<B, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<B extends BinaryCoStream, Depth>(
+        this: B,
+        depth: Depth & DepthsIn<B>,
+    ): Promise<DeeplyLoaded<B, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<B extends BinaryCoStream, Depth>(
+        this: B,
+        depth: Depth & DepthsIn<B>,
+        listener: (value: DeeplyLoaded<B, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
+    }
 }

package/src/coValues/group.ts

@@ -1,5 +1,15 @@
 import type { AccountID, Everyone, RawGroup, Role } from "cojson";
-import type { CoValue, ID, RefEncoded, Schema, ClassOf } from "../internal.js";
+import type {
+    CoValue,
+    ID,
+    RefEncoded,
+    Schema,
+    AccountCtx,
+    CoValueClass,
+    DeeplyLoaded,
+    DepthsIn,
+    UnavailableError,
+} from "../internal.js";
 import {
     Account,
     CoMap,
@@ -9,7 +19,14 @@ import {
     isControlledAccount,
     AccountAndGroupProxyHandler,
     MembersSym,
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    ensureCoValueLoaded,
+    subscribeToExistingCoValue,
 } from "../internal.js";
+import { Effect, Stream } from "effect";
 
 /** @category Identity & Permissions */
 export class Profile extends CoMap {
@@ -17,7 +34,7 @@ export class Profile extends CoMap {
 }
 
 /** @category Identity & Permissions */
-export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
+export class Group extends CoValueBase implements CoValue {
     declare id: ID<this>;
     declare _type: "Group";
     static {
@@ -41,7 +58,7 @@ export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
             [MembersSym]: {
                 ref: () => Account,
                 optional: false,
-            } satisfies Schema,
+            } satisfies RefEncoded<Account>,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any;
         Object.defineProperty(this.prototype, "_schema", {
@@ -97,7 +114,7 @@ export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
             const initOwner = options.owner;
             if (!initOwner) throw new Error("No owner provided");
             if (
-                initOwner instanceof Account &&
+                initOwner._type === "Account" &&
                 isControlledAccount(initOwner)
             ) {
                 const rawOwner = initOwner._raw;
@@ -124,7 +141,7 @@ export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
     }
 
     static create<G extends Group>(
-        this: ClassOf<G>,
+        this: CoValueClass<G>,
         options: { owner: Account },
     ) {
         return new this(options);
@@ -170,4 +187,60 @@ export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
                 };
             });
     }
+
+    /** @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);
+    }
 }