jazz-tools 0.7.0-alpha.0

package/src/coValues/group/groupOf.ts

@@ -0,0 +1,183 @@
+import {
+    CoValueSchema,
+    ID,
+    inspect,
+    isCoValueSchema,
+} from "../../coValueInterfaces.js";
+import * as S from "@effect/schema/Schema";
+import { AnyGroup, GroupSchema } from "./group.js";
+import {
+    AnyAccount,
+    ControlledAccount,
+    isControlledAccount,
+} from "../account/account.js";
+import { AST, Schema } from "@effect/schema";
+import { constructorOfSchemaSym } from "../resolution.js";
+import { pipeArguments } from "effect/Pipeable";
+import { Everyone, RawGroup, Role } from "cojson";
+import { ValueRef } from "../../refs.js";
+import { controlledAccountFromNode } from "../account/accountOf.js";
+import { SharedCoValueConstructor } from "../construction.js";
+
+export function GroupOf<
+    P extends CoValueSchema | S.Schema<null>,
+    R extends CoValueSchema | S.Schema<null>,
+>(fields: { profile: P; root: R }) {
+    class GroupOfProfileAndRoot
+        extends SharedCoValueConstructor
+        implements AnyGroup<P, R>
+    {
+        static get ast() {
+            return AST.setAnnotation(
+                Schema.instanceOf(this).ast,
+                constructorOfSchemaSym,
+                this
+            );
+        }
+        static [Schema.TypeId]: Schema.Schema.Variance<
+            AnyGroup<P, R> & GroupOfProfileAndRoot,
+            AnyGroup<P, R> & GroupOfProfileAndRoot,
+            never
+        >[Schema.TypeId];
+        static pipe() {
+            // eslint-disable-next-line prefer-rest-params
+            return pipeArguments(this, arguments);
+        }
+        static type = "Group" as const;
+
+        id!: ID<this>;
+        _type!: "Group";
+        _owner!: AnyAccount | AnyGroup;
+        _refs!: AnyGroup<P, R>["_refs"];
+        _raw!: RawGroup;
+        _loadedAs!: ControlledAccount;
+        _schema!: typeof GroupOfProfileAndRoot;
+
+        constructor(options: { owner: AnyAccount | AnyGroup });
+        constructor(init: any, options: { fromRaw: RawGroup });
+        constructor(init: undefined, options: { owner: AnyAccount | AnyGroup });
+        constructor(
+            init: undefined | { owner: AnyAccount | AnyGroup },
+            options?: { fromRaw: RawGroup } | { owner: AnyAccount | AnyGroup }
+        ) {
+            super();
+            let raw: RawGroup;
+
+            if (options && "fromRaw" in options) {
+                raw = options.fromRaw;
+            } else {
+                const initOwner = options?.owner || init?.owner;
+                if (!initOwner) throw new Error("No owner provided");
+                if (isControlledAccount(initOwner)) {
+                    const rawOwner = initOwner._raw;
+                    raw = rawOwner.createGroup();
+                } else {
+                    throw new Error(
+                        "Can only construct group as a controlled account"
+                    );
+                }
+            }
+
+            const refs = {
+                get profile() {
+                    if (isCoValueSchema(fields.profile)) {
+                        const profileID = raw.get("profile");
+                        return (
+                            profileID &&
+                            new ValueRef(
+                                profileID as unknown as ID<
+                                    Schema.Schema.To<typeof fields.profile>
+                                >,
+                                controlledAccountFromNode(raw.core.node),
+                                fields.profile
+                            )
+                        );
+                    }
+                },
+                get root() {
+                    if (isCoValueSchema(fields.root)) {
+                        const rootID = raw.get("root");
+                        return (
+                            rootID &&
+                            new ValueRef(
+                                rootID as unknown as ID<
+                                    Schema.Schema.To<typeof fields.root>
+                                >,
+                                controlledAccountFromNode(raw.core.node),
+                                fields.root
+                            )
+                        );
+                    }
+                },
+            };
+
+            Object.defineProperties(this, {
+                id: { value: raw.id, enumerable: false },
+                _type: { value: "Group", enumerable: false },
+                _owner: { value: this, enumerable: false },
+                _refs: { value: refs, enumerable: false },
+                _raw: { value: raw, enumerable: false },
+                _loadedAs: {
+                    get: () => controlledAccountFromNode(raw.core.node),
+                    enumerable: false,
+                },
+                _schema: { value: GroupOfProfileAndRoot, enumerable: false },
+            });
+        }
+
+        static fromRaw(raw: RawGroup) {
+            return new GroupOfProfileAndRoot(undefined, {
+                fromRaw: raw,
+            });
+        }
+
+        get profile(): S.Schema.To<P> | undefined {
+            return this._refs.profile.accessFrom(this);
+        }
+
+        get root(): S.Schema.To<R> | undefined {
+            return this._refs.root.accessFrom(this);
+        }
+
+        addMember(member: AnyAccount | Everyone, role: Role) {
+            this._raw.addMember(
+                typeof member === "string" ? member : member._raw,
+                role
+            );
+
+            return this;
+        }
+
+        myRole(): Role | undefined {
+            return this._raw.myRole();
+        }
+
+        toJSON() {
+            return {
+                co: {
+                    id: this.id,
+                    type: this._type,
+                },
+                profile: this.profile?.toJSON(),
+                root: this.root?.toJSON(),
+            };
+        }
+
+        [inspect]() {
+            return this.toJSON();
+        }
+
+        static as<SubClass>() {
+            return this as unknown as GroupSchema<SubClass, P, R>;
+        }
+    }
+
+    return GroupOfProfileAndRoot as GroupSchema<GroupOfProfileAndRoot, P, R> & {
+        as<SubClass>(): GroupSchema<SubClass, P, R>;
+    };
+}
+
+export class Group extends GroupOf({
+    profile: S.null,
+    root: S.null,
+}).as<Group>() {}

