jazz-tools 0.7.21 → 0.7.24

package/src/coValues/coMap.ts

@@ -11,8 +11,6 @@ import type {
     RefIfCoValue,
     DepthsIn,
     DeeplyLoaded,
-    UnavailableError,
-    AccountCtx,
     CoValueClass,
 } from "../internal.js";
 import {
@@ -26,13 +24,10 @@ import {
     ItemsSym,
     isRefEncoded,
     loadCoValue,
-    loadCoValueEf,
     subscribeToCoValue,
-    subscribeToCoValueEf,
     ensureCoValueLoaded,
     subscribeToExistingCoValue,
 } from "../internal.js";
-import { Effect, Stream } from "effect";
 
 type CoMapEdit<V> = {
     value?: V;
@@ -391,21 +386,6 @@ export class CoMap extends CoValueBase implements CoValue {
         return loadCoValue(this, id, as, depth);
     }
 
-    /**
-     * Effectful version of `CoMap.load()`.
-     *
-     * Needs to be run inside an `AccountCtx` context.
-     *
-     * @category Subscription & Loading
-     */
-    static loadEf<M extends CoMap, Depth>(
-        this: CoValueClass<M>,
-        id: ID<M>,
-        depth: Depth & DepthsIn<M>,
-    ): Effect.Effect<DeeplyLoaded<M, Depth>, UnavailableError, AccountCtx> {
-        return loadCoValueEf<M, Depth>(this, id, depth);
-    }
-
     /**
      * Load and subscribe to a `CoMap` with a given ID, as a given account.
      *
@@ -444,21 +424,6 @@ export class CoMap extends CoValueBase implements CoValue {
         return subscribeToCoValue<M, Depth>(this, id, as, depth, listener);
     }
 
-    /**
-     * Effectful version of `CoMap.subscribe()` that returns a stream of updates.
-     *
-     * Needs to be run inside an `AccountCtx` context.
-     *
-     * @category Subscription & Loading
-     */
-    static subscribeEf<M extends CoMap, Depth>(
-        this: CoValueClass<M>,
-        id: ID<M>,
-        depth: Depth & DepthsIn<M>,
-    ): Stream.Stream<DeeplyLoaded<M, Depth>, UnavailableError, AccountCtx> {
-        return subscribeToCoValueEf<M, Depth>(this, id, depth);
-    }
-
     /**
      * Given an already loaded `CoMap`, ensure that the specified fields are loaded to the specified depth.
      *

package/src/coValues/coStream.ts

@@ -17,11 +17,9 @@ import type {
     ID,
     IfCo,
     UnCo,
-    AccountCtx,
     CoValueClass,
     DeeplyLoaded,
     DepthsIn,
-    UnavailableError,
 } from "../internal.js";
 import {
     ItemsSym,
@@ -33,14 +31,11 @@ import {
     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>>;
@@ -202,15 +197,6 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
         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>,
@@ -222,15 +208,6 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
         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,
@@ -638,15 +615,6 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
         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>,
@@ -658,15 +626,6 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
         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,

package/src/coValues/group.ts

@@ -4,11 +4,9 @@ import type {
     ID,
     RefEncoded,
     Schema,
-    AccountCtx,
     CoValueClass,
     DeeplyLoaded,
     DepthsIn,
-    UnavailableError,
 } from "../internal.js";
 import {
     Account,
@@ -20,13 +18,10 @@ import {
     AccountAndGroupProxyHandler,
     MembersSym,
     loadCoValue,
-    loadCoValueEf,
     subscribeToCoValue,
-    subscribeToCoValueEf,
     ensureCoValueLoaded,
     subscribeToExistingCoValue,
 } from "../internal.js";
-import { Effect, Stream } from "effect";
 
 /** @category Identity & Permissions */
 export class Profile extends CoMap {
@@ -198,15 +193,6 @@ export class Group extends CoValueBase implements CoValue {
         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>,
@@ -218,15 +204,6 @@ export class Group extends CoValueBase implements CoValue {
         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,

package/src/coValues/interfaces.ts

@@ -1,10 +1,8 @@
-import { Effect, Option, Sink, Stream } from "effect";
 import type { CojsonInternalTypes, RawCoValue } from "cojson";
 import { RawAccount } from "cojson";
-import type { DeeplyLoaded, DepthsIn, UnavailableError } from "../internal.js";
+import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
     Account,
-    AccountCtx,
     Group,
     SubscriptionScope,
     Ref,
@@ -134,13 +132,22 @@ export function loadCoValue<V extends CoValue, Depth>(
     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),
-        ),
-    );
+    return new Promise((resolve) => {
+        const unsubscribe = subscribeToCoValue(
+            cls,
+            id,
+            as,
+            depth,
+            (value) => {
+                resolve(value);
+                unsubscribe();
+            },
+            () => {
+                resolve(undefined);
+                unsubscribe();
+            },
+        );
+    });
 }
 
 export function ensureCoValueLoaded<V extends CoValue, Depth>(
@@ -155,41 +162,46 @@ export function ensureCoValueLoaded<V extends CoValue, 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,
+    onUnavailable?: () => void,
 ): () => void {
-    void Effect.runPromise(
-        Effect.provideService(
-            subscribeToCoValueEf(cls, id, depth).pipe(
-                Stream.run(
-                    Sink.forEach((update) =>
-                        Effect.sync(() => listener(update)),
-                    ),
-                ),
-            ),
-            AccountCtx,
-            as,
-        ),
-    );
+    const ref = new Ref(id, as, { ref: cls, optional: false });
+
+    let unsubscribed = false;
+    let unsubscribe: (() => void) | undefined;
+
+    ref.load()
+        .then((value) => {
+            if (!value) {
+                onUnavailable && onUnavailable();
+                return;
+            }
+            if (unsubscribed) return;
+            const subscription = new SubscriptionScope(
+                value,
+                cls as CoValueClass<V> & CoValueFromRaw<V>,
+                (update) => {
+                    if (fulfillsDepth(depth, update)) {
+                        listener(update as DeeplyLoaded<V, Depth>);
+                    }
+                },
+            );
+
+            unsubscribe = () => subscription.unsubscribeAll();
+        })
+        .catch((e) => {
+            console.error("Failed to load / subscribe to CoValue", e);
+        });
 
-    return function unsubscribe() {};
+    return function unsubscribeAtAnyPoint() {
+        unsubscribed = true;
+        unsubscribe && unsubscribe();
+    };
 }
 
 export function subscribeToExistingCoValue<V extends CoValue, Depth>(
@@ -205,43 +217,3 @@ export function subscribeToExistingCoValue<V extends CoValue, 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/refs.ts

@@ -1,4 +1,3 @@
-import { Effect } from "effect";
 import type { CoID, RawCoValue } from "cojson";
 import type {
     Account,
@@ -6,7 +5,6 @@ import type {
     ID,
     RefEncoded,
     UnCo,
-    UnavailableError,
 } from "../internal.js";
 import {
     instantiateRefEncoded,
@@ -47,22 +45,6 @@ export class Ref<out V extends CoValue> {
         }
     }
 
-    loadEf() {
-        return Effect.async<V, UnavailableError>((fulfill) => {
-            this.loadHelper()
-                .then((value) => {
-                    if (value === "unavailable") {
-                        fulfill(Effect.fail<UnavailableError>("unavailable"));
-                    } else {
-                        fulfill(Effect.succeed(value));
-                    }
-                })
-                .catch((e) => {
-                    fulfill(Effect.die(e));
-                });
-        });
-    }
-
     private async loadHelper(options?: {
         onProgress: (p: number) => void;
     }): Promise<V | "unavailable"> {

package/src/implementation/schema.ts

@@ -17,6 +17,36 @@ export type IfCo<C, R> = C extends infer _A | infer B
     : never;
 export type UnCo<T> = T extends co<infer A> ? A : T;
 
+const optional = {
+    ref: optionalRef,
+    json<T extends JsonValue>(): co<T | undefined> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    encoded<T>(arg: OptionalEncoder<T>): co<T | undefined> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+    },
+    string: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<string | undefined>,
+    number: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<number | undefined>,
+    boolean: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<boolean | undefined>,
+    null: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<null | undefined>,
+    literal<T extends (string | number | boolean)[]>(
+        ..._lit: T
+    ): co<T[number] | undefined> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+};
+
 /** @category Schema definition */
 export const co = {
     string: {
@@ -48,8 +78,15 @@ export const co = {
     ref,
     items: ItemsSym as ItemsSym,
     members: MembersSym as MembersSym,
+    optional,
 };
 
+function optionalRef<C extends CoValueClass>(
+    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+): co<InstanceType<C> | null | undefined> {
+    return ref(arg, { optional: true });
+}
+
 function ref<C extends CoValueClass>(
     arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
 ): co<InstanceType<C> | null>;
@@ -131,6 +168,10 @@ export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
 };
 
 export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
+export type OptionalEncoder<V> = EffectSchemaWithInputAndOutput<
+    V,
+    JsonValue | undefined
+>;
 
 import { Date } from "@effect/schema/Schema";
 import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";

package/src/index.ts

@@ -26,9 +26,4 @@ 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";
+export { loadCoValue, subscribeToCoValue } from "./internal.js";

package/src/tests/coList.test.ts

@@ -157,11 +157,12 @@ describe("CoList resolution", async () => {
     test("Loading and availability", async () => {
         const { me, list } = await initNodeAndList();
 
-        const [initialAsPeer, secondPeer] = await Effect.runPromise(connectedPeers(
-            "initial",
-            "second",
-            { peer1role: "server", peer2role: "client" },
-        ));
+        const [initialAsPeer, secondPeer] = await Effect.runPromise(
+            connectedPeers("initial", "second", {
+                peer1role: "server",
+                peer2role: "client",
+            }),
+        );
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
         }
@@ -216,11 +217,12 @@ describe("CoList resolution", async () => {
     test("Subscription & auto-resolution", async () => {
         const { me, list } = await initNodeAndList();
 
-        const [initialAsPeer, secondPeer] = await Effect.runPromise(connectedPeers(
-            "initial",
-            "second",
-            { peer1role: "server", peer2role: "client" },
-        ));
+        const [initialAsPeer, secondPeer] = await Effect.runPromise(
+            connectedPeers("initial", "second", {
+                peer1role: "server",
+                peer2role: "client",
+            }),
+        );
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
         }

package/src/tests/coMap.test.ts

@@ -25,7 +25,8 @@ describe("Simple CoMap operations", async () => {
         _height = co.number;
         birthday = co.encoded(Encoders.Date);
         name? = co.string;
-        nullable = co.encoded(Schema.NullOr(Schema.String));
+        nullable = co.optional.encoded(Schema.NullishOr(Schema.String));
+        optionalDate = co.optional.encoded(Encoders.Date);
 
         get roughColor() {
             return this.color + "ish";
@@ -94,6 +95,8 @@ describe("Simple CoMap operations", async () => {
 
             map.nullable = "not null";
             map.nullable = null;
+            delete map.nullable;
+            map.nullable = undefined;
 
             map.name = "Secret name";
             expect(map.name).toEqual("Secret name");
@@ -442,7 +445,7 @@ describe("CoMap resolution", async () => {
 
     class TestMapWithOptionalRef extends CoMap {
         color = co.string;
-        nested = co.ref(NestedMap, { optional: true });
+        nested = co.optional.ref(NestedMap);
     }
 
     test("Construction with optional", async () => {

package/src/tests/deepLoading.test.ts

@@ -39,10 +39,12 @@ describe("Deep loading with depth arg", async () => {
         crypto: Crypto,
     });
 
-    const [initialAsPeer, secondPeer] = await Effect.runPromise(connectedPeers("initial", "second", {
-        peer1role: "server",
-        peer2role: "client",
-    }));
+    const [initialAsPeer, secondPeer] = await Effect.runPromise(
+        connectedPeers("initial", "second", {
+            peer1role: "server",
+            peer2role: "client",
+        }),
+    );
     if (!isControlledAccount(me)) {
         throw "me is not a controlled account";
     }
@@ -252,10 +254,12 @@ test("Deep loading a record-like coMap", async () => {
         crypto: Crypto,
     });
 
-    const [initialAsPeer, secondPeer] = await Effect.runPromise(connectedPeers("initial", "second", {
-        peer1role: "server",
-        peer2role: "client",
-    }));
+    const [initialAsPeer, secondPeer] = await Effect.runPromise(
+        connectedPeers("initial", "second", {
+            peer1role: "server",
+            peer2role: "client",
+        }),
+    );
     if (!isControlledAccount(me)) {
         throw "me is not a controlled account";
     }