jazz-tools 0.7.1 → 0.7.6

package/src/coValues/interfaces.ts

@@ -13,74 +13,29 @@ import {
 } from "../internal.js";
 import { fulfillsDepth } from "./deepLoading.js";
 
-export type ClassOf<T> = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new (...args: any[]): T;
-};
-
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
-    new (init: Init, options: { owner: Account | Group }): Value;
-
+export interface CoValueClass<Value extends CoValue = CoValue> {
     /** @ignore */
-    fromRaw(raw: Value["_raw"]): Value;
-
-    /** @category Subscription & Loading */
-    load<V extends Value, Depth>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        as: Account,
-        depth: Depth & DepthsIn<V>,
-    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
-    /** @category Subscription & Loading */
-    load<V extends Value, Depth>(
-        this: ClassOf<V>,
-        existing: V,
-        depth: Depth & DepthsIn<V>,
-    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
-
-    /** @category Subscription & Loading */
-    loadEf<V extends Value, Depth>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        depth: Depth & DepthsIn<V>,
-    ): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx>;
-
-    /** @category Subscription & Loading */
-    subscribe<V extends Value, Depth>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        as: Account,
-        depth: Depth & DepthsIn<V>,
-        listener: (value: DeeplyLoaded<V, Depth>) => void,
-    ): () => void;
-    subscribe<V extends Value, Depth>(
-        this: ClassOf<V>,
-        existing: V,
-        depth: Depth & DepthsIn<V>,
-        listener: (value: DeeplyLoaded<V, Depth>) => void,
-    ): () => void;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    new (...args: any[]): Value;
+}
 
