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

package/src/coValues/coStream/coStreamOf.ts

@@ -1,404 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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/group/group.ts

@@ -1,27 +0,0 @@
-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>;
-}