jazz-tools 0.7.0-alpha.0 → 0.7.0-alpha.2

package/src/coValues/interfaces.ts

@@ -0,0 +1,216 @@
+import { Effect, Sink, Stream } from "effect";
+import type { CojsonInternalTypes, RawCoValue } from "cojson";
+import { RawAccount } from "cojson";
+import type { Me, UnavailableError } from "../internal.js";
+import {
+    Account,
+    AccountCtx,
+    Group,
+    SubscriptionScope,
+    ValueRef,
+    inspect,
+} from "../internal.js";
+
+export type SubclassedConstructor<T> = {
+    new (...args: any[]): T;
+};
+
+export interface CoValueClass<
+    Value extends CoValue = CoValue,
+    Init = any,
+> {
+    /** @category Construction and loading */
+    new (init: Init, options: { owner: Account | Group }): Value;
+
+    /** @ignore */
+    fromRaw(raw: Value["_raw"]): Value;
+
+    /** @category Construction and loading */
+    load<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>,
+        options: {
+            as: Account & Me;
+            onProgress?: (progress: number) => void;
+        }
+    ): Promise<V | undefined>;
+
+    /** @category Construction and loading */
+    loadEf<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>
+    ): Effect.Effect<V, UnavailableError, AccountCtx>;
+
+    /** @category Subscription */
+    subscribe<V extends Value, Acc extends Account>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>,
+        options: { as: Acc & Me },
+        onUpdate: (value: V) => void
+    ): () => void;
+
+    /** @category Subscription */
+    subscribeEf<V extends Value>(
+        this: SubclassedConstructor<V>,
+        id: ID<V>
+    ): Stream.Stream<V, UnavailableError, AccountCtx>;
+}
+
+/** @category Schemas & CoValues - Abstract interfaces */
+export interface CoValue<Type extends string = string, Raw = any> {
+    /** @category Value identity */
+    readonly id: ID<this>;
+    /** @category Value identity */
+    _type: Type;
+    /** @category Collaboration */
+    _owner: Account | Group;
+    /** @category Subscription */
+    subscribe(listener: (update: this) => void): () => void;
+    /** @category Subscription */
+    subscribeEf(): Stream.Stream<this, UnavailableError, never>;
+    /** @category Internals */
+    _raw: Raw;
+    /** @category Internals */
+    readonly _loadedAs: Account & Me;
+    /** @category Stringifying & inspection */
+    toJSON(): any[] | object;
+    /** @category Stringifying & inspection */
+    [inspect](): any;
+}
+
+export function isCoValue(value: any): value is CoValue {
+    return value && value._type !== undefined;
+}
+
+/** @category Schemas & CoValues - Abstract interfaces */
+export type ID<T> = CojsonInternalTypes.RawCoID & {
+    readonly __type: T;
+};
+
+export class CoValueBase implements CoValue {
+    id!: ID<this>;
+    _type!: string;
+    _raw!: RawCoValue;
+
+    get _owner(): Account | Group {
+        return this._raw.group instanceof RawAccount
+            ? Account.fromRaw(this._raw.group)
+            : Group.fromRaw(this._raw.group);
+    }
+
+    get _loadedAs() {
+        return Account.fromNode(this._raw.core.node);
+    }
+
+    constructor(..._args: any) {}
+
+    static fromRaw<V extends CoValue>(
+        this: SubclassedConstructor<V>,
+        raw: RawCoValue
+    ): V {
+        return new this(undefined, { fromRaw: raw });
+    }
+
+    static loadEf<V extends CoValue>(
+        this: SubclassedConstructor<V> & typeof CoValueBase,
+        id: ID<V>
+    ): Effect.Effect<V, UnavailableError, AccountCtx> {
+        return Effect.gen(this, function* (_) {
+            const account = yield* _(AccountCtx);
+            return yield* _(new ValueRef(id as ID<V>, account, this).loadEf());
+        });
+    }
+
+    static load<V extends CoValue>(
+        this: SubclassedConstructor<V> & typeof CoValueBase,
+        id: ID<V>,
+        options: {
+            as: Account & Me;
+            onProgress?: (progress: number) => void;
+        }
+    ): Promise<V | undefined> {
+        return new ValueRef(id as ID<V>, options.as, this).load(
+            options?.onProgress && { onProgress: options.onProgress }
+        );
+    }
+
+    static subscribe<V extends CoValue, Acc extends Account>(
+        this: SubclassedConstructor<V> & typeof CoValueBase,
+        id: ID<V>,
+        options: { as: Acc & Me },
+        onUpdate: (value: V) => void
+    ): () => void {
+        void Effect.runPromise(
+            Effect.provideService(
+                this.subscribeEf(id).pipe(
+                    Stream.run(
+                        Sink.forEach((update) =>
+                            Effect.sync(() => onUpdate(update))
+                        )
+                    )
+                ),
+                AccountCtx,
+                options.as as Account & Me
+            )
+        );
+
+        return function unsubscribe() {};
+    }
+
+    static subscribeEf<V extends CoValue>(
+        this: SubclassedConstructor<V> & typeof CoValueBase,
+        id: ID<V>
+    ): Stream.Stream<V, UnavailableError, AccountCtx> {
+        return Stream.fromEffect(this.loadEf(id)).pipe(
+            Stream.flatMap((value) =>
+                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())
+                            )
+                        );
+                    })
+                )
+            )
+        );
+    }
+
+    subscribe(listener: (update: this) => void): () => void {
+        return (this.constructor as unknown as typeof CoValueBase).subscribe(
+            this.id as unknown as ID<CoValue>,
+            { as: this._loadedAs },
+            listener as unknown as (update: CoValue) => void
+        );
+    }
+
+    subscribeEf(): Stream.Stream<this, UnavailableError, never> {
+        return Stream.provideService(
+            (this.constructor as unknown as typeof CoValueBase).subscribeEf(
+                this.id as unknown as ID<CoValue>
+            ),
+            AccountCtx,
+            this._loadedAs
+        ) as unknown as Stream.Stream<this, UnavailableError, never>;
+    }
+
+    toJSON(): object | any[] {
+        return {
+            id: this.id,
+            type: this._type,
+            error: "unknown CoValue class",
+        };
+    }
+
+    [inspect]() {
+        return this.toJSON();
+    }
+}