-    /** @category Subscription & Loading */
-    subscribeEf<V extends Value, Depth>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        depth: Depth & DepthsIn<V>,
-    ): Stream.Stream<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx>;
+export interface CoValueFromRaw<V extends CoValue> {
+    fromRaw(raw: V["_raw"]): V;
 }
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface CoValue<Type extends string = string, Raw = any> {
+export interface CoValue {
     /** @category Content */
     readonly id: ID<this>;
     /** @category Type Helpers */
-    _type: Type;
+    _type: string;
     /** @category Collaboration */
     _owner: Account | Group;
     /** @category Internals */
-    _raw: Raw;
+    _raw: RawCoValue;
     /** @internal */
     readonly _loadedAs: Account;
     /** @category Stringifying & Inspection */
@@ -96,8 +51,10 @@ export function isCoValue(value: any): value is CoValue {
     return value && value._type !== undefined;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isCoValueClass(value: any): value is CoValueClass {
+export function isCoValueClass<V extends CoValue>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    value: any,
+): value is CoValueClass<V> & CoValueFromRaw<V> {
     return typeof value === "function" && value.fromRaw !== undefined;
 }
 
@@ -111,6 +68,7 @@ export class CoValueBase implements CoValue {
     id!: ID<this>;
     _type!: string;
     _raw!: RawCoValue;
+    /** @category Internals */
     _instanceID!: string;
 
     get _owner(): Account | Group {
@@ -142,156 +100,13 @@ export class CoValueBase implements CoValue {
     }
 
     /** @category Internals */
-    static fromRaw<V extends CoValue>(this: ClassOf<V>, raw: RawCoValue): V {
+    static fromRaw<V extends CoValue>(
+        this: CoValueClass<V>,
+        raw: RawCoValue,
+    ): V {
         return new this({ fromRaw: raw });
     }
 
-    /** @category Subscription & Loading */
-    static load<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        id: ID<V>,
-        as: Account,
-        depth: Depth & DepthsIn<V>,
-    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
-    /** @category Subscription & Loading */
-    static load<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        existing: V,
-        depth: Depth & DepthsIn<V>,
-    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
-    static load<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-
-        ...args:
-            | [ID<V>, Account, Depth & DepthsIn<V>]
-            | [V, Depth & DepthsIn<V>]
-    ): Promise<DeeplyLoaded<V, Depth> | undefined> {
-        const { id, as, depth } =
-            args.length === 3
-                ? { id: args[0], as: args[1], depth: args[2] }
-                : { id: args[0].id, as: args[0]._loadedAs, depth: args[1] };
-        return Effect.runPromise(
-            this.loadEf(id, depth).pipe(
-                Effect.mapError(() => undefined),
-                Effect.merge,
-                Effect.provideService(AccountCtx, as),
-            ),
-        );
-    }
-
-    /** @category Subscription & Loading */
-    static loadEf<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        id: ID<V>,
-        depth: Depth & DepthsIn<V>,
-    ): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
-        return this.subscribeEf(id, depth).pipe(
-            Stream.runHead,
-            Effect.andThen(
-                Effect.mapError((_noSuchElem) => "unavailable" as const),
-            ),
-        );
-    }
-
-    /** @category Subscription & Loading */
-    static subscribe<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        id: ID<V>,
-        as: Account,
-        depth: Depth & DepthsIn<V>,
-        listener: (value: DeeplyLoaded<V, Depth>) => void,
-    ): () => void;
-    static subscribe<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        existing: V,
-        depth: Depth & DepthsIn<V>,
-        listener: (value: DeeplyLoaded<V, Depth>) => void,
-    ): () => void;
-    static subscribe<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        ...args:
-            | [
-                  ID<V>,
-                  Account,
-                  Depth & DepthsIn<V>,
-                  (value: DeeplyLoaded<V, Depth>) => void,
-              ]
-            | [V, Depth & DepthsIn<V>, (value: DeeplyLoaded<V, Depth>) => void]
-    ): () => void {
-        const { id, as, depth, listener } =
-            args.length === 4
-                ? {
-                      id: args[0],
-                      as: args[1],
-                      depth: args[2],
-                      listener: args[3],
-                  }
-                : {
-                      id: args[0].id,
-                      as: args[0]._loadedAs,
-                      depth: args[1],
-                      listener: args[2],
-                  };
-        void Effect.runPromise(
-            Effect.provideService(
-                this.subscribeEf(id, depth).pipe(
-                    Stream.run(
-                        Sink.forEach((update) =>
-                            Effect.sync(() => listener(update)),
-                        ),
-                    ),
-                ),
-                AccountCtx,
-                as,
-            ),
-        );
-
-        return function unsubscribe() {};
-    }
-
-    /** @category Subscription & Loading */
-    static subscribeEf<V extends CoValue, Depth>(
-        this: ClassOf<V> & typeof CoValueBase,
-        id: ID<V>,
-        depth: Depth & DepthsIn<V>,
-    ): Stream.Stream<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
-        return AccountCtx.pipe(
-            Effect.andThen((account) =>
-                new Ref(id, account, {
-                    ref: this as CoValueClass<V>,
-                    optional: false,
-                }).loadEf(),
-            ),
-            Stream.fromEffect,
-            Stream.flatMap((value: V) =>
-                Stream.asyncScoped<V, UnavailableError>((emit) =>
-                    Effect.gen(this, function* (_) {
-                        const subscription = new SubscriptionScope(
-                            value,
-                            this,
-                            (update) => void emit.single(update as V),
-                        );
-
-                        yield* _(
-                            Effect.addFinalizer(() =>
-                                Effect.sync(() =>
-                                    subscription.unsubscribeAll(),
-                                ),
-                            ),
-                        );
-                    }),
-                ),
-            ),
-            Stream.filterMap((update: V) =>
-                Option.fromNullable(
-                    fulfillsDepth(depth, update)
-                        ? (update as DeeplyLoaded<V, Depth>)
-                        : undefined,
-                ),
-            ),
-        );
-    }
-
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON(): object | any[] {
         return {
@@ -305,13 +120,128 @@ export class CoValueBase implements CoValue {
         return this.toJSON();
     }
 
-    /** @category Type Helpers*/
-    as<C extends CoValueClass>(otherSchema: C): InstanceType<C> {
-        const cast = otherSchema.fromRaw(this._raw) as InstanceType<C>;
-        const subScope = subscriptionsScopes.get(this);
-        if (subScope) {
-            subscriptionsScopes.set(cast, subScope);
-        }
-        return cast;
+    /** @category Type Helpers */
+    castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
+        cl: Cl,
+    ): InstanceType<Cl> {
+        return cl.fromRaw(this._raw) as InstanceType<Cl>;
     }
 }
+
+export function loadCoValue<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    as: Account,
+    depth: Depth & DepthsIn<V>,
+): Promise<DeeplyLoaded<V, Depth> | undefined> {
+    return Effect.runPromise(
+        loadCoValueEf(cls, id, depth).pipe(
+            Effect.mapError(() => undefined),
+            Effect.merge,
+            Effect.provideService(AccountCtx, as),
+        ),
+    );
+}
+
+export function ensureCoValueLoaded<V extends CoValue, Depth>(
+    existing: V,
+    depth: Depth & DepthsIn<V>,
+): Promise<DeeplyLoaded<V, Depth> | undefined> {
+    return loadCoValue(
+        existing.constructor as CoValueClass<V>,
+        existing.id,
+        existing._loadedAs,
+        depth,
+    );
+}
+
+export function loadCoValueEf<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    depth: Depth & DepthsIn<V>,
+): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
+    return subscribeToCoValueEf(cls, id, depth).pipe(
+        Stream.runHead,
+        Effect.andThen(
+            Effect.mapError((_noSuchElem) => "unavailable" as const),
+        ),
+    );
+}
+
+export function subscribeToCoValue<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    as: Account,
+    depth: Depth & DepthsIn<V>,
+    listener: (value: DeeplyLoaded<V, Depth>) => void,
+): () => void {
+    void Effect.runPromise(
+        Effect.provideService(
+            subscribeToCoValueEf(cls, id, depth).pipe(
+                Stream.run(
+                    Sink.forEach((update) =>
+                        Effect.sync(() => listener(update)),
+                    ),
+                ),
+            ),
+            AccountCtx,
+            as,
+        ),
+    );
+
+    return function unsubscribe() {};
+}
+
+export function subscribeToExistingCoValue<V extends CoValue, Depth>(
+    existing: V,
+    depth: Depth & DepthsIn<V>,
+    listener: (value: DeeplyLoaded<V, Depth>) => void,
+): () => void {
+    return subscribeToCoValue(
+        existing.constructor as CoValueClass<V>,
+        existing.id,
+        existing._loadedAs,
+        depth,
+        listener,
+    );
+}
+
+export function subscribeToCoValueEf<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    depth: Depth & DepthsIn<V>,
+): Stream.Stream<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
+    return AccountCtx.pipe(
+        Effect.andThen((account) =>
+            new Ref(id, account, {
+                ref: cls,
+                optional: false,
+            }).loadEf(),
+        ),
+        Stream.fromEffect,
+        Stream.flatMap((value: V) =>
+            Stream.asyncScoped<V, UnavailableError>((emit) =>
+                Effect.gen(function* (_) {
+                    const subscription = new SubscriptionScope(
+                        value,
+                        cls as CoValueClass<V> & CoValueFromRaw<V>,
+                        (update) => void emit.single(update as V),
+                    );
+
+                    yield* _(
+                        Effect.addFinalizer(() =>
+                            Effect.sync(() => subscription.unsubscribeAll()),
+                        ),
+                    );
+                }),
+            ),
+        ),
+        Stream.filterMap((update: V) =>
+            Option.fromNullable(
+                fulfillsDepth(depth, update)
+                    ? (update as DeeplyLoaded<V, Depth>)
+                    : undefined,
+            ),
+        ),
+    );
+}

