jazz-tools 0.7.0-alpha.0

package/src/coValues/coStream/coStreamOf.ts

@@ -0,0 +1,404 @@
+import {
+    AccountID,
+    AgentID,
+    BinaryStreamInfo,
+    CojsonInternalTypes,
+    JsonValue,
+    RawAccount,
+    RawBinaryCoStream,
+    RawCoStream,
+    SessionID,
+    cojsonInternals,
+} from "cojson";
+import {
+    CoValue,
+    CoValueSchema,
+    ID,
+    inspect,
+} from "../../coValueInterfaces.js";
+import { AnyAccount, ControlledAccount } from "../account/account.js";
+import { AnyGroup } from "../group/group.js";
+import {
+    BinaryCoStream,
+    BinaryCoStreamSchema,
+    CoStream,
+    CoStreamSchema,
+} from "./coStream.js";
+import { SharedCoValueConstructor } from "../construction.js";
+import { AST, Schema } from "@effect/schema";
+import {
+    constructorOfSchemaSym,
+    propertyIsCoValueSchema,
+} from "../resolution.js";
+import { pipeArguments } from "effect/Pipeable";
+import { ValueRef } from "../../refs.js";
+import { SchemaWithOutput } from "../../schemaHelpers.js";
+import { Account, controlledAccountFromNode } from "../account/accountOf.js";
+import { Group } from "../group/groupOf.js";
+
+export function CoStreamOf<
+    Item extends SchemaWithOutput<CoValue> | SchemaWithOutput<JsonValue>,
+>(itemSchema: Item) {
+    const decodeItem = Schema.decodeSync(itemSchema);
+    const encodeItem = Schema.encodeSync(itemSchema);
+    const itemIsCoValue = propertyIsCoValueSchema(itemSchema);
+
+    class CoStreamOfItem extends SharedCoValueConstructor {
+        static get ast() {
+            return AST.setAnnotation(
+                Schema.instanceOf(this).ast,
+                constructorOfSchemaSym,
+                this
+            );
+        }
+        static [Schema.TypeId]: Schema.Schema.Variance<
+            CoStreamOfItem,
+            CoStreamOfItem,
+            never
+        >[Schema.TypeId];
+        static pipe() {
+            // eslint-disable-next-line prefer-rest-params
+            return pipeArguments(this, arguments);
+        }
+        static type = "CoStream" as const;
+
+        id!: ID<this>;
+        _type!: "CoStream";
+        _owner!: AnyAccount | AnyGroup;
+        _raw!: RawCoStream;
+        _loadedAs!: ControlledAccount;
+        _schema!: typeof CoStreamOfItem;
+
+        by: CoStream<Item>["by"];
+        in: CoStream<Item>["in"];
+
+        constructor(
+            init: Schema.Schema.To<Item>[] | undefined,
+            options: { owner: AnyAccount | AnyGroup } | { fromRaw: RawCoStream }
+        ) {
+            super();
+
+            let raw: RawCoStream;
+
+            if ("fromRaw" in options) {
+                raw = options.fromRaw;
+            } else {
+                const rawOwner = options.owner._raw;
+
+                raw = rawOwner.createStream();
+            }
+
+            this.by = {} as CoStream<Item>["by"];
+            this.in = {} as CoStream<Item>["in"];
+
+            Object.defineProperties(this, {
+                id: { value: raw.id, enumerable: false },
+                _type: { value: "CoStream", enumerable: false },
+                _owner: {
+                    get: () =>
+                        raw.group instanceof RawAccount
+                            ? Account.fromRaw(raw.group)
+                            : Group.fromRaw(raw.group),
+                    enumerable: false,
+                },
+                _raw: { value: raw, enumerable: false },
+                _loadedAs: {
+                    get: () => controlledAccountFromNode(raw.core.node),
+                    enumerable: false,
+                },
+                _schema: { value: this.constructor, enumerable: false },
+            });
+
+            if (init !== undefined) {
+                for (const item of init) {
+                    this.pushItem(item);
+                }
+            }
+
+            this.updateEntries();
+        }
+
+        private updateEntries() {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            const raw = this._raw;
+            const loadedAs = this._loadedAs;
+
+            for (const accountID of this._raw.accounts() as unknown as Set<
+                ID<AnyAccount>
+            >) {
+                Object.defineProperty(this.by, accountID, {
+                    get() {
+                        const rawEntry = raw.lastItemBy(
+                            accountID as unknown as AccountID
+                        );
+
+                        if (!rawEntry) return;
+                        return entryFromRawEntry(
+                            self,
+                            rawEntry,
+                            loadedAs,
+                            accountID
+                        );
+                    },
+                    configurable: true,
+                });
+            }
+            Object.defineProperty(this.by, "me", {
+                get() {
+                    return self.by[loadedAs.id];
+                },
+                enumerable: false,
+                configurable: true,
+            });
+
+            for (const sessionID of raw.sessions() as unknown as Set<SessionID>) {
+                Object.defineProperty(this.in, sessionID, {
+                    get() {
+                        const rawEntry = raw.lastItemIn(
+                            sessionID as unknown as SessionID
+                        );
+
+                        if (!rawEntry) return;
+                        const by =
+                            cojsonInternals.accountOrAgentIDfromSessionID(
+                                sessionID
+                            );
+                        return entryFromRawEntry(
+                            self,
+                            rawEntry,
+                            loadedAs,
+                            cojsonInternals.isAccountID(by)
+                                ? (by as unknown as ID<AnyAccount>)
+                                : undefined
+                        );
+                    },
+                    configurable: true,
+                });
+            }
+            Object.defineProperty(this.in, "currentSession", {
+                get() {
+                    return self.in[loadedAs.sessionID];
+                },
+                enumerable: false,
+                configurable: true,
+            });
+        }
+
+        static fromRaw(raw: RawCoStream) {
+            return new CoStreamOfItem(undefined, { fromRaw: raw });
+        }
+
+        push(...items: Schema.Schema.To<Item>[]) {
+            for (const item of items) {
+                this.pushItem(item);
+            }
+            this.updateEntries();
+        }
+
+        private pushItem(item: Schema.Schema.To<Item>) {
+            if (itemIsCoValue) {
+                this._raw.push(item.id);
+            } else {
+                this._raw.push(encodeItem(item));
+            }
+        }
+
+        toJSON() {
+            return {
+                by: Object.fromEntries(
+                    Object.entries(this.by).map(([key, value]) => [
+                        key,
+                        value &&
+                        typeof value === "object" &&
+                        "toJSON" in value &&
+                        typeof value.toJSON === "function"
+                            ? value.toJSON()
+                            : value,
+                    ])
+                ),
+                in: Object.fromEntries(
+                    Object.entries(this.in).map(([key, value]) => [
+                        key,
+                        value &&
+                        typeof value === "object" &&
+                        "toJSON" in value &&
+                        typeof value.toJSON === "function"
+                            ? value.toJSON()
+                            : value,
+                    ])
+                ),
+                co: {
+                    id: this.id,
+                    type: "CoStream",
+                },
+            };
+        }
+
+        [inspect]() {
+            return this.toJSON();
+        }
+
+        static as<SubClass>() {
+            return CoStreamOfItem as unknown as CoStreamSchema<SubClass, Item>;
+        }
+    }
+
+    return CoStreamOfItem as CoStreamSchema<CoStreamOfItem, Item> & {
+        as<SubClass>(): CoStreamSchema<SubClass, Item>;
+    };
+
+    function entryFromRawEntry(
+        accessFrom: CoValue,
+        rawEntry: {
+            by: AccountID | AgentID;
+            tx: CojsonInternalTypes.TransactionID;
+            at: Date;
+            value: JsonValue;
+        },
+        loadedAs: ControlledAccount,
+        accountID: ID<AnyAccount> | undefined
+    ) {
+        return {
+            get value(): Schema.Schema.To<Item> | undefined {
+                if (itemIsCoValue) {
+                    return this.ref?.accessFrom(accessFrom);
+                } else {
+                    return decodeItem(rawEntry.value);
+                }
+            },
+            get ref() {
+                if (itemIsCoValue) {
+                    const rawId = rawEntry.value;
+                    return new ValueRef(
+                        rawId as unknown as ID<Schema.Schema.To<Item>>,
+                        loadedAs,
+                        itemSchema
+                    );
+                }
+            },
+            get by() {
+                return (
+                    accountID &&
+                    new ValueRef(
+                        accountID as unknown as ID<AnyAccount>,
+                        loadedAs,
+                        Account
+                    )?.accessFrom(accessFrom)
+                );
+            },
+            madeAt: rawEntry.at,
+            tx: rawEntry.tx,
+        };
+    }
+}
+
+class BinaryCoStreamImplClass
+    extends SharedCoValueConstructor
+    implements BinaryCoStream
+{
+    static ast = AST.setAnnotation(
+        Schema.instanceOf(this).ast,
+        constructorOfSchemaSym,
+        this
+    );
+    static [Schema.TypeId]: Schema.Schema.Variance<
+        BinaryCoStream,
+        BinaryCoStream,
+        never
+    >[Schema.TypeId];
+    static pipe() {
+        // eslint-disable-next-line prefer-rest-params
+        return pipeArguments(this, arguments);
+    }
+    static type = "BinaryCoStream" as const;
+
+    id!: ID<this>;
+    _type!: "BinaryCoStream";
+    _owner!: AnyAccount | AnyGroup;
+    _raw!: RawBinaryCoStream;
+    _loadedAs!: ControlledAccount;
+    _schema!: typeof BinaryCoStreamImplClass;
+
+    constructor(
+        init: [] | undefined,
+        options:
+            | {
+                  owner: AnyAccount | AnyGroup;
+              }
+            | {
+                  fromRaw: RawBinaryCoStream;
+              }
+    ) {
+        super();
+
+        let raw: RawBinaryCoStream;
+
+        if ("fromRaw" in options) {
+            raw = options.fromRaw;
+        } else {
+            const rawOwner = options.owner._raw;
+
+            raw = rawOwner.createBinaryStream();
+        }
+
+        Object.defineProperties(this, {
+            id: { value: raw.id, enumerable: false },
+            _type: { value: "BinaryCoStream", enumerable: false },
+            _owner: {
+                get: () =>
+                    raw.group instanceof RawAccount
+                        ? Account.fromRaw(raw.group)
+                        : Group.fromRaw(raw.group),
+                enumerable: false,
+            },
+            _raw: { value: raw, enumerable: false },
+            _loadedAs: {
+                get: () => controlledAccountFromNode(raw.core.node),
+                enumerable: false,
+            },
+            _schema: { value: this.constructor, enumerable: false },
+        });
+    }
+
+    static fromRaw(raw: RawBinaryCoStream) {
+        return new BinaryCoStreamImplClass(undefined, { fromRaw: raw });
+    }
+
+    getChunks(options?: {
+        allowUnfinished?: boolean;
+    }):
+        | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
+        | undefined {
+        return this._raw.getBinaryChunks(options?.allowUnfinished);
+    }
+
+    start(options: BinaryStreamInfo): void {
+        this._raw.startBinaryStream(options);
+    }
+
+    push(data: Uint8Array): void {
+        this._raw.pushBinaryStreamChunk(data);
+    }
+
+    end(): void {
+        this._raw.endBinaryStream();
+    }
+
+    toJSON(): object | any[] {
+        return {
+            ...this.getChunks(),
+            co: {
+                id: this.id,
+                type: "BinaryCoStream",
+            },
+        };
+    }
+
+    [inspect]() {
+        return this.toJSON();
+    }
+}
+
+export const BinaryCoStreamImpl =
+    BinaryCoStreamImplClass as BinaryCoStreamSchema;