package/src/implementation/inspect.ts

@@ -0,0 +1,2 @@
+export const inspect = Symbol.for("nodejs.util.inspect.custom");
+export type inspect = typeof inspect;

package/src/{refs.ts → implementation/refs.ts}

@@ -1,19 +1,15 @@
 import { Effect } from "effect";
-import { CoValue, ID } from "./coValueInterfaces.js";
-import { ControlledAccount } from "./coValues/account/account.js";
-import { CoID, RawCoValue } from "cojson";
-import { UnavailableError } from "./errors.js";
-import { getCoValueConstructorInProperty } from "./coValues/resolution.js";
-import { PropDef } from "./schemaHelpers.js";
-import { subscriptionsScopes } from "./subscriptionScope.js";
+import type { CoID, RawCoValue } from "cojson";
+import type { Account, CoValue, ID, Me, SubclassedConstructor, UnavailableError, indexSignature} from '../internal.js';
+import { subscriptionsScopes } from '../internal.js';
 
 export class ValueRef<V extends CoValue> {
     private cachedValue: V | undefined;
 
     constructor(
         readonly id: ID<V>,
-        readonly controlledAccount: ControlledAccount,
-        readonly propDef: PropDef<any>
+        readonly controlledAccount: Account & Me,
+        readonly valueConstructor: SubclassedConstructor<V>
     ) {}
 
     get value() {
@@ -23,18 +19,11 @@ export class ValueRef<V extends CoValue> {
             this.id as unknown as CoID<RawCoValue>
         );
         if (raw) {
-            const Constructor = getCoValueConstructorInProperty(
-                this.propDef,
-                raw
-            );
-            if (!Constructor) {
-                throw new Error(
-                    "Couldn't extract CoValue constructor from property definition"
-                );
-            }
-            const value = new Constructor(undefined, { fromRaw: raw }) as V;
+            const value = new this.valueConstructor(undefined, { fromRaw: raw }) as V;
             this.cachedValue = value;
             return value;
+        } else {
+            return null;
         }
     }
 
@@ -62,7 +51,7 @@ export class ValueRef<V extends CoValue> {
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(this.id, this.controlledAccount, this.propDef)
+            return new ValueRef(this.id, this.controlledAccount, this.valueConstructor)
                 .value!;
         }
     }
@@ -76,7 +65,7 @@ export class ValueRef<V extends CoValue> {
         }
     }
 
