jazz-tools 0.7.23 → 0.7.25

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

@@ -23,7 +23,7 @@ const optional = {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
-    encoded<T>(arg: OptionalEncoder<T>): co<T> {
+    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;
     },

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/coMap.test.ts

@@ -26,6 +26,7 @@ describe("Simple CoMap operations", async () => {
         birthday = co.encoded(Encoders.Date);
         name? = co.string;
         nullable = co.optional.encoded(Schema.NullishOr(Schema.String));
+        optionalDate = co.optional.encoded(Encoders.Date);
 
         get roughColor() {
             return this.color + "ish";
@@ -576,3 +577,163 @@ describe("CoMap resolution", async () => {
         ]);
     });
 });
+
+describe("CoMap applyDiff", async () => {
+    const me = await Account.create({
+        creationProps: { name: "Tester McTesterson" },
+        crypto: Crypto,
+    });
+
+    class TestMap extends CoMap {
+        name = co.string;
+        age = co.number;
+        isActive = co.boolean;
+        birthday = co.encoded(Encoders.Date);
+        nested = co.ref(NestedMap);
+        optionalField = co.optional.string;
+    }
+
+    class NestedMap extends CoMap {
+        value = co.string;
+    }
+
+    test("Basic applyDiff", () => {
+        const map = TestMap.create(
+            {
+                name: "Alice",
+                age: 30,
+                isActive: true,
+                birthday: new Date("1990-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            name: "Bob",
+            age: 35,
+            isActive: false,
+        };
+
+        map.applyDiff(newValues);
+
+        expect(map.name).toEqual("Bob");
+        expect(map.age).toEqual(35);
+        expect(map.isActive).toEqual(false);
+        expect(map.birthday).toEqual(new Date("1990-01-01"));
+        expect(map.nested?.value).toEqual("original");
+    });
+
+    test("applyDiff with nested changes", () => {
+        const map = TestMap.create(
+            {
+                name: "Charlie",
+                age: 25,
+                isActive: true,
+                birthday: new Date("1995-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            name: "David",
+            nested: NestedMap.create({ value: "updated" }, { owner: me }),
+        };
+
+        map.applyDiff(newValues);
+
+        expect(map.name).toEqual("David");
+        expect(map.age).toEqual(25);
+        expect(map.nested?.value).toEqual("updated");
+    });
+
+    test("applyDiff with encoded fields", () => {
+        const map = TestMap.create(
+            {
+                name: "Eve",
+                age: 28,
+                isActive: true,
+                birthday: new Date("1993-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            birthday: new Date("1993-06-15"),
+        };
+
+        map.applyDiff(newValues);
+
+        expect(map.birthday).toEqual(new Date("1993-06-15"));
+    });
+
+    test("applyDiff with optional fields", () => {
+        const map = TestMap.create(
+            {
+                name: "Frank",
+                age: 40,
+                isActive: true,
+                birthday: new Date("1980-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            optionalField: "New optional value",
+        };
+
+        map.applyDiff(newValues);
+
+        expect(map.optionalField).toEqual("New optional value");
+
+        map.applyDiff({ optionalField: undefined });
+
+        expect(map.optionalField).toBeUndefined();
+    });
+
+    test("applyDiff with no changes", () => {
+        const map = TestMap.create(
+            {
+                name: "Grace",
+                age: 35,
+                isActive: true,
+                birthday: new Date("1985-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const originalJSON = map.toJSON();
+
+        map.applyDiff({});
+
+        expect(map.toJSON()).toEqual(originalJSON);
+    });
+
+    test("applyDiff with invalid field", () => {
+        const map = TestMap.create(
+            {
+                name: "Henry",
+                age: 45,
+                isActive: false,
+                birthday: new Date("1975-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            name: "Ian",
+            invalidField: "This should be ignored",
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map.applyDiff(newValues as any);
+
+        expect(map.name).toEqual("Ian");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect((map as any).invalidField).toBeUndefined();
+    });
+});