package/src/coValues/construction.ts

@@ -0,0 +1,110 @@
+import { Effect, Sink, Stream } from "effect";
+import {
+    CoValueSchema,
+    CoValue,
+    ID,
+    SubclassedConstructor,
+} from "../coValueInterfaces.js";
+import { UnavailableError } from "../errors.js";
+import { ControlledAccount, ControlledAccountCtx } from "./account/account.js";
+import { ValueRef } from "../refs.js";
+import { SubscriptionScope } from "../subscriptionScope.js";
+
+export abstract class SharedCoValueConstructor {
+    id!: ID<this>;
+    _schema!: CoValueSchema;
+    _loadedAs!: ControlledAccount;
+
+    static loadEf<V extends CoValue>(
+        this: CoValueSchema & SubclassedConstructor<V>,
+        id: ID<V>
+    ): Effect.Effect<V, UnavailableError, ControlledAccountCtx> {
+        return Effect.gen(this, function* (_) {
+            const controlledAccount = yield* _(ControlledAccountCtx);
+            return yield* _(
+                new ValueRef(id as ID<V>, controlledAccount, this).loadEf()
+            );
+        });
+    }
+
+    static load<V extends CoValue>(
+        this: CoValueSchema & SubclassedConstructor<V>,
+        id: ID<V>,
+        options: {
+            as: ControlledAccount;
+            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>(
+        this: CoValueSchema & SubclassedConstructor<V>,
+        id: ID<V>,
+        options: { as: ControlledAccount },
+        onUpdate: (value: V) => void
+    ): () => void {
+        void Effect.runPromise(
+            Effect.provideService(
+                this.subscribeEf(id).pipe(
+                    Stream.run(
+                        Sink.forEach((update) =>
+                            Effect.sync(() => onUpdate(update))
+                        )
+                    )
+                ),
+                ControlledAccountCtx,
+                options.as
+            )
+        );
+
+        return function unsubscribe() {};
+    }
+
+    static subscribeEf<V extends CoValue>(
+        this: CoValueSchema & SubclassedConstructor<V>,
+        id: ID<V>
+    ): Stream.Stream<V, UnavailableError, ControlledAccountCtx> {
+        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._schema as unknown as CoValueSchema).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._schema as unknown as CoValueSchema).subscribeEf(
+                this.id as unknown as ID<CoValue>
+            ),
+            ControlledAccountCtx,
+            this._loadedAs
+        ) as unknown as  Stream.Stream<this, UnavailableError, never>;
+    }
+}

