jazz-tools 0.7.0-alpha.9 → 0.7.3

package/src/coValues/coStream.ts

@@ -8,16 +8,20 @@ import type {
     RawCoStream,
     SessionID,
 } from "cojson";
-import { cojsonInternals } from "cojson";
+import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals } from "cojson";
 import type {
     CoValue,
-    ValidItem,
-    Encoding,
-    EncodingFor,
+    Schema,
+    SchemaFor,
     Group,
     ID,
-    Me,
-    IsVal,
+    IfCo,
+    UnCo,
+    AccountCtx,
+    CoValueClass,
+    DeeplyLoaded,
+    DepthsIn,
+    UnavailableError,
 } from "../internal.js";
 import {
     ItemsSym,
@@ -25,46 +29,56 @@ import {
     CoValueBase,
     Ref,
     inspect,
-    val,
+    co,
     InitValues,
     SchemaInit,
+    isRefEncoded,
+    loadCoValue,
+    loadCoValueEf,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    ensureCoValueLoaded,
+    subscribeToExistingCoValue,
 } from "../internal.js";
-import { Schema } from "@effect/schema";
+import { encodeSync, decodeSync } from "@effect/schema/Schema";
+import { Effect, Stream } from "effect";
 
-export type CoStreamEntry<Item> = {
+export type CoStreamEntry<Item> = SingleCoStreamEntry<Item> & {
+    all: IterableIterator<SingleCoStreamEntry<Item>>;
+};
+
+export type SingleCoStreamEntry<Item> = {
     value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
-    ref?: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
-    by?: Account;
+    ref: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
+    by?: Account | null;
     madeAt: Date;
     tx: CojsonInternalTypes.TransactionID;
 };
 
-export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
-    extends CoValueBase
-    implements CoValue<"CoStream", RawCoStream>
-{
-    static Of<Item extends ValidItem<Item, "CoStream"> = any>(
-        item: IsVal<Item, Item>
-    ): typeof CoStream<Item> {
+/** @category CoValues */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class CoStream<Item = any> extends CoValueBase implements CoValue {
+    static Of<Item>(item: IfCo<Item, Item>): typeof CoStream<Item> {
         return class CoStreamOf extends CoStream<Item> {
-            [val.items] = item;
+            [co.items] = item;
         };
     }
 
-    id!: ID<this>;
-    _type!: "CoStream";
+    declare id: ID<this>;
+    declare _type: "CoStream";
     static {
         this.prototype._type = "CoStream";
     }
-    _raw!: RawCoStream;
+    declare _raw: RawCoStream;
 
     /** @internal This is only a marker type and doesn't exist at runtime */
     [ItemsSym]!: Item;
-    static _encoding: any;
-    get _encoding(): {
-        [ItemsSym]: EncodingFor<Item>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _schema: any;
+    get _schema(): {
+        [ItemsSym]: SchemaFor<Item>;
     } {
-        return (this.constructor as typeof CoStream)._encoding;
+        return (this.constructor as typeof CoStream)._schema;
     }
 
     [key: ID<Account>]: CoStreamEntry<Item>;
@@ -76,19 +90,16 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
         [key: SessionID]: CoStreamEntry<Item>;
     };
     get inCurrentSession(): CoStreamEntry<Item> | undefined {
-        return this.perSession[this._loadedAs.sessionID];
+        return this.perSession[this._loadedAs.sessionID!];
     }
 
-    [InitValues]?: {
-        init?: Item[];
-        owner: Account | Group;
-    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [InitValues]?: any;
 
-    constructor(_init: undefined, options: { fromRaw: RawCoStream });
-    constructor(init: Item[], options: { owner: Account | Group });
     constructor(
-        init: Item[] | undefined,
-        options: { owner: Account | Group } | { fromRaw: RawCoStream }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { fromRaw: RawCoStream },
     ) {
         super();
 
@@ -102,7 +113,7 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
             });
         } else {
             this[InitValues] = {
-                init,
+                init: options.init,
                 owner: options.owner,
             };
         }
@@ -110,6 +121,14 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
         return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
     }
 
+    static create<S extends CoStream>(
+        this: CoValueClass<S>,
+        init: S extends CoStream<infer Item> ? UnCo<Item>[] : never,
+        options: { owner: Account | Group },
+    ) {
+        return new this({ init, owner: options.owner });
+    }
+
     push(...items: Item[]) {
         for (const item of items) {
             this.pushItem(item);
@@ -117,24 +136,24 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
     }
 
     private pushItem(item: Item) {
-        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
+        const itemDescriptor = this._schema[ItemsSym] as Schema;
 
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
         } else if ("encoded" in itemDescriptor) {
-            this._raw.push(Schema.encodeSync(itemDescriptor.encoded)(item));
-        } else if ("ref" in itemDescriptor) {
+            this._raw.push(encodeSync(itemDescriptor.encoded)(item));
+        } else if (isRefEncoded(itemDescriptor)) {
             this._raw.push((item as unknown as CoValue).id);
         }
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
+        const itemDescriptor = this._schema[ItemsSym] as Schema;
         const mapper =
             itemDescriptor === "json"
                 ? (v: unknown) => v
                 : "encoded" in itemDescriptor
-                  ? Schema.encodeSync(itemDescriptor.encoded)
+                  ? encodeSync(itemDescriptor.encoded)
                   : (v: unknown) => v && (v as CoValue).id;
 
         return {
@@ -144,13 +163,13 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
                 Object.entries(this).map(([account, entry]) => [
                     account,
                     mapper(entry.value),
-                ])
+                ]),
             ),
             in: Object.fromEntries(
                 Object.entries(this.perSession).map(([session, entry]) => [
                     session,
                     mapper(entry.value),
-                ])
+                ]),
             ),
         };
     }
@@ -159,12 +178,69 @@ export class CoStream<Item extends ValidItem<Item, "CoStream"> = any>
         return this.toJSON();
     }
 
-    static encoding<V extends CoStream>(
+    static schema<V extends CoStream>(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this: { new (...args: any): V } & typeof CoStream,
-        def: { [ItemsSym]: V["_encoding"][ItemsSym] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] },
     ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, def);
+        this._schema ||= {};
+        Object.assign(this._schema, def);
+    }
+
+    /** @category Subscription & Loading */
+    static load<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        as: Account,
+        depth: Depth & DepthsIn<S>,
+    ): Promise<DeeplyLoaded<S, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        depth: Depth & DepthsIn<S>,
+    ): Effect.Effect<DeeplyLoaded<S, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<S, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        as: Account,
+        depth: Depth & DepthsIn<S>,
+        listener: (value: DeeplyLoaded<S, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<S, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<S extends CoStream, Depth>(
+        this: CoValueClass<S>,
+        id: ID<S>,
+        depth: Depth & DepthsIn<S>,
+    ): Stream.Stream<DeeplyLoaded<S, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<S, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<S extends CoStream, Depth>(
+        this: S,
+        depth: Depth & DepthsIn<S>,
+    ): Promise<DeeplyLoaded<S, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<S extends CoStream, Depth>(
+        this: S,
+        depth: Depth & DepthsIn<S>,
+        listener: (value: DeeplyLoaded<S, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
     }
 }
 
@@ -176,38 +252,64 @@ function entryFromRawEntry<Item>(
         at: Date;
         value: JsonValue;
     },
-    loadedAs: Account & Me,
+    loadedAs: Account,
     accountID: ID<Account> | undefined,
-    itemField: Encoding
-) {
+    itemField: Schema,
+): Omit<CoStreamEntry<Item>, "all"> {
     return {
-        get value(): Item | undefined {
+        get value(): NonNullable<Item> extends CoValue
+            ? (CoValue & Item) | null
+            : Item {
             if (itemField === "json") {
-                return rawEntry.value as Item;
+                return rawEntry.value as NonNullable<Item> extends CoValue
+                    ? (CoValue & Item) | null
+                    : Item;
             } else if ("encoded" in itemField) {
-                return Schema.decodeSync(itemField.encoded)(rawEntry.value);
-            } else if ("ref" in itemField) {
-                return this.ref?.accessFrom(accessFrom) as Item;
+                return decodeSync(itemField.encoded)(rawEntry.value);
+            } else if (isRefEncoded(itemField)) {
+                return this.ref?.accessFrom(
+                    accessFrom,
+                    rawEntry.by +
+                        rawEntry.tx.sessionID +
+                        rawEntry.tx.txIndex +
+                        ".value",
+                ) as NonNullable<Item> extends CoValue
+                    ? (CoValue & Item) | null
+                    : Item;
+            } else {
+                throw new Error("Invalid item field schema");
             }
         },
-        get ref() {
-            if (itemField !== "json" && "ref" in itemField) {
+        get ref(): NonNullable<Item> extends CoValue
+            ? Ref<NonNullable<Item>>
+            : never {
+            if (itemField !== "json" && isRefEncoded(itemField)) {
                 const rawId = rawEntry.value;
                 return new Ref(
                     rawId as unknown as ID<CoValue>,
                     loadedAs,
-                    itemField
-                );
+                    itemField,
+                ) as NonNullable<Item> extends CoValue
+                    ? Ref<NonNullable<Item>>
+                    : never;
+            } else {
+                return undefined as never;
             }
         },
         get by() {
             return (
                 accountID &&
-                new Ref(
+                new Ref<Account>(
                     accountID as unknown as ID<Account>,
                     loadedAs,
-                    {ref: () => Account}
-                )?.accessFrom(accessFrom)
+                    { ref: Account, optional: false },
+                )?.accessFrom(
+                    accessFrom,
+                    rawEntry.by +
+                        rawEntry.tx.sessionID +
+                        rawEntry.tx.txIndex +
+                        ".by",
+                )
             );
         },
         madeAt: rawEntry.at,
@@ -242,15 +344,40 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
             const rawEntry = target._raw.lastItemBy(key as AccountID);
 
             if (!rawEntry) return;
-            return entryFromRawEntry(
+            const entry = entryFromRawEntry(
                 receiver,
                 rawEntry,
                 target._loadedAs,
                 key as unknown as ID<Account>,
-                target._encoding[ItemsSym]
+                target._schema[ItemsSym],
             );
+
+            Object.defineProperty(entry, "all", {
+                get: () => {
+                    const allRawEntries = target._raw.itemsBy(key as AccountID);
+                    return (function* () {
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                receiver,
+                                rawEntry.value,
+                                target._loadedAs,
+                                key as unknown as ID<Account>,
+                                target._schema[ItemsSym],
+                            );
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+                },
+            });
+
+            return entry;
         } else if (key === "perSession") {
-            return new Proxy(receiver, CoStreamPerSessionProxyHandler);
+            return new Proxy(
+                {},
+                CoStreamPerSessionProxyHandler(target, receiver),
+            );
         } else {
             return Reflect.get(target, key, receiver);
         }
@@ -261,8 +388,8 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
             typeof value === "object" &&
             SchemaInit in value
         ) {
-            (target.constructor as typeof CoStream)._encoding ||= {};
-            (target.constructor as typeof CoStream)._encoding[ItemsSym] =
+            (target.constructor as typeof CoStream)._schema ||= {};
+            (target.constructor as typeof CoStream)._schema[ItemsSym] =
                 value[SchemaInit];
             init(target);
             return true;
@@ -277,8 +404,8 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
             typeof descriptor.value === "object" &&
             SchemaInit in descriptor.value
         ) {
-            (target.constructor as typeof CoStream)._encoding ||= {};
-            (target.constructor as typeof CoStream)._encoding[ItemsSym] =
+            (target.constructor as typeof CoStream)._schema ||= {};
+            (target.constructor as typeof CoStream)._schema[ItemsSym] =
                 descriptor.value[SchemaInit];
             init(target);
             return true;
@@ -308,46 +435,85 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
     },
 };
 
-const CoStreamPerSessionProxyHandler: ProxyHandler<CoStream> = {
-    get(target, key, receiver) {
+const CoStreamPerSessionProxyHandler = (
+    innerTarget: CoStream,
+    accessFrom: CoStream,
+): ProxyHandler<Record<string, never>> => ({
+    get(_target, key, receiver) {
         if (typeof key === "string" && key.includes("session")) {
             const sessionID = key as SessionID;
-            const rawEntry = target._raw.lastItemIn(sessionID);
+            const rawEntry = innerTarget._raw.lastItemIn(sessionID);
 
             if (!rawEntry) return;
             const by = cojsonInternals.accountOrAgentIDfromSessionID(sessionID);
-            return entryFromRawEntry(
-                target,
+
+            const entry = entryFromRawEntry(
+                accessFrom,
                 rawEntry,
-                target._loadedAs,
+                innerTarget._loadedAs,
                 cojsonInternals.isAccountID(by)
                     ? (by as unknown as ID<Account>)
                     : undefined,
-                target._encoding[ItemsSym]
+                innerTarget._schema[ItemsSym],
             );
+
+            Object.defineProperty(entry, "all", {
+                get: () => {
+                    const allRawEntries = innerTarget._raw.itemsIn(sessionID);
+                    return (function* () {
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                accessFrom,
+                                rawEntry.value,
+                                innerTarget._loadedAs,
+                                cojsonInternals.isAccountID(by)
+                                    ? (by as unknown as ID<Account>)
+                                    : undefined,
+                                innerTarget._schema[ItemsSym],
+                            );
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+                },
+            });
+
+            return entry;
         } else {
-            return Reflect.get(target, key, receiver);
+            return Reflect.get(innerTarget, key, receiver);
         }
     },
-};
+    ownKeys() {
+        return innerTarget._raw.sessions();
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: false,
+            };
+        } else {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        }
+    },
+});
 
-export class BinaryCoStream
-    extends CoValueBase
-    implements CoValue<"BinaryCoStream", RawBinaryCoStream>
-{
-    id!: ID<this>;
-    _type!: "BinaryCoStream";
-    _raw!: RawBinaryCoStream;
+/** @category CoValues */
+export class BinaryCoStream extends CoValueBase implements CoValue {
+    declare id: ID<this>;
+    declare _type: "BinaryCoStream";
+    declare _raw: RawBinaryCoStream;
 
     constructor(
-        init: [] | undefined,
         options:
             | {
                   owner: Account | Group;
               }
             | {
                   fromRaw: RawBinaryCoStream;
-              }
+              },
     ) {
         super();
 
@@ -365,10 +531,18 @@ export class BinaryCoStream
                 value: raw.id,
                 enumerable: false,
             },
+            _type: { value: "BinaryCoStream", enumerable: false },
             _raw: { value: raw, enumerable: false },
         });
     }
 
+    static create<S extends BinaryCoStream>(
+        this: CoValueClass<S>,
+        options: { owner: Account | Group },
+    ) {
+        return new this(options);
+    }
+
     getChunks(options?: {
         allowUnfinished?: boolean;
     }):
@@ -389,6 +563,77 @@ export class BinaryCoStream
         this._raw.endBinaryStream();
     }
 
+    toBlob(options?: { allowUnfinished?: boolean }): Blob | undefined {
+        const chunks = this.getChunks({
+            allowUnfinished: options?.allowUnfinished,
+        });
+
+        if (!chunks) {
+            return undefined;
+        }
+
+        return new Blob(chunks.chunks, { type: chunks.mimeType });
+    }
+
+    static async loadAsBlob(
+        id: ID<BinaryCoStream>,
+        as: Account,
+        options?: {
+            allowUnfinished?: boolean;
+        },
+    ): Promise<Blob | undefined> {
+        const stream = await this.load(id, as, []);
+
+        return stream?.toBlob({
+            allowUnfinished: options?.allowUnfinished,
+        });
+    }
+
+    static async createFromBlob(
+        blob: Blob | File,
+        options: {
+            owner: Group | Account;
+            onProgress?: (progress: number) => void;
+        },
+    ): Promise<BinaryCoStream> {
+        const stream = this.create({ owner: options.owner });
+
+        const start = Date.now();
+
+        const data = new Uint8Array(await blob.arrayBuffer());
+        stream.start({
+            mimeType: blob.type,
+            totalSizeBytes: blob.size,
+            fileName: blob instanceof File ? blob.name : undefined,
+        });
+        const chunkSize = MAX_RECOMMENDED_TX_SIZE;
+
+        let lastProgressUpdate = Date.now();
+
+        for (let idx = 0; idx < data.length; idx += chunkSize) {
+            stream.push(data.slice(idx, idx + chunkSize));
+
+            if (Date.now() - lastProgressUpdate > 100) {
+                options.onProgress?.(idx / data.length);
+                lastProgressUpdate = Date.now();
+            }
+
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        stream.end();
+        const end = Date.now();
+
+        console.debug(
+            "Finished creating binary stream in",
+            (end - start) / 1000,
+            "s - Throughput in MB/s",
+            (1000 * (blob.size / (end - start))) / (1024 * 1024),
+        );
+        options.onProgress?.(1);
+
+        return stream;
+    }
+
     toJSON() {
         return {
             id: this.id,
@@ -400,4 +645,60 @@ export class BinaryCoStream
     [inspect]() {
         return this.toJSON();
     }
+
+    /** @category Subscription & Loading */
+    static load<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        as: Account,
+        depth: Depth & DepthsIn<B>,
+    ): Promise<DeeplyLoaded<B, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        depth: Depth & DepthsIn<B>,
+    ): Effect.Effect<DeeplyLoaded<B, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<B, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        as: Account,
+        depth: Depth & DepthsIn<B>,
+        listener: (value: DeeplyLoaded<B, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<B, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<B extends BinaryCoStream, Depth>(
+        this: CoValueClass<B>,
+        id: ID<B>,
+        depth: Depth & DepthsIn<B>,
+    ): Stream.Stream<DeeplyLoaded<B, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<B, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<B extends BinaryCoStream, Depth>(
+        this: B,
+        depth: Depth & DepthsIn<B>,
+    ): Promise<DeeplyLoaded<B, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<B extends BinaryCoStream, Depth>(
+        this: B,
+        depth: Depth & DepthsIn<B>,
+        listener: (value: DeeplyLoaded<B, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
+    }
 }