package/src/implementation/schema.ts

@@ -3,6 +3,7 @@ import {
     type CoValue,
     type CoValueClass,
     isCoValueClass,
+    CoValueFromRaw,
 } from "../internal.js";
 import type { Schema as EffectSchema, TypeId } from "@effect/schema/Schema";
 
@@ -96,11 +97,13 @@ export function instantiateRefEncoded<V extends CoValue>(
     schema: RefEncoded<V>,
     raw: RawCoValue,
 ): V {
-    return isCoValueClass(schema.ref)
+    return isCoValueClass<V>(schema.ref)
         ? schema.ref.fromRaw(raw)
-        : (schema.ref as (raw: RawCoValue) => CoValueClass<V>)(raw).fromRaw(
-              raw,
-          );
+        : (
+              schema.ref as (
+                  raw: RawCoValue,
+              ) => CoValueClass<V> & CoValueFromRaw<V>
+          )(raw).fromRaw(raw);
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/implementation/subscriptionScope.ts

@@ -2,9 +2,9 @@ import type { RawCoValue } from "cojson";
 import type {
     Account,
     CoValue,
-    CoValueBase,
     ID,
-    ClassOf,
+    CoValueClass,
+    CoValueFromRaw,
 } from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
@@ -35,7 +35,7 @@ export class SubscriptionScope<Root extends CoValue> {
 
     constructor(
         root: Root,
-        rootSchema: ClassOf<Root> & typeof CoValueBase,
+        rootSchema: CoValueClass<Root> & CoValueFromRaw<Root>,
         onUpdate: (newRoot: Root) => void,
     ) {
         this.rootEntry = {

package/src/index.ts

@@ -25,3 +25,10 @@ export { Account, isControlledAccount } from "./internal.js";
 export { ImageDefinition } from "./internal.js";
 export { CoValueBase, type CoValueClass } from "./internal.js";
 export type { DepthsIn, DeeplyLoaded } from "./internal.js";
+
+export {
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+} from "./internal.js";

package/src/tests/deepLoading.test.ts

@@ -180,7 +180,10 @@ class CustomAccount extends Account {
     profile = co.ref(CustomProfile);
     root = co.ref(TestMap);
 
-    async migrate(creationProps?: { name: string } | undefined) {
+    async migrate(
+        this: CustomAccount,
+        creationProps?: { name: string } | undefined,
+    ) {
         if (creationProps) {
             this.profile = CustomProfile.create(
                 {
@@ -195,7 +198,7 @@ class CustomAccount extends Account {
             );
         }
 
-        const thisLoaded = await CustomAccount.load(this, {
+        const thisLoaded = await this.ensureLoaded({
             profile: { stream: [] },
             root: { list: [] },
         });
@@ -219,7 +222,7 @@ test("Deep loading within account", async () => {
         crypto: Crypto,
     });
 
-    const meLoaded = await CustomAccount.load(me, {
+    const meLoaded = await me.ensureLoaded({
         profile: { stream: [] },
         root: { list: [] },
     });

package/src/tests/groupsAndAccounts.test.ts

@@ -13,7 +13,7 @@ describe("Custom accounts and groups", async () => {
         profile = co.ref(CustomProfile);
         root = co.ref(CoMap);
 
-        migrate(creationProps?: { name: string }) {
+        migrate(this: CustomAccount, creationProps?: { name: string }) {
             if (creationProps) {
                 const profileGroup = Group.create({ owner: this });
                 profileGroup.addMember("everyone", "reader");
@@ -56,7 +56,7 @@ describe("Custom accounts and groups", async () => {
         expect(group.nMembers).toBe(2);
 
         await new Promise<void>((resolve) => {
-            CustomGroup.subscribe(group, {}, (update) => {
+            group.subscribe({}, (update) => {
                 const meAsMember = update.members.find((member) => {
                     return member.id === me.id && member.account?.profile;
                 });
@@ -77,7 +77,7 @@ describe("Custom accounts and groups", async () => {
         const map = MyMap.create({ name: "test" }, { owner: group });
 
         const meAsCastMember = map._owner
-            .as(CustomGroup)
+            .castAs(CustomGroup)
             .members.find((member) => member.id === me.id);
         expect(meAsCastMember?.account?.profile?.name).toBe(
             "Hermes Puggington",
@@ -86,6 +86,6 @@ describe("Custom accounts and groups", async () => {
 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         expect((map._owner as any).nMembers).toBeUndefined();
-        expect(map._owner.as(CustomGroup).nMembers).toBe(2);
+        expect(map._owner.castAs(CustomGroup).nMembers).toBe(2);
     });
 });