package/src/coValues/resolution.ts

@@ -0,0 +1,111 @@
+import { Schema, AST } from "@effect/schema";
+import { RawCoValue } from "cojson";
+import { CoValue, CoValueSchema } from "../coValueInterfaces.js";
+
+// TODO: can we get rid of this because effect schema already has an annotation for the constructor?
+export const constructorOfSchemaSym = Symbol.for("@jazz/constructorOfSymbol");
+export type constructorOfSchemaSym = typeof constructorOfSchemaSym;
+
+export function propertyIsCoValueSchema(
+    prop:
+        | Schema.Schema<any>
+        | Schema.PropertySignature<any, boolean, any, boolean, never>
+): prop is CoValueSchema {
+    if ("propertySignatureAST" in prop) {
+        return astIsCoValueSchema(
+            (prop.propertySignatureAST as { from: AST.AST }).from
+        );
+    } else {
+        return astIsCoValueSchema((prop as Schema.Schema<unknown>).ast);
+    }
+}
+
+function astIsCoValueSchema(ast: AST.AST): boolean {
+    if (
+        (ast._tag === "Declaration") &&
+        ast.annotations[constructorOfSchemaSym]
+    ) {
+        return true;
+    } else if (ast._tag === "Union") {
+        return ast.types.every(
+            (member) =>
+                member._tag === "UndefinedKeyword" || astIsCoValueSchema(member)
+        );
+    } else if (
+        ast._tag === "BooleanKeyword" ||
+        ast._tag === "NumberKeyword" ||
+        ast._tag === "StringKeyword" ||
+        ast._tag === "Literal" ||
+        ast._tag === "Tuple"
+    ) {
+        return false;
+    } else if (ast._tag === "Refinement") {
+        return astIsCoValueSchema(ast.from);
+    } else if (ast._tag === "Transform") {
+        return astIsCoValueSchema(ast.from);
+    } else {
+        throw new Error(
+            `astIsCoValueSchema can't yet handle ${ast._tag}: ${JSON.stringify(
+                ast
+            )}`
+        );
+    }
+}
+
+export function getCoValueConstructorInProperty(
+    prop:
+        | Schema.Schema<unknown>
+        | Schema.PropertySignature<unknown, boolean, unknown, boolean, never>,
+    rawValue: RawCoValue
+):
+    | (new (init: undefined, options: { fromRaw: RawCoValue }) => CoValue)
+    | undefined {
+    if ("propertySignatureAST" in prop) {
+        return getCoValueConstructorInAST(
+            (prop.propertySignatureAST as { from: AST.AST }).from,
+            rawValue
+        );
+    } else {
+        return getCoValueConstructorInAST(
+            (prop as Schema.Schema<unknown>).ast,
+            rawValue
+        );
+    }
+}
+
+// TODO (optimization): make this meta, so this creates a tailor-made function that will take a RawCoValue at call time
+function getCoValueConstructorInAST(
+    ast: AST.AST,
+    rawValue: RawCoValue
+):
+    | (new (init: undefined, options: { fromRaw: RawCoValue }) => CoValue)
+    | undefined {
+    if (
+        (ast._tag === "Declaration") &&
+        ast.annotations[constructorOfSchemaSym]
+    ) {
+        return ast.annotations[constructorOfSchemaSym] as new (
+            init: undefined,
+            options: { fromRaw: RawCoValue }
+        ) => CoValue;
+    } else if (ast._tag === "Union" && ast.types.length === 2) {
+        const [a, b] = ast.types;
+        if (a._tag === "UndefinedKeyword") {
+            return getCoValueConstructorInAST(b, rawValue);
+        } else if (b._tag === "UndefinedKeyword") {
+            return getCoValueConstructorInAST(a, rawValue);
+        } else {
+            throw new Error(
+                `getCoValueConstructorInAST can't yet handle Union of: ${JSON.stringify(
+                    ast.types
+                )}`
+            );
+        }
+    } else {
+        throw new Error(
+            `getCoValueConstructorInAST can't yet handle ${
+                ast._tag
+            }: ${JSON.stringify(ast)}`
+        );
+    }
+}

