@meshagent/meshagent 0.29.4 → 0.30.1

package/dist/esm/storage-client.js

@@ -1,15 +1,18 @@
 import { FileDeletedEvent, FileUpdatedEvent } from "./room-event";
+import { BinaryContent, ControlContent, ErrorContent, JsonContent, FileContent } from "./response";
 import { unpackMessage } from "./utils";
 import { EventEmitter } from "./event-emitter";
+import { RoomServerException } from "./room-server-client";
 export class FileHandle {
     constructor({ id }) {
         this.id = id;
     }
 }
 class StorageEntry {
-    constructor({ name, isFolder }) {
+    constructor({ name, isFolder, size = null }) {
         this.name = name;
         this.isFolder = isFolder;
+        this.size = size;
     }
     nameWithoutExtension() {
         const segments = this.name
@@ -39,41 +42,376 @@ export class StorageClient extends EventEmitter {
         this.client.emit(event);
         this.emit('file.deleted', event);
     }
+    _unexpectedResponseError(operation) {
+        return new RoomServerException(`unexpected return type from storage.${operation}`);
+    }
+    async _invoke(operation, input, callerContext) {
+        return await this.client.invoke({
+            toolkit: "storage",
+            tool: operation,
+            input,
+            callerContext,
+        });
+    }
     async list(path) {
-        const response = (await this.client.sendRequest("storage.list", { path }));
+        const response = await this._invoke("list", { path });
+        if (!(response instanceof JsonContent)) {
+            throw this._unexpectedResponseError("list");
+        }
         const files = response.json["files"];
         const entries = files.map((f) => {
             return new StorageEntry({
                 name: f["name"],
                 isFolder: f["is_folder"],
+                size: typeof f["size"] === "number" ? f["size"] : null,
             });
         });
         entries.sort((a, b) => a.name.localeCompare(b.name));
         return entries;
     }
     async delete(path) {
-        await this.client.sendRequest("storage.delete", { path });
-    }
-    async open(path, { overwrite = false }) {
-        const response = (await this.client.sendRequest("storage.open", { path, overwrite }));
-        return new FileHandle({ id: response.json["handle"] });
+        await this._invoke("delete", { path, recursive: null });
     }
     async exists(path) {
-        const result = (await this.client.sendRequest("storage.exists", { path }));
+        const result = await this._invoke("exists", { path });
+        if (!(result instanceof JsonContent)) {
+            throw this._unexpectedResponseError("exists");
+        }
         return result.json["exists"];
     }
-    async write(handle, bytes) {
-        await this.client.sendRequest("storage.write", { handle: handle.id }, bytes);
+    _defaultUploadName(path, name) {
+        if (typeof name === "string" && name.length > 0) {
+            return name;
+        }
+        const segments = path.split("/").filter((segment) => segment.length > 0);
+        const lastSegment = segments.length > 0 ? segments[segments.length - 1] : undefined;
+        return lastSegment ?? path;
     }
-    async close(handle) {
-        await this.client.sendRequest("storage.close", { handle: handle.id });
+    async upload(path, bytes, { overwrite = false, name, mimeType = null, } = {}) {
+        async function* singleChunk() {
+            yield bytes;
+        }
+        await this.uploadStream(path, singleChunk(), {
+            overwrite,
+            size: bytes.length,
+            name,
+            mimeType,
+        });
+    }
+    async uploadStream(path, chunks, { overwrite = false, chunkSize = 64 * 1024, size = null, name, mimeType = null, } = {}) {
+        const resolvedName = this._defaultUploadName(path, name);
+        const input = new _StorageUploadInputStream({
+            path,
+            overwrite,
+            chunks,
+            chunkSize,
+            size,
+            name: resolvedName,
+            mimeType,
+        });
+        const response = await this.client.invokeStream({
+            toolkit: "storage",
+            tool: "upload",
+            input: input.stream(),
+        });
+        try {
+            for await (const chunk of response) {
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("upload");
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw this._unexpectedResponseError("upload");
+                }
+                if (chunk.headers["kind"] !== "pull") {
+                    throw this._unexpectedResponseError("upload");
+                }
+                input.requestNext();
+            }
+        }
+        finally {
+            input.close();
+        }
     }
     async download(path) {
-        const response = (await this.client.sendRequest("storage.download", { path }));
-        return response;
+        const stream = await this.downloadStream(path);
+        let name = null;
+        let mimeType = null;
+        let expectedSize = null;
+        let bytesReceived = 0;
+        const parts = [];
+        for await (const chunk of stream) {
+            const kind = chunk.headers["kind"];
+            if (kind === "start") {
+                const chunkName = chunk.headers["name"];
+                const chunkMimeType = chunk.headers["mime_type"];
+                const chunkSizeValue = chunk.headers["size"];
+                if (typeof chunkName !== "string" ||
+                    typeof chunkMimeType !== "string" ||
+                    typeof chunkSizeValue !== "number" ||
+                    chunkSizeValue < 0) {
+                    throw this._unexpectedResponseError("download");
+                }
+                name = chunkName;
+                mimeType = chunkMimeType;
+                expectedSize = chunkSizeValue;
+                continue;
+            }
+            if (kind !== "data") {
+                throw this._unexpectedResponseError("download");
+            }
+            parts.push(chunk.data);
+            bytesReceived += chunk.data.length;
+        }
+        if (name == null || mimeType == null || expectedSize == null || bytesReceived !== expectedSize) {
+            throw this._unexpectedResponseError("download");
+        }
+        const totalLength = parts.reduce((sum, chunk) => sum + chunk.length, 0);
+        const data = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const part of parts) {
+            data.set(part, offset);
+            offset += part.length;
+        }
+        return new FileContent({ data, name, mimeType });
+    }
+    async downloadStream(path, { chunkSize = 64 * 1024, } = {}) {
+        const input = new _StorageDownloadInputStream({ path, chunkSize });
+        const response = await this.client.invokeStream({
+            toolkit: "storage",
+            tool: "download",
+            input: input.stream(),
+        });
+        const self = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                let metadataReceived = false;
+                let expectedSize = null;
+                let bytesReceived = 0;
+                try {
+                    for await (const chunk of response) {
+                        if (chunk instanceof ErrorContent) {
+                            throw new RoomServerException(chunk.text, chunk.code);
+                        }
+                        if (chunk instanceof ControlContent) {
+                            if (chunk.method === "close") {
+                                if (!metadataReceived || expectedSize == null || bytesReceived !== expectedSize) {
+                                    throw self._unexpectedResponseError("download");
+                                }
+                                return;
+                            }
+                            throw self._unexpectedResponseError("download");
+                        }
+                        if (!(chunk instanceof BinaryContent)) {
+                            throw self._unexpectedResponseError("download");
+                        }
+                        const kind = chunk.headers["kind"];
+                        if (kind === "start") {
+                            if (metadataReceived) {
+                                throw self._unexpectedResponseError("download");
+                            }
+                            const chunkName = chunk.headers["name"];
+                            const chunkMimeType = chunk.headers["mime_type"];
+                            const chunkSizeValue = chunk.headers["size"];
+                            if (typeof chunkName !== "string" ||
+                                typeof chunkMimeType !== "string" ||
+                                typeof chunkSizeValue !== "number" ||
+                                chunkSizeValue < 0) {
+                                throw self._unexpectedResponseError("download");
+                            }
+                            metadataReceived = true;
+                            expectedSize = chunkSizeValue;
+                            yield chunk;
+                            if (expectedSize > 0) {
+                                input.requestNext();
+                            }
+                            continue;
+                        }
+                        if (kind !== "data" || !metadataReceived || expectedSize == null) {
+                            throw self._unexpectedResponseError("download");
+                        }
+                        bytesReceived += chunk.data.length;
+                        if (bytesReceived > expectedSize) {
+                            throw self._unexpectedResponseError("download");
+                        }
+                        yield chunk;
+                        if (bytesReceived < expectedSize) {
+                            input.requestNext();
+                        }
+                    }
+                }
+                finally {
+                    input.close();
+                }
+            },
+        };
     }
     async downloadUrl(path) {
-        const response = (await this.client.sendRequest("storage.download_url", { path }));
+        const response = await this._invoke("download_url", { path });
+        if (!(response instanceof JsonContent)) {
+            throw this._unexpectedResponseError("download_url");
+        }
         return response.json["url"];
     }
 }
