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

package/src/coValues/interfaces.ts

@@ -0,0 +1,218 @@
+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,
+    Ref,
+    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;
+}
+export function isCoValueClass(value: any): value is CoValueClass {
+    return typeof value === "function" && value.fromRaw !== 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 Ref(id as ID<V>, account, this as CoValueClass<V>).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 Ref(id as ID<V>, options.as, this as CoValueClass<V>).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,20 +1,31 @@
 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,
+    RefEncoded,
+    UnavailableError,
+} from "../internal.js";
+import {
+    instantiateRefEncoded,
+    isRefEncoded,
+    subscriptionsScopes,
+} from "../internal.js";
 
-export class ValueRef<V extends CoValue> {
+export class Ref<V extends CoValue> {
     private cachedValue: V | undefined;
 
     constructor(
         readonly id: ID<V>,
-        readonly controlledAccount: ControlledAccount,
-        readonly propDef: PropDef<any>
-    ) {}
+        readonly controlledAccount: Account & Me,
+        readonly schema: RefEncoded<V>
+    ) {
+        if (!isRefEncoded(schema)) {
+            throw new Error("Ref must be constructed with a ref schema");
+        }
+    }
 
     get value() {
         if (this.cachedValue) return this.cachedValue;
@@ -23,18 +34,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 = instantiateRefEncoded(this.schema, raw);
             this.cachedValue = value;
             return value;
+        } else {
+            return null;
         }
     }
 
@@ -54,7 +58,9 @@ export class ValueRef<V extends CoValue> {
         });
     }
 
-    private async loadHelper(options?: {onProgress: (p: number) => void}): Promise<V | "unavailable"> {
+    private async loadHelper(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | "unavailable"> {
         const raw = await this.controlledAccount._raw.core.node.load(
             this.id as unknown as CoID<RawCoValue>,
             options?.onProgress
@@ -62,12 +68,14 @@ export class ValueRef<V extends CoValue> {
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(this.id, this.controlledAccount, this.propDef)
+            return new Ref(this.id, this.controlledAccount, this.schema)
                 .value!;
         }
     }
 
-    async load(options?: {onProgress: (p: number) => void}): Promise<V | undefined> {
+    async load(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | undefined> {
         const result = await this.loadHelper(options);
         if (result === "unavailable") {
             return undefined;
@@ -76,7 +84,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,22 +97,28 @@ 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>(
+    getIdForKey: (key: Keys) => ID<CoValue> | undefined,
+    getKeysWithIds: () => Keys[],
+    controlledAccount: Account & Me,
+    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>
+): { [K in Keys]: Ref<CoValue> } & {
+    [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
+    length: number;
+} {
+    const refs = {} as { [K in Keys]: Ref<CoValue> } & {
+        [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
+        length: number;
+    };
     return new Proxy(refs, {
-        get(target, key) {
+        get(_target, key) {
             if (key === Symbol.iterator) {
                 return function* () {
                     for (const key of getKeysWithIds()) {
-                        yield new ValueRef(
+                        yield new Ref(
                             getIdForKey(key)!,
                             controlledAccount,
-                            propDefForKey(key)
+                            refSchemaForKey(key)
                         );
                     }
                 };
@@ -113,12 +127,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]>,
+            return new Ref(
+                id as ID<CoValue>,
                 controlledAccount,
-                propDefForKey(key as keyof F)
+                refSchemaForKey(key as Keys)
             );
         },
         ownKeys() {

package/src/implementation/schema.ts

@@ -0,0 +1,124 @@
+import type { JsonValue, RawCoValue } from "cojson";
+import { type CoValue, type CoValueClass, isCoValueClass } from "../internal.js";
+import type { Schema as EffectSchema,  TypeId } from "@effect/schema/Schema";
+
+export type CoMarker = { readonly __co: unique symbol };
+export type co<T> = T | (T & CoMarker);
+export type IfCo<C, R> = C extends infer _A | infer B
+    ? B extends CoMarker
+        ? R
+        : never
+    : never;
+
+export const SchemaInit = Symbol.for("SchemaInit");
+export type SchemaInit = typeof SchemaInit;
+
+export const InitValues = Symbol.for("InitValues");
+export type InitValues = typeof InitValues;
+
+export const ItemsSym = Symbol.for("items");
+export type ItemsSym = typeof ItemsSym;
+
+export const co = {
+    string: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<string>,
+    number: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<number>,
+    boolean: {
+        [SchemaInit]: "json" satisfies Schema,
+    } as unknown as co<boolean>,
+    literal: <T extends string | number | boolean>(_lit: T): co<T> => {
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    json: <T extends JsonValue>(): co<T> => {
+        return { [SchemaInit]: "json" satisfies Schema } as any;
+    },
+    encoded: <T>(arg: Encoder<T>): co<T> => {
+        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+    },
+    ref: <C extends CoValueClass>(
+        arg: C | ((_raw: InstanceType<C>["_raw"]) => C)
+    ): co<InstanceType<C> | null> => {
+        return { [SchemaInit]: arg satisfies Schema } as any;
+    },
+    items: ItemsSym as ItemsSym,
+};
+
+export type JsonEncoded = "json";
+export type EncodedAs<V> = { encoded: Encoder<V> };
+export type RefEncoded<V extends CoValue> =
+    | CoValueClass<V>
+    | ((raw: RawCoValue) => CoValueClass<V>);
+
+export function isRefEncoded<V extends CoValue>(
+    schema: Schema
+): schema is RefEncoded<V> {
+    return typeof schema === "function";
+}
+
+export function instantiateRefEncoded<V extends CoValue>(
+    schema: RefEncoded<V>,
+    raw: RawCoValue
+): V {
+    return isCoValueClass(schema)
+        ? schema.fromRaw(raw)
+        : (schema as (raw: RawCoValue) => CoValueClass<V>)(raw).fromRaw(raw);
+}
+
+export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
+
+export type SchemaFor<Field> = NonNullable<Field> extends CoValue
+    ? RefEncoded<NonNullable<Field>>
+    : NonNullable<Field> extends JsonValue
+      ? JsonEncoded
+      : EncodedAs<NonNullable<Field>>;
+
+export type EffectSchemaWithInputAndOutput<A, I = A> = EffectSchema<
+    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 type EnsureCoValueNullable<
+    V,
+    Key extends string | ItemsSym,
+> = 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 _item as:`,
+                V | null,
+            ]
+    : V;
+
+export type ValidItem<
+    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,68 +1,25 @@
-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 {
+    /** @category Internal types */
     cojsonReady as jazzReady,
+    cojsonInternals,
+    MAX_RECOMMENDED_TX_SIZE,
+} from "cojson";
+export type {
     InviteSecret,
     Peer,
     SessionID,
     AgentID,
     SyncMessage,
-    cojsonInternals,
-    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 type { 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, co } from "./internal.js";
 
-export { ImageDefinition } from "./coValues/extensions/imageDef.js";
+export { CoMap } from "./internal.js";
+export { CoList } from "./internal.js";
+export { CoStream, BinaryCoStream } from "./internal.js";
+export { Group, Profile } from "./internal.js";
+export { Account, type Me } from "./internal.js";
+export { ImageDefinition } from "./internal.js";
+export { CoValueBase, type 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";