jazz-tools 0.7.25 → 0.7.28

package/src/coValues/coStream.ts

@@ -35,7 +35,6 @@ import {
     ensureCoValueLoaded,
     subscribeToExistingCoValue,
 } from "../internal.js";
-import { encodeSync, decodeSync } from "@effect/schema/Schema";
 
 export type CoStreamEntry<Item> = SingleCoStreamEntry<Item> & {
     all: IterableIterator<SingleCoStreamEntry<Item>>;
@@ -141,7 +140,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
         } else if ("encoded" in itemDescriptor) {
-            this._raw.push(encodeSync(itemDescriptor.encoded)(item));
+            this._raw.push(itemDescriptor.encoded.encode(item));
         } else if (isRefEncoded(itemDescriptor)) {
             this._raw.push((item as unknown as CoValue).id);
         }
@@ -153,7 +152,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
             itemDescriptor === "json"
                 ? (v: unknown) => v
                 : "encoded" in itemDescriptor
-                  ? encodeSync(itemDescriptor.encoded)
+                  ? itemDescriptor.encoded.encode
                   : (v: unknown) => v && (v as CoValue).id;
 
         return {
@@ -247,7 +246,7 @@ function entryFromRawEntry<Item>(
                     ? (CoValue & Item) | null
                     : Item;
             } else if ("encoded" in itemField) {
-                return decodeSync(itemField.encoded)(rawEntry.value);
+                return itemField.encoded.decode(rawEntry.value);
             } else if (isRefEncoded(itemField)) {
                 return this.ref?.accessFrom(
                     accessFrom,

package/src/coValues/interfaces.ts

@@ -122,7 +122,12 @@ export class CoValueBase implements CoValue {
     castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
         cl: Cl,
     ): InstanceType<Cl> {
-        return cl.fromRaw(this._raw) as InstanceType<Cl>;
+        const casted = cl.fromRaw(this._raw) as InstanceType<Cl>;
+        const subscriptionScope = subscriptionsScopes.get(this);
+        if (subscriptionScope) {
+            subscriptionsScopes.set(casted, subscriptionScope);
+        }
+        return casted;
     }
 }
 

package/src/implementation/schema.ts

@@ -5,7 +5,6 @@ import {
     isCoValueClass,
     CoValueFromRaw,
 } from "../internal.js";
-import type { Schema as EffectSchema, TypeId } from "@effect/schema/Schema";
 
 export type CoMarker = { readonly __co: unique symbol };
 /** @category Schema definition */
@@ -113,7 +112,7 @@ function ref<
 }
 
 export type JsonEncoded = "json";
-export type EncodedAs<V> = { encoded: Encoder<V> };
+export type EncodedAs<V> = { encoded: Encoder<V> | OptionalEncoder<V> };
 export type RefEncoded<V extends CoValue> = {
     ref: CoValueClass<V> | ((raw: RawCoValue) => CoValueClass<V>);
     optional: boolean;
@@ -152,31 +151,23 @@ export type SchemaFor<Field> = NonNullable<Field> extends CoValue
       ? JsonEncoded
       : EncodedAs<NonNullable<Field>>;
 
-export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    any,
-    never
-> & {
-    [TypeId]: {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        _A: (_: any) => A;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        _I: (_: any) => I;
-    };
+export type Encoder<V> = {
+    encode: (value: V) => JsonValue;
+    decode: (value: JsonValue) => V;
 };
+export type OptionalEncoder<V> =
+    | Encoder<V>
+    | {
+          encode: (value: V | undefined) => JsonValue;
+          decode: (value: JsonValue) => V | undefined;
+      };
 
-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";
 
 /** @category Schema definition */
 export const Encoders = {
-    Date,
+    Date: {
+        encode: (value: Date) => value.toISOString(),
+        decode: (value: JsonValue) => new Date(value as string),
+    },
 };

package/src/tests/coList.test.ts

@@ -1,12 +1,12 @@
 import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
-import { Effect, Queue } from "effect";
 import {
     Account,
     CoList,
     WasmCrypto,
     co,
+    cojsonInternals,
     isControlledAccount,
 } from "../index.js";
 
@@ -157,11 +157,13 @@ describe("CoList resolution", async () => {
     test("Loading and availability", async () => {
         const { me, list } = await initNodeAndList();
 
-        const [initialAsPeer, secondPeer] = await Effect.runPromise(
-            connectedPeers("initial", "second", {
+        const [initialAsPeer, secondPeer] = connectedPeers(
+            "initial",
+            "second",
+            {
                 peer1role: "server",
                 peer2role: "client",
-            }),
+            },
         );
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
@@ -217,11 +219,13 @@ describe("CoList resolution", async () => {
     test("Subscription & auto-resolution", async () => {
         const { me, list } = await initNodeAndList();
 
-        const [initialAsPeer, secondPeer] = await Effect.runPromise(
-            connectedPeers("initial", "second", {
+        const [initialAsPeer, secondPeer] = connectedPeers(
+            "initial",
+            "second",
+            {
                 peer1role: "server",
                 peer2role: "client",
-            }),
+            },
         );
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
@@ -236,63 +240,52 @@ describe("CoList resolution", async () => {
             crypto: Crypto,
         });
 
-        await Effect.runPromise(
-            Effect.gen(function* ($) {
-                const queue = yield* $(Queue.unbounded<TestList>());
-
-                TestList.subscribe(
-                    list.id,
-                    meOnSecondPeer,
-                    [],
-                    (subscribedList) => {
-                        console.log(
-                            "subscribedList?.[0]?.[0]?.[0]",
-                            subscribedList?.[0]?.[0]?.[0],
-                        );
-                        void Effect.runPromise(
-                            Queue.offer(queue, subscribedList),
-                        );
-                    },
-                );
-
-                const update1 = yield* $(Queue.take(queue));
-                expect(update1?.[0]).toBe(null);
-
-                const update2 = yield* $(Queue.take(queue));
-                expect(update2?.[0]).toBeDefined();
-                expect(update2?.[0]?.[0]).toBe(null);
-
-                const update3 = yield* $(Queue.take(queue));
-                expect(update3?.[0]?.[0]).toBeDefined();
-                expect(update3?.[0]?.[0]?.[0]).toBe("a");
-                expect(update3?.[0]?.[0]?.joined()).toBe("a,b");
-
-                update3[0]![0]![0] = "x";
-
-                const update4 = yield* $(Queue.take(queue));
-                expect(update4?.[0]?.[0]?.[0]).toBe("x");
-
-                // When assigning a new nested value, we get an update
-
-                const newTwiceNestedList = TwiceNestedList.create(["y", "z"], {
-                    owner: meOnSecondPeer,
-                });
-
-                const newNestedList = NestedList.create([newTwiceNestedList], {
-                    owner: meOnSecondPeer,
-                });
-
-                update4[0] = newNestedList;
-
-                const update5 = yield* $(Queue.take(queue));
-                expect(update5?.[0]?.[0]?.[0]).toBe("y");
-                expect(update5?.[0]?.[0]?.joined()).toBe("y,z");
-
-                // we get updates when the new nested value changes
-                newTwiceNestedList[0] = "w";
-                const update6 = yield* $(Queue.take(queue));
-                expect(update6?.[0]?.[0]?.[0]).toBe("w");
-            }),
-        );
+        const queue = new cojsonInternals.Channel();
+
+        TestList.subscribe(list.id, meOnSecondPeer, [], (subscribedList) => {
+            console.log(
+                "subscribedList?.[0]?.[0]?.[0]",
+                subscribedList?.[0]?.[0]?.[0],
+            );
+            void queue.push(subscribedList);
+        });
+
+        const update1 = (await queue.next()).value;
+        expect(update1?.[0]).toBe(null);
+
+        const update2 = (await queue.next()).value;
+        expect(update2?.[0]).toBeDefined();
+        expect(update2?.[0]?.[0]).toBe(null);
+
+        const update3 = (await queue.next()).value;
+        expect(update3?.[0]?.[0]).toBeDefined();
+        expect(update3?.[0]?.[0]?.[0]).toBe("a");
+        expect(update3?.[0]?.[0]?.joined()).toBe("a,b");
+
+        update3[0]![0]![0] = "x";
+
+        const update4 = (await queue.next()).value;
+        expect(update4?.[0]?.[0]?.[0]).toBe("x");
+
+        // When assigning a new nested value, we get an update
+
+        const newTwiceNestedList = TwiceNestedList.create(["y", "z"], {
+            owner: meOnSecondPeer,
+        });
+
+        const newNestedList = NestedList.create([newTwiceNestedList], {
+            owner: meOnSecondPeer,
+        });
+
+        update4[0] = newNestedList;
+
+        const update5 = (await queue.next()).value;
+        expect(update5?.[0]?.[0]?.[0]).toBe("y");
+        expect(update5?.[0]?.[0]?.joined()).toBe("y,z");
+
+        // we get updates when the new nested value changes
+        newTwiceNestedList[0] = "w";
+        const update6 = (await queue.next()).value;
+        expect(update6?.[0]?.[0]?.[0]).toBe("w");
     });
 });

package/src/tests/coMap.test.ts

@@ -1,7 +1,6 @@
 import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
-import { Effect, Queue } from "effect";
 import {
     Account,
     Encoders,
@@ -9,8 +8,8 @@ import {
     co,
     WasmCrypto,
     isControlledAccount,
+    cojsonInternals,
 } from "../index.js";
-import { Schema } from "@effect/schema";
 
 const Crypto = await WasmCrypto.create();
 
@@ -25,7 +24,10 @@ describe("Simple CoMap operations", async () => {
         _height = co.number;
         birthday = co.encoded(Encoders.Date);
         name? = co.string;
-        nullable = co.optional.encoded(Schema.NullishOr(Schema.String));
+        nullable = co.optional.encoded<string | undefined>({
+            encode: (value: string | undefined) => value || null,
+            decode: (value: unknown) => (value as string) || undefined,
+        });
         optionalDate = co.optional.encoded(Encoders.Date);
 
         get roughColor() {
@@ -42,7 +44,7 @@ describe("Simple CoMap operations", async () => {
             color: "red",
             _height: 10,
             birthday: birthday,
-            nullable: null,
+            nullable: undefined,
         },
         { owner: me },
     );
@@ -94,7 +96,7 @@ describe("Simple CoMap operations", async () => {
             expect(map._raw.get("_height")).toEqual(20);
 
             map.nullable = "not null";
-            map.nullable = null;
+            map.nullable = undefined;
             delete map.nullable;
             map.nullable = undefined;
 
@@ -282,12 +284,12 @@ describe("CoMap resolution", async () => {
 
     test("Loading and availability", async () => {
         const { me, map } = await initNodeAndMap();
-        const [initialAsPeer, secondPeer] = await Effect.runPromise(
+        const [initialAsPeer, secondPeer] =
             connectedPeers("initial", "second", {
                 peer1role: "server",
                 peer2role: "client",
-            }),
-        );
+            });
+
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
         }
@@ -353,12 +355,12 @@ describe("CoMap resolution", async () => {
     test("Subscription & auto-resolution", async () => {
         const { me, map } = await initNodeAndMap();
 
-        const [initialAsPeer, secondAsPeer] = await Effect.runPromise(
+        const [initialAsPeer, secondAsPeer] =
             connectedPeers("initial", "second", {
                 peer1role: "server",
                 peer2role: "client",
-            }),
-        );
+            });
+
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
         }
@@ -372,9 +374,8 @@ describe("CoMap resolution", async () => {
             crypto: Crypto,
         });
 
-        await Effect.runPromise(
-            Effect.gen(function* ($) {
-                const queue = yield* $(Queue.unbounded<TestMap>());
+
+                const queue = new cojsonInternals.Channel<TestMap>();
 
                 TestMap.subscribe(
                     map.id,
@@ -385,22 +386,20 @@ describe("CoMap resolution", async () => {
                             "subscribedMap.nested?.twiceNested?.taste",
                             subscribedMap.nested?.twiceNested?.taste,
                         );
-                        void Effect.runPromise(
-                            Queue.offer(queue, subscribedMap),
-                        );
+                        void queue.push(subscribedMap);
                     },
                 );
 
-                const update1 = yield* $(Queue.take(queue));
+                const update1 = (await queue.next()).value;
                 expect(update1.nested).toEqual(null);
 
-                const update2 = yield* $(Queue.take(queue));
+                const update2 = (await queue.next()).value;
                 expect(update2.nested?.name).toEqual("nested");
 
                 map.nested!.name = "nestedUpdated";
 
-                const _ = yield* $(Queue.take(queue));
-                const update3 = yield* $(Queue.take(queue));
+                const _ = (await queue.next()).value;
+                const update3 = (await queue.next()).value;
                 expect(update3.nested?.name).toEqual("nestedUpdated");
 
                 const oldTwiceNested = update3.nested!.twiceNested;
@@ -424,23 +423,21 @@ describe("CoMap resolution", async () => {
 
                 update3.nested = newNested;
 
-                yield* $(Queue.take(queue));
-                // const update4 = yield* $(Queue.take(queue));
-                const update4b = yield* $(Queue.take(queue));
+                (await queue.next()).value;
+                // const update4 = (await queue.next()).value;
+                const update4b = (await queue.next()).value;
 
                 expect(update4b.nested?.name).toEqual("newNested");
                 expect(update4b.nested?.twiceNested?.taste).toEqual("sweet");
 
                 // we get updates when the new nested value changes
                 newTwiceNested.taste = "salty";
-                const update5 = yield* $(Queue.take(queue));
+                const update5 = (await queue.next()).value;
                 expect(update5.nested?.twiceNested?.taste).toEqual("salty");
 
                 newTwiceNested.taste = "umami";
-                const update6 = yield* $(Queue.take(queue));
+                const update6 = (await queue.next()).value;
                 expect(update6.nested?.twiceNested?.taste).toEqual("umami");
-            }),
-        );
     });
 
     class TestMapWithOptionalRef extends CoMap {