+class _StorageDownloadInputStream {
+    constructor({ path, chunkSize }) {
+        this.closed = false;
+        this.pendingPulls = 0;
+        this.waitingResolver = null;
+        this.path = path;
+        this.chunkSize = chunkSize;
+    }
+    requestNext() {
+        if (this.closed) {
+            return;
+        }
+        this.pendingPulls += 1;
+        if (this.waitingResolver) {
+            const resolver = this.waitingResolver;
+            this.waitingResolver = null;
+            resolver();
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        if (this.waitingResolver) {
+            const resolver = this.waitingResolver;
+            this.waitingResolver = null;
+            resolver();
+        }
+    }
+    async *stream() {
+        yield new BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                kind: "start",
+                path: this.path,
+                chunk_size: this.chunkSize,
+            },
+        });
+        while (!this.closed) {
+            if (this.pendingPulls === 0) {
+                await new Promise((resolve) => {
+                    this.waitingResolver = resolve;
+                });
+            }
+            if (this.closed) {
+                return;
+            }
+            if (this.pendingPulls === 0) {
+                continue;
+            }
+            this.pendingPulls -= 1;
+            yield new BinaryContent({
+                data: new Uint8Array(0),
+                headers: { kind: "pull" },
+            });
+        }
+    }
+}
+class _StorageUploadInputStream {
+    constructor({ path, overwrite, chunks, chunkSize, size, name, mimeType, }) {
+        this.closed = false;
+        this.pendingPulls = 0;
+        this.waitingResolver = null;
+        this.pendingChunk = new Uint8Array(0);
+        this.pendingOffset = 0;
+        this.sourceExhausted = false;
+        this.path = path;
+        this.overwrite = overwrite;
+        this.source = chunks[Symbol.asyncIterator]();
+        this.chunkSize = chunkSize;
+        this.size = size;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+    requestNext() {
+        if (this.closed) {
+            return;
+        }
+        this.pendingPulls += 1;
+        if (this.waitingResolver) {
+            const resolver = this.waitingResolver;
+            this.waitingResolver = null;
+            resolver();
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        if (this.waitingResolver) {
+            const resolver = this.waitingResolver;
+            this.waitingResolver = null;
+            resolver();
+        }
+    }
+    async nextChunk() {
+        while (true) {
+            if (this.pendingOffset < this.pendingChunk.length) {
+                const start = this.pendingOffset;
+                const end = Math.min(start + this.chunkSize, this.pendingChunk.length);
+                this.pendingOffset = end;
+                return this.pendingChunk.slice(start, end);
+            }
+            if (this.sourceExhausted) {
+                return null;
+            }
+            const next = await this.source.next();
+            if (next.done) {
+                this.sourceExhausted = true;
+                return null;
+            }
+            if (next.value.length === 0) {
+                continue;
+            }
+            this.pendingChunk = next.value;
+            this.pendingOffset = 0;
+        }
+    }
+    async *stream() {
+        yield new BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                kind: "start",
+                path: this.path,
+                overwrite: this.overwrite,
+                name: this.name,
+                mime_type: this.mimeType,
+                size: this.size,
+            },
+        });
+        while (!this.closed) {
+            if (this.pendingPulls === 0) {
+                await new Promise((resolve) => {
+                    this.waitingResolver = resolve;
+                });
+            }
+            if (this.closed) {
+                return;
+            }
+            if (this.pendingPulls === 0) {
+                continue;
+            }
+            this.pendingPulls -= 1;
+            const chunk = await this.nextChunk();
+            if (chunk == null) {
+                return;
+            }
+            yield new BinaryContent({
+                data: chunk,
+                headers: { kind: "data" },
+            });
+        }
+    }
+}