package/src/errors.ts

@@ -0,0 +1 @@
+export type UnavailableError = "unavailable";

package/src/index.ts

@@ -0,0 +1,68 @@
+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,
+    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 { 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 { ImageDefinition } from "./coValues/extensions/imageDef.js";

package/src/refs.ts

@@ -0,0 +1,128 @@
+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";
+
+export class ValueRef<V extends CoValue> {
+    private cachedValue: V | undefined;
+
+    constructor(
+        readonly id: ID<V>,
+        readonly controlledAccount: ControlledAccount,
+        readonly propDef: PropDef<any>
+    ) {}
+
+    get value() {
+        if (this.cachedValue) return this.cachedValue;
+        // TODO: cache it for object identity!!!
+        const raw = this.controlledAccount._raw.core.node.getLoaded(
+            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;
+            this.cachedValue = value;
+            return value;
+        }
+    }
+
+    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"> {
+        const raw = await this.controlledAccount._raw.core.node.load(
+            this.id as unknown as CoID<RawCoValue>,
+            options?.onProgress
+        );
+        if (raw === "unavailable") {
+            return "unavailable";
+        } else {
+            return new ValueRef(this.id, this.controlledAccount, this.propDef)
+                .value!;
+        }
+    }
+
+    async load(options?: {onProgress: (p: number) => void}): Promise<V | undefined> {
+        const result = await this.loadHelper(options);
+        if (result === "unavailable") {
+            return undefined;
+        } else {
+            return result;
+        }
+    }
+
+    accessFrom(fromScopeValue: CoValue): V | undefined {
+        const subScope = subscriptionsScopes.get(fromScopeValue);
+
+        subScope?.onRefAccessedOrSet(this.id);
+
+        if (this.value && subScope) {
+            subscriptionsScopes.set(this.value, subScope);
+        }
+
+        return this.value;
+    }
+}
+
+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]> };
+    return new Proxy(refs, {
+        get(target, key) {
+            if (key === Symbol.iterator) {
+                return function* () {
+                    for (const key of getKeysWithIds()) {
+                        yield new ValueRef(
+                            getIdForKey(key)!,
+                            controlledAccount,
+                            propDefForKey(key)
+                        );
+                    }
+                };
+            }
+            if (typeof key === "symbol") return undefined;
+            if (key === "length") {
+                return getKeysWithIds().length;
+            }
+            const id = getIdForKey(key as keyof F);
+            if (!id) return undefined;
+            return new ValueRef(
+                id as ID<F[typeof key]>,
+                controlledAccount,
+                propDefForKey(key as keyof F)
+            );
+        },
+        ownKeys() {
+            return getKeysWithIds().map((key) => key.toString());
+        },
+    });
+}

package/src/schemaHelpers.ts

@@ -0,0 +1,72 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AST } from "@effect/schema";
+import * as S from "@effect/schema/Schema";
+
+export type SchemaWithOutput<I> = S.Schema<any, any, never> & {
+    [S.TypeId]: {
+        _I: (_: any) => I;
+    };
+};
+
+export type SchemaWithInputAndOutput<A, I = A> = S.Schema<any, any, never> & {
+    [S.TypeId]: {
+        _A: (_: any) => A;
+        _I: (_: any) => I;
+    };
+};
+
+export type PropertySignatureWithOutput<I> = S.PropertySignature<
+    any,
+    boolean,
+    any,
+    boolean,
+    never
+> & {
+    [S.TypeId]: {
+        _I: (_: any) => I | undefined;
+    };
+};
+
+export type PropertySignatureWithInputAndOutput<I, A> = S.PropertySignature<
+    any,
+    boolean,
+    any,
+    boolean,
+    never
+> & {
+    [S.TypeId]: {
+        _A: (_: any) => A | undefined;
+        _I: (_: any) => I | undefined;
+    };
+};
+
+export type PropDef<I> =
+    | S.Schema<I>
+    | S.PropertySignature<I, boolean, I, boolean, never>;
+
+export function CoSchema<Raw extends S.Schema<any>>(
+    raw: Raw
+): Raw & S.Schema<Raw, any, any> {
+    return raw as any;
+}
+
+export function propSigToSchema<
+    S extends S.Schema<any> | PropertySignatureWithInputAndOutput<any, any>,
+>(
+    propSig: S
+): S extends S.Schema<any>
+    ? S
+    : S extends PropertySignatureWithInputAndOutput<infer A, infer I>
+      ? S.Schema<A, I>
+      : never {
+    if ("ast" in propSig) {
+        return propSig as any;
+    } else {
+        const ast = (
+            propSig as unknown as {
+                propertySignatureAST: { from: AST.AST };
+            }
+        ).propertySignatureAST;
+        return S.make<any, unknown, never>(ast.from) as any;
+    }
+}