package/src/coValues/extensions/imageDef.ts

@@ -0,0 +1,51 @@
+import * as S from "@effect/schema/Schema";
+import { CoMapOf } from "../coMap/coMapOf.js";
+import { BinaryCoStreamImpl } from "../coStream/coStreamOf.js";
+import { BinaryCoStream } from "../coStream/coStream.js";
+import { subscriptionsScopes } from "../../subscriptionScope.js";
+
+export class ImageDefinition extends CoMapOf(
+    {
+        originalSize: S.tuple(S.number, S.number),
+        placeholderDataURL: S.optional(S.string),
+    },
+    {
+        key: S.templateLiteral(S.string, S.literal("x"), S.string),
+        value: BinaryCoStreamImpl,
+    }
+).as<ImageDefinition>() {
+    get highestResAvailable():
+        | { res: `${number}x${number}`; stream: BinaryCoStream }
+        | undefined {
+        if (!subscriptionsScopes.get(this)) {
+            console.warn(
+                "highestResAvailable() only makes sense when used within a subscription."
+            );
+        }
+
+        const resolutions = Object.keys(this).filter((key) =>
+            key.match(/^\d+x\d+$/)
+        ) as `${number}x${number}`[];
+
+        resolutions.sort((a, b) => {
+            const aWidth = Number(a.split("x")[0]);
+            const bWidth = Number(b.split("x")[0]);
+            return aWidth - bWidth;
+        });
+
+        let highestAvailableResolution: `${number}x${number}` | undefined;
+
+        for (const resolution of resolutions) {
+            if (this[resolution] && this[resolution]?.getChunks()) {
+                highestAvailableResolution = resolution;
+            } else {
+                return (
+                    highestAvailableResolution && {
+                        res: highestAvailableResolution,
+                        stream: this[highestAvailableResolution]!,
+                    }
+                );
+            }
+        }
+    }
+}