-    accessFrom(fromScopeValue: CoValue): V | undefined {
+    accessFrom(fromScopeValue: CoValue): V | null {
         const subScope = subscriptionsScopes.get(fromScopeValue);
 
         subScope?.onRefAccessedOrSet(this.id);
@@ -89,13 +78,13 @@ export class ValueRef<V extends CoValue> {
     }
 }
 
-export function makeRefs<F extends { [key: string | number]: CoValue }>(
-    getIdForKey: <K extends keyof F>(key: K) => F[K]["id"] | undefined,
-    getKeysWithIds: () => (keyof F)[],
-    controlledAccount: ControlledAccount,
-    propDefForKey: <K extends keyof F>(key: K) => PropDef<F[K]>
-): { [K in keyof F]: ValueRef<F[K]> } {
-    const refs = {} as { [K in keyof F]: ValueRef<F[K]> };
+export function makeRefs<Keys extends string | number | indexSignature>(
+    getIdForKey: (key: Keys) => ID<CoValue> | undefined,
+    getKeysWithIds: () => Keys[],
+    controlledAccount: Account & Me,
+    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>,
+): { [K in Keys]: ValueRef<CoValue> } {
+    const refs = {} as { [K in Keys]: ValueRef<CoValue> };
     return new Proxy(refs, {
         get(target, key) {
             if (key === Symbol.iterator) {
@@ -104,7 +93,7 @@ export function makeRefs<F extends { [key: string | number]: CoValue }>(
                         yield new ValueRef(
                             getIdForKey(key)!,
                             controlledAccount,
-                            propDefForKey(key)
+                            valueConstructorForKey(key)
                         );
                     }
                 };
@@ -113,12 +102,12 @@ export function makeRefs<F extends { [key: string | number]: CoValue }>(
             if (key === "length") {
                 return getKeysWithIds().length;
             }
-            const id = getIdForKey(key as keyof F);
+            const id = getIdForKey(key as Keys);
             if (!id) return undefined;
             return new ValueRef(
-                id as ID<F[typeof key]>,
+                id as ID<CoValue>,
                 controlledAccount,
-                propDefForKey(key as keyof F)
+                valueConstructorForKey(key as Keys)
             );
         },
         ownKeys() {

package/src/implementation/schema.ts

@@ -0,0 +1,69 @@
+import type { JsonValue } from "cojson";
+import type { CoValue, CoValueClass } from "../internal.js";
+import type { Schema, TypeId } from "@effect/schema/Schema";
+
+export type PrimitiveField = "json";
+export type EncodedField<V> = { encoded: Encoder<V> };
+export type RefField<V extends CoValue> = {
+    ref: () => CoValueClass<V>;
+};
+
+export type FieldDescriptor =
+    | PrimitiveField
+    | RefField<CoValue>
+    | EncodedField<any>;
+
+export type FieldDescriptorFor<Field> = NonNullable<Field> extends CoValue
+    ? RefField<NonNullable<Field>>
+    : NonNullable<Field> extends JsonValue
+      ? PrimitiveField
+      : EncodedField<NonNullable<Field>>;
+
+export type EffectSchemaWithInputAndOutput<A, I = A> = Schema<
+    any,
+    any,
+    never
+> & {
+    [TypeId]: {
+        _A: (_: any) => A;
+        _I: (_: any) => I;
+    };
+};
+
+export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
+
+import { Date } from "@effect/schema/Schema";
+
+export const Encoders = {
+    Date,
+};
+
+export const indexSignature = Symbol.for("indexSignature");
+export type indexSignature = typeof indexSignature;
+
+export type EnsureCoValueNullable<
+    V,
+    Key extends string | indexSignature,
+> = NonNullable<V> extends CoValue
+    ? null extends V
+        ? V
+        : Key extends string
+          ? [
+                `👋 CoMap fields that are CoValue references should be nullable, declare ${Key} as:`,
+                V | null,
+            ]
+          : [
+                `👋 CoMap fields that are CoValue references should be nullable, declare [indexSignature] as:`,
+                V | null,
+            ]
+    : V;
+
+export type EnsureItemNullable<Item, ContainerType extends string> =
+    NonNullable<Item> extends CoValue
+        ? null extends Item
+            ? any
+            : [
+                  `👋 CoList items that are CoValue references should be nullable, make sure the Item generic parameter of ${ContainerType} is:`,
+                  Item | null
+              ]
+        : any;

package/src/{subscriptionScope.ts → implementation/subscriptionScope.ts}

@@ -1,7 +1,5 @@
-import { ControlledAccount } from "./coValues/account/account.js";
-import { CoValueSchema, CoValue, ID } from "./coValueInterfaces.js";
-import * as S from "@effect/schema/Schema";
-import { RawCoValue } from "cojson";
+import type { RawCoValue } from "cojson";
+import type { Account, CoValue, CoValueBase, ID, Me, SubclassedConstructor } from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
     CoValue,
@@ -9,10 +7,10 @@ export const subscriptionsScopes = new WeakMap<
 >();
 
 export class SubscriptionScope<
-    RootSchema extends CoValueSchema = CoValueSchema,
+    Root extends CoValue
 > {
     scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
-    subscriber: ControlledAccount;
+    subscriber: Account & Me;
     entries = new Map<
         ID<CoValue>,
         | { state: "loading"; immediatelyUnsub?: boolean }
@@ -20,16 +18,16 @@ export class SubscriptionScope<
     >();
     rootEntry: {
         state: "loaded";
-        value: S.Schema.To<RootSchema>;
+        value: Root;
         rawUnsub: () => void;
     };
-    onUpdate: (newRoot: S.Schema.To<RootSchema>) => void;
+    onUpdate: (newRoot: Root) => void;
     scheduledUpdate: boolean = false;
 
     constructor(
-        root: S.Schema.To<RootSchema>,
-        rootSchema: RootSchema,
-        onUpdate: (newRoot: S.Schema.To<RootSchema>) => void
+        root: Root,
+        rootSchema: SubclassedConstructor<Root> & typeof CoValueBase,
+        onUpdate: (newRoot: Root) => void
     ) {
         this.rootEntry = {
             state: "loaded" as const,
@@ -47,7 +45,7 @@ export class SubscriptionScope<
                 if (!rawUpdate) return;
                 this.rootEntry.value = rootSchema.fromRaw(
                     rawUpdate
-                ) as S.Schema.To<RootSchema>;
+                ) as Root;
                 // console.log("root update", this.rootEntry.value.toJSON());
                 subscriptionsScopes.set(this.rootEntry.value, this);
                 this.scheduleUpdate();
@@ -77,7 +75,7 @@ export class SubscriptionScope<
                 immediatelyUnsub: false,
             } as const;
             this.entries.set(accessedOrSetId, loadingEntry);
-            this.subscriber._raw.core.node
+            void this.subscriber._raw.core.node
                 .loadCoValueCore(accessedOrSetId)
                 .then((core) => {
                     if (

package/src/index.ts

@@ -1,29 +1,3 @@
-import { AccountOf } from "./coValues/account/accountOf.js";
-import { CoListOf } from "./coValues/coList/coListOf.js";
-import { CoMapOf } from "./coValues/coMap/coMapOf.js";
-import {
-    BinaryCoStreamImpl,
-    CoStreamOf,
-} from "./coValues/coStream/coStreamOf.js";
-import { ImageDefinition } from "./coValues/extensions/imageDef.js";
-import { GroupOf } from "./coValues/group/groupOf.js";
-
-/** @hidden */
-export * as S from "@effect/schema/Schema";
-
-/** @category Schemas & CoValues - Schema definers */
-export const Co = {
-    map: CoMapOf,
-    list: CoListOf,
-    stream: CoStreamOf,
-    binaryStream: BinaryCoStreamImpl,
-    account: AccountOf,
-    group: GroupOf,
-    media: {
-        imageDef: ImageDefinition
-    }
-};
-
 /** @category Internal types */
 export {
     cojsonReady as jazzReady,
@@ -36,33 +10,14 @@ export {
     MAX_RECOMMENDED_TX_SIZE,
 } from "cojson";
 
-export { ID, CoValue, CoValueSchema } from "./coValueInterfaces.js";
-
-
-export { CoMap, CoMapSchema } from "./coValues/coMap/coMap.js";
-/** @category Schemas & CoValues - CoMap */
-export * as CoMapInternals from "./coValues/coMap/internalDocs.js";
-
-export { CoList, CoListSchema } from "./coValues/coList/coList.js";
-/** @category Schemas & CoValues - CoList */
-export * as CoListInternals from "./coValues/coList/internalDocs.js";
-
-export {
-    CoStream,
-    CoStreamSchema,
-    BinaryCoStream,
-} from "./coValues/coStream/coStream.js";
-
-export {
-    AnyAccount,
-    ControlledAccount,
-    AccountSchema,
-    controlledAccountSym,
-} from "./coValues/account/account.js";
+export { ID, CoValue } from "./internal.js";
 
-export { AccountMigration } from "./coValues/account/migration.js";
-export { Account, BaseProfile } from "./coValues/account/accountOf.js";
-export { AnyGroup } from "./coValues/group/group.js";
-export { Group } from "./coValues/group/groupOf.js";
+export { Encoders } from "./internal.js";
 
-export { ImageDefinition } from "./coValues/extensions/imageDef.js";
+export { CoMap, indexSignature } from "./internal.js";
+export { CoList } from "./internal.js";
+export { CoStream, BinaryCoStream } from "./internal.js";
+export { Group, Profile } from "./internal.js";
+export { Account, Me } from "./internal.js";
+export { ImageDefinition } from "./internal.js";
+export { CoValueBase, CoValueClass } from "./internal.js";

package/src/internal.ts

@@ -0,0 +1,15 @@
+export * from './implementation/inspect.js';
+export * from "./coValues/interfaces.js";
+
+export * from "./coValues/coMap.js";
+export * from "./coValues/account.js";
+export * from "./coValues/coList.js";
+export * from "./coValues/coStream.js";
+export * from "./coValues/group.js";
+
+export * from "./implementation/errors.js";
+export * from "./implementation/refs.js";
+export * from "./implementation/schema.js";
+export * from "./implementation/subscriptionScope.js";
+
+export * from "./coValues/extensions/imageDef.js";

package/src/tests/coList.test.ts

@@ -4,7 +4,7 @@ import { webcrypto } from "node:crypto";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Co, S, Account, jazzReady } from "..";
+import { Account, CoList, jazzReady } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,7 +20,8 @@ describe("Simple CoList operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestList extends Co.list(S.string).as<TestList>() {}
+    class TestList extends CoList<string> {}
+    TestList.encoding({ _item: "json" });
 
     const list = new TestList(["bread", "butter", "onion"], { owner: me });
 
@@ -97,32 +98,35 @@ describe("Simple CoList operations", async () => {
             expect(list._raw.asArray()).toEqual(["butter", "onion"]);
         });
 
-        test("splice", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
-                owner: me,
-            });
-            list.splice(1, 1, "salt", "pepper");
-            expect(list.length).toBe(4);
-            expect(list._raw.asArray()).toEqual([
-                "bread",
-                "salt",
-                "pepper",
-                "onion",
-            ]);
-        });
+        // test("splice", () => {
+        //     const list = new TestList(["bread", "butter", "onion"], {
+        //         owner: me,
+        //     });
+        //     list.splice(1, 1, "salt", "pepper");
+        //     expect(list.length).toBe(4);
+        //     expect(list._raw.asArray()).toEqual([
+        //         "bread",
+        //         "salt",
+        //         "pepper",
+        //         "onion",
+        //     ]);
+        // });
     });
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends Co.list(S.string).as<TwiceNestedList>() {
+    class TwiceNestedList extends CoList<string> {
         joined() {
             return this.join(",");
         }
     }
+    TwiceNestedList.encoding({ _item: "json" });
 
-    class NestedList extends Co.list(TwiceNestedList).as<NestedList>() {}
+    class NestedList extends CoList<TwiceNestedList | null> {}
+    NestedList.encoding({ _item: { ref: () => TwiceNestedList } });
 
-    class TestList extends Co.list(NestedList).as<TestList>() {}
+    class TestList extends CoList<NestedList | null> {}
+    TestList.encoding({ _item: { ref: () => NestedList } });
 
     const initNodeAndList = async () => {
         const me = await Account.create({
@@ -173,7 +177,7 @@ describe("CoList resolution", async () => {
 
         const loadedList = await TestList.load(list.id, { as: meOnSecondPeer });
 
-        expect(loadedList?.[0]).toBe(undefined);
+        expect(loadedList?.[0]).toBe(null);
         expect(loadedList?._refs[0]?.id).toEqual(list[0]!.id);
 
         const loadedNestedList = await NestedList.load(list[0]!.id, {
@@ -181,7 +185,7 @@ describe("CoList resolution", async () => {
         });
 
         expect(loadedList?.[0]).toBeDefined();
-        expect(loadedList?.[0]?.[0]).toBeUndefined();
+        expect(loadedList?.[0]?.[0]).toBe(null);
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]![0]!.id);
         expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
 
@@ -194,9 +198,7 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?.[0]?.[0]).toBe("a");
         expect(loadedList?.[0]?.[0]?.joined()).toBe("a,b");
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
-        expect(loadedList?.[0]?._refs[0]?.value).toEqual(
-            loadedTwiceNestedList
-        );
+        expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
         const otherNestedList = new NestedList(
             [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
@@ -241,11 +243,11 @@ describe("CoList resolution", async () => {
                 );
 
                 const update1 = yield* $(Queue.take(queue));
-                expect(update1?.[0]).toEqual(undefined);
+                expect(update1?.[0]).toBe(null);
 
                 const update2 = yield* $(Queue.take(queue));
                 expect(update2?.[0]).toBeDefined();
-                expect(update2?.[0]?.[0]).toBeUndefined();
+                expect(update2?.[0]?.[0]).toBe(null);
 
                 const update3 = yield* $(Queue.take(queue));
                 expect(update3?.[0]?.[0]).toBeDefined();