package/src/subscriptionScope.ts

@@ -0,0 +1,118 @@
+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";
+
+export const subscriptionsScopes = new WeakMap<
+    CoValue,
+    SubscriptionScope<any>
+>();
+
+export class SubscriptionScope<
+    RootSchema extends CoValueSchema = CoValueSchema,
+> {
+    scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
+    subscriber: ControlledAccount;
+    entries = new Map<
+        ID<CoValue>,
+        | { state: "loading"; immediatelyUnsub?: boolean }
+        | { state: "loaded"; rawUnsub: () => void }
+    >();
+    rootEntry: {
+        state: "loaded";
+        value: S.Schema.To<RootSchema>;
+        rawUnsub: () => void;
+    };
+    onUpdate: (newRoot: S.Schema.To<RootSchema>) => void;
+    scheduledUpdate: boolean = false;
+
+    constructor(
+        root: S.Schema.To<RootSchema>,
+        rootSchema: RootSchema,
+        onUpdate: (newRoot: S.Schema.To<RootSchema>) => void
+    ) {
+        this.rootEntry = {
+            state: "loaded" as const,
+            value: root,
+            rawUnsub: () => {}, // placeholder
+        };
+        this.entries.set(root.id, this.rootEntry);
+
+        subscriptionsScopes.set(root, this);
+
+        this.subscriber = root._loadedAs;
+        this.onUpdate = onUpdate;
+        this.rootEntry.rawUnsub = root._raw.core.subscribe(
+            (rawUpdate: RawCoValue | undefined) => {
+                if (!rawUpdate) return;
+                this.rootEntry.value = rootSchema.fromRaw(
+                    rawUpdate
+                ) as S.Schema.To<RootSchema>;
+                // console.log("root update", this.rootEntry.value.toJSON());
+                subscriptionsScopes.set(this.rootEntry.value, this);
+                this.scheduleUpdate();
+            }
+        );
+    }
+
+    scheduleUpdate() {
+        if (!this.scheduledUpdate) {
+            this.scheduledUpdate = true;
+            queueMicrotask(() => {
+                this.scheduledUpdate = false;
+                this.onUpdate(this.rootEntry.value);
+            });
+        }
+    }
+
+    onRefAccessedOrSet(accessedOrSetId: ID<CoValue> | undefined) {
+        // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
+        if (!accessedOrSetId) {
+            return;
+        }
+
+        if (!this.entries.has(accessedOrSetId)) {
+            const loadingEntry = {
+                state: "loading",
+                immediatelyUnsub: false,
+            } as const;
+            this.entries.set(accessedOrSetId, loadingEntry);
+            this.subscriber._raw.core.node
+                .loadCoValueCore(accessedOrSetId)
+                .then((core) => {
+                    if (
+                        loadingEntry.state === "loading" &&
+                        loadingEntry.immediatelyUnsub
+                    ) {
+                        return;
+                    }
+                    if (core !== "unavailable") {
+                        const entry = {
+                            state: "loaded" as const,
+                            rawUnsub: () => {}, // placeholder
+                        };
+                        this.entries.set(accessedOrSetId, entry);
+
+                        const rawUnsub = core.subscribe((rawUpdate) => {
+                            // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
+                            if (!rawUpdate) return;
+                            this.scheduleUpdate();
+                        });
+
+                        entry.rawUnsub = rawUnsub;
+                    }
+                });
+        }
+    }
+
+    unsubscribeAll() {
+        for (const entry of this.entries.values()) {
+            if (entry.state === "loaded") {
+                entry.rawUnsub();
+            } else {
+                entry.immediatelyUnsub = true;
+            }
+        }
+        this.entries.clear();
+    }
+}