package/src/coValues/group/group.ts

@@ -0,0 +1,27 @@
+import * as S from "@effect/schema/Schema";
+import { Everyone, RawGroup, Role } from "cojson";
+import { CoValue, CoValueSchema } from "../../coValueInterfaces.js";
+import { ValueRef } from "../../refs.js";
+import { AnyAccount } from "../account/account.js";
+
+export interface AnyGroup<
+    P extends CoValueSchema | S.Schema<null> = CoValueSchema | S.Schema<null>,
+    R extends CoValueSchema | S.Schema<null> = CoValueSchema | S.Schema<null>,
+> extends CoValue<"Group", RawGroup> {
+    profile?: S.Schema.To<P>;
+    root?: S.Schema.To<R>;
+    _refs: {
+        profile: ValueRef<S.Schema.To<P>>;
+        root: ValueRef<S.Schema.To<R>>;
+    };
+    addMember(member: Everyone | AnyAccount, role: Role): this;
+    myRole(): Role | undefined;
+}
+
+export interface GroupSchema<
+    Self,
+    P extends CoValueSchema | S.Schema<null>,
+    R extends CoValueSchema | S.Schema<null>,
+> extends CoValueSchema<Self, AnyGroup<P, R>, "Group", undefined> {
+    new (options: { owner: AnyAccount | AnyGroup }): AnyGroup<P, R>;
+}