package/dist/esm/sync-client.d.ts

@@ -1,37 +1,36 @@
 import { EventEmitter } from "./event-emitter";
 import { RoomClient } from "./room-client";
+import { MeshSchema } from "./schema";
 import { MeshDocument } from "./room-server-client";
 export interface SyncClientEvent {
     type: string;
-    doc: MeshDocument;
-}
-export declare class QueuedSync {
-    path: string;
-    base64: string;
-    constructor({ path, base64 }: {
-        path: string;
-        base64: string;
-    });
+    doc?: MeshDocument;
+    status?: unknown;
 }
 export declare class SyncClient extends EventEmitter<SyncClientEvent> {
-    private client;
+    private readonly client;
     private _connectingDocuments;
-    private _changesToSync;
     private _connectedDocuments;
+    private _documentStreams;
     constructor({ room }: {
         room: RoomClient;
     });
+    private _unexpectedResponseError;
+    private _invoke;
     start({ onDone, onError }?: {
         onDone?: () => void;
         onError?: (error: Error) => void;
     }): void;
     dispose(): void;
-    private _handleSync;
+    private _applySyncPayload;
     private _handleStatus;
     create(path: string, json?: Record<string, any>): Promise<void>;
-    open(path: string, { create }?: {
+    open(path: string, { create, initialJson, schema, }?: {
         create?: boolean;
+        initialJson?: Record<string, any>;
+        schema?: MeshSchema;
     }): Promise<MeshDocument>;
     close(path: string): Promise<void>;
     sync(path: string, data: Uint8Array): Promise<void>;
+    private _consumeOpenStream;
 }