@meshagent/meshagent 0.29.4 → 0.30.1

package/dist/node/sync-client.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncClient = exports.QueuedSync = void 0;
+exports.SyncClient = void 0;
 const event_emitter_1 = require("./event-emitter");
 const schema_1 = require("./schema");
-const stream_controller_1 = require("./stream-controller");
 const room_server_client_1 = require("./room-server-client");
+const response_1 = require("./response");
 const utils_1 = require("./utils");
 const runtime_1 = require("./runtime");
 const completer_1 = require("./completer");
@@ -21,99 +21,251 @@ function normalizeSyncPath(path) {
     }
     return normalized;
 }
-;
-class QueuedSync {
-    constructor({ path, base64 }) {
-        this.path = path;
-        this.base64 = base64;
+function parseSyncOpenStateChunkHeaders(headers) {
+    if (headers["kind"] !== "state" ||
+        typeof headers["path"] !== "string" ||
+        typeof headers["schema"] !== "object" ||
+        headers["schema"] == null) {
+        throw new room_server_client_1.RoomServerException("unexpected return type from sync.open");
     }
+    return {
+        kind: "state",
+        path: headers["path"],
+        schema: headers["schema"],
+    };
 }
-exports.QueuedSync = QueuedSync;
+function parseSyncOpenOutputChunkHeaders(headers) {
+    const kind = headers["kind"];
+    if ((kind !== "state" && kind !== "sync") ||
+        typeof headers["path"] !== "string") {
+        throw new room_server_client_1.RoomServerException("unexpected return type from sync.open");
+    }
+    return {
+        kind,
+        path: headers["path"],
+    };
+}
+class SyncOpenStreamState {
+    constructor(params) {
+        this.params = params;
+        this._inputQueue = [];
+        this._inputWaiters = [];
+        this._inputClosed = false;
+    }
+    _enqueueChunk(chunk) {
+        const waiter = this._inputWaiters.shift();
+        if (waiter) {
+            waiter(chunk);
+            return;
+        }
+        this._inputQueue.push(chunk);
+    }
+    _nextChunk() {
+        const queued = this._inputQueue.shift();
+        if (queued !== undefined) {
+            return Promise.resolve(queued);
+        }
+        return new Promise((resolve) => {
+            this._inputWaiters.push(resolve);
+        });
+    }
+    async *inputStream() {
+        yield new response_1.BinaryContent({
+            data: new Uint8Array(),
+            headers: {
+                kind: "start",
+                path: this.params.path,
+                create: this.params.create,
+                vector: this.params.vector,
+                schema: this.params.schemaJson,
+                schema_path: this.params.schemaPath,
+                initial_json: this.params.initialJson,
+            },
+        });
+        while (true) {
+            const chunk = await this._nextChunk();
+            if (chunk === SyncOpenStreamState.INPUT_STREAM_CLOSE) {
+                return;
+            }
+            yield chunk;
+        }
+    }
+    attachTask(task) {
+        this._task = task
+            .catch((error) => {
+            this._error = error;
+            throw error;
+        })
+            .finally(() => {
+            this.closeInputStream();
+        });
+        void this._task.catch(() => undefined);
+    }
+    closeInputStream() {
+        if (this._inputClosed) {
+            return;
+        }
+        this._inputClosed = true;
+        this._enqueueChunk(SyncOpenStreamState.INPUT_STREAM_CLOSE);
+    }
+    queueSync(data) {
+        if (this._error instanceof Error) {
+            throw this._error;
+        }
+        if (this._error !== undefined) {
+            throw new room_server_client_1.RoomServerException(`sync stream failed: ${String(this._error)}`);
+        }
+        if (this._inputClosed) {
+            throw new room_server_client_1.RoomServerException("attempted to sync to a document that is not connected");
+        }
+        this._enqueueChunk(new response_1.BinaryContent({
+            data,
+            headers: { kind: "sync" },
+        }));
+    }
+    async wait() {
+        await this._task;
+    }
+}
+SyncOpenStreamState.INPUT_STREAM_CLOSE = Symbol("sync-open-input-close");
 class SyncClient extends event_emitter_1.EventEmitter {
     constructor({ room }) {
         super();
         this._connectingDocuments = {};
-        this._changesToSync = new stream_controller_1.StreamController();
         this._connectedDocuments = {};
+        this._documentStreams = {};
         this.client = room;
-        this.client.protocol.addHandler("room.sync", this._handleSync.bind(this));
         this.client.protocol.addHandler("room.status", this._handleStatus.bind(this));
     }
+    _unexpectedResponseError(operation) {
+        return new room_server_client_1.RoomServerException(`unexpected return type from sync.${operation}`);
+    }
+    async _invoke(operation, input) {
+        return await this.client.invoke({
+            toolkit: "sync",
+            tool: operation,
+            input,
+        });
+    }
     start({ onDone, onError } = {}) {
         this.client.protocol.start({ onDone, onError });
-        (async () => {
-            for await (const message of this._changesToSync.stream) {
-                await this.client.sendRequest("room.sync", { path: message.path }, utils_1.encoder.encode(message.base64));
-            }
-        })();
     }
     dispose() {
         super.dispose();
-        this._changesToSync.close();
-    }
-    async _handleSync(protocol, messageId, data, bytes) {
-        const headerStr = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
-        const payload = (0, utils_1.splitMessagePayload)(bytes || new Uint8Array());
-        const header = JSON.parse(headerStr);
-        const path = normalizeSyncPath(header["path"]);
-        const isConnecting = this._connectingDocuments[path];
-        if (isConnecting) {
-            await isConnecting;
-        }
-        if (this._connectedDocuments[path]) {
-            const rc = this._connectedDocuments[path];
-            const doc = rc.ref;
+        for (const streamState of Object.values(this._documentStreams)) {
+            streamState.closeInputStream();
+        }
+        this._documentStreams = {};
+        for (const rc of Object.values(this._connectedDocuments)) {
+            (0, runtime_1.unregisterDocument)(rc.ref.id);
+        }
+        this._connectedDocuments = {};
+        this._connectingDocuments = {};
+    }
+    _applySyncPayload(rc, payload) {
+        const doc = rc.ref;
+        if (payload.length > 0) {
             const base64 = utils_1.decoder.decode(payload);
             (0, runtime_1.applyBackendChanges)(doc.id, base64);
-            this.emit("synced", { type: "sync", doc });
-            if (!doc.isSynchronized) {
-                doc.setSynchronizedComplete();
-            }
         }
-        else {
-            throw new room_server_client_1.RoomServerException(`received change for a document that is not connected: ${path}`);
+        this.emit("synced", { type: "sync", doc });
+        if (!doc.isSynchronized) {
+            doc.setSynchronizedComplete();
         }
     }
-    async _handleStatus(protocol, messageId, data, bytes) {
-        const headerStr = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
-        const header = JSON.parse(headerStr);
-        this.emit("status", header.status);
+    async _handleStatus(_protocol, _messageId, _type, bytes) {
+        if (!bytes) {
+            return;
+        }
+        const [header] = (0, utils_1.unpackMessage)(bytes);
+        this.emit("status", { type: "status", status: header.status });
     }
     async create(path, json) {
-        path = normalizeSyncPath(path);
-        await this.client.sendRequest("room.create", { path, json });
+        const normalizedPath = normalizeSyncPath(path);
+        await this._invoke("create", {
+            path: normalizedPath,
+            json: json ?? null,
+            schema: null,
+            schema_path: null,
+        });
     }
-    async open(path, { create = true } = {}) {
+    async open(path, { create = true, initialJson, schema, } = {}) {
         path = normalizeSyncPath(path);
         const pending = this._connectingDocuments[path];
         if (pending) {
             await pending;
         }
-        if (this._connectedDocuments[path]) {
-            const rc = this._connectedDocuments[path];
-            rc.count++;
-            return rc.ref;
+        const connected = this._connectedDocuments[path];
+        if (connected) {
+            connected.count++;
+            return connected.ref;
         }
-        const c = new completer_1.Completer();
-        this._connectingDocuments[path] = c.fut;
+        const connecting = new completer_1.Completer();
+        this._connectingDocuments[path] = connecting.fut;
+        let streamState;
+        let iterator;
         try {
-            const result = (await this.client.sendRequest("room.connect", { path, create }));
-            const schema = schema_1.MeshSchema.fromJson(result.json["schema"]);
+            streamState = new SyncOpenStreamState({
+                path,
+                create,
+                vector: null,
+                schemaJson: schema == null ? null : schema.toJson(),
+                schemaPath: null,
+                initialJson: initialJson ?? null,
+            });
+            const responseStream = await this.client.invokeStream({
+                toolkit: "sync",
+                tool: "open",
+                input: streamState.inputStream(),
+            });
+            iterator = responseStream[Symbol.asyncIterator]();
+            const first = await iterator.next();
+            if (first.done || first.value === undefined) {
+                throw new room_server_client_1.RoomServerException("sync.open stream closed before the initial document state was returned");
+            }
+            const firstChunk = first.value;
+            if (firstChunk instanceof response_1.ErrorContent) {
+                throw new room_server_client_1.RoomServerException(firstChunk.text, firstChunk.code);
+            }
+            if (!(firstChunk instanceof response_1.BinaryContent)) {
+                throw this._unexpectedResponseError("open");
+            }
+            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
+            if (normalizeSyncPath(stateHeaders.path) !== path) {
+                throw new room_server_client_1.RoomServerException("sync.open stream returned a mismatched path");
+            }
             const doc = new room_server_client_1.MeshDocument({
-                schema,
-                sendChangesToBackend: (base64Str) => {
-                    this._changesToSync.add({ path, base64: base64Str });
+                schema: schema_1.MeshSchema.fromJson(stateHeaders.schema),
+                sendChangesToBackend: (base64) => {
+                    try {
+                        streamState?.queueSync(utils_1.encoder.encode(base64));
+                    }
+                    catch {
+                    }
                 },
             });
             const rc = new utils_1.RefCount(doc);
             this._connectedDocuments[path] = rc;
+            this._documentStreams[path] = streamState;
+            this._applySyncPayload(rc, firstChunk.data);
+            streamState.attachTask(this._consumeOpenStream({
+                path,
+                rc,
+                iterator,
+                streamState,
+            }));
             this.emit("connected", { type: "connect", doc });
-            c.complete();
+            connecting.complete(rc);
+            await doc.synchronized;
             return doc;
         }
-        catch (err) {
-            c.completeError(err);
-            throw err;
+        catch (error) {
+            streamState?.closeInputStream();
+            if (iterator) {
+                await iterator.return?.();
+            }
+            connecting.completeError(error);
+            throw error;
         }
         finally {
             delete this._connectingDocuments[path];
@@ -121,11 +273,6 @@ class SyncClient extends event_emitter_1.EventEmitter {
     }
     async close(path) {
         path = normalizeSyncPath(path);
-        const pending = this._connectingDocuments[path];
-        if (pending) {
-            await pending;
-            await new Promise(resolve => setTimeout(resolve, 50));
-        }
         const rc = this._connectedDocuments[path];
         if (!rc) {
             throw new room_server_client_1.RoomServerException(`Not connected to ${path}`);
@@ -134,14 +281,65 @@ class SyncClient extends event_emitter_1.EventEmitter {
         rc.count--;
         if (rc.count === 0) {
             delete this._connectedDocuments[path];
-            await this.client.sendRequest("room.disconnect", { path });
-            (0, runtime_1.unregisterDocument)(doc.id);
+            const streamState = this._documentStreams[path];
+            delete this._documentStreams[path];
+            if (streamState) {
+                streamState.closeInputStream();
+                try {
+                    await streamState.wait();
+                }
+                finally {
+                    (0, runtime_1.unregisterDocument)(doc.id);
+                }
+            }
+            else {
+                (0, runtime_1.unregisterDocument)(doc.id);
+            }
         }
         this.emit("closed", { type: "close", doc });
     }
     async sync(path, data) {
         path = normalizeSyncPath(path);
-        await this.client.sendRequest("room.sync", { path }, data);
+        if (!this._connectedDocuments[path]) {
+            throw new room_server_client_1.RoomServerException("attempted to sync to a document that is not connected");
+        }
+        const streamState = this._documentStreams[path];
+        if (!streamState) {
+            throw new room_server_client_1.RoomServerException("attempted to sync to a document that is not connected");
+        }
+        streamState.queueSync(data);
+    }
+    async _consumeOpenStream(params) {
+        try {
+            while (true) {
+                const next = await params.iterator.next();
+                if (next.done || next.value === undefined) {
+                    return;
+                }
+                const chunk = next.value;
+                if (chunk instanceof response_1.ErrorContent) {
+                    throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof response_1.ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("open");
+                }
+                if (!(chunk instanceof response_1.BinaryContent)) {
+                    throw this._unexpectedResponseError("open");
+                }
+                const headers = parseSyncOpenOutputChunkHeaders(chunk.headers);
+                if (normalizeSyncPath(headers.path) !== params.path) {
+                    throw new room_server_client_1.RoomServerException("sync.open stream returned a mismatched path");
+                }
+                this._applySyncPayload(params.rc, chunk.data);
+            }
+        }
+        finally {
+            params.streamState.closeInputStream();
+            await params.iterator.return?.();
+        }
     }
 }
 exports.SyncClient = SyncClient;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.29.4",
+    "version": "0.30.1",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {