@milaboratories/pl-client 2.17.7 → 2.17.9

package/dist/core/websocket_stream.cjs

@@ -1,353 +1,284 @@
-'use strict';
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_errors = require('./errors.cjs');
+const require_retry_strategy = require('../helpers/retry_strategy.cjs');
+let denque = require("denque");
+denque = require_runtime.__toESM(denque);
+let undici = require("undici");
 
-var undici = require('undici');
-var Denque = require('denque');
-var retry_strategy = require('../helpers/retry_strategy.cjs');
-var errors = require('./errors.cjs');
-
-var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState[ConnectionState["NEW"] = 0] = "NEW";
-    ConnectionState[ConnectionState["CONNECTING"] = 1] = "CONNECTING";
-    ConnectionState[ConnectionState["CONNECTED"] = 2] = "CONNECTED";
-    ConnectionState[ConnectionState["CLOSING"] = 3] = "CLOSING";
-    ConnectionState[ConnectionState["CLOSED"] = 4] = "CLOSED";
-})(ConnectionState || (ConnectionState = {}));
+//#region src/core/websocket_stream.ts
+var ConnectionState = /* @__PURE__ */ function(ConnectionState) {
+	ConnectionState[ConnectionState["NEW"] = 0] = "NEW";
+	ConnectionState[ConnectionState["CONNECTING"] = 1] = "CONNECTING";
+	ConnectionState[ConnectionState["CONNECTED"] = 2] = "CONNECTED";
+	ConnectionState[ConnectionState["CLOSING"] = 3] = "CLOSING";
+	ConnectionState[ConnectionState["CLOSED"] = 4] = "CLOSED";
+	return ConnectionState;
+}(ConnectionState || {});
 /**
- * WebSocket-based bidirectional stream implementation for LLTransaction.
- * Implements BiDiStream interface which is compatible with DuplexStreamingCall.
- */
-class WebSocketBiDiStream {
-    url;
-    serializeClientMessage;
-    parseServerMessage;
-    options;
-    // Connection
-    ws = null;
-    connectionState = ConnectionState.NEW;
-    reconnection;
-    // Send management
-    sendQueue = new Denque();
-    sendCompleted = false;
-    onComplete;
-    // Response management
-    responseQueue = new Denque();
-    responseResolvers = [];
-    // Error tracking
-    lastError;
-    // === Public API ===
-    requests = {
-        send: async (message) => {
-            return await this.enqueueSend(message);
-        },
-        complete: async () => {
-            if (this.sendCompleted)
-                return;
-            await this.drainSendQueue(); // ensure we sent all already queued messages before closing the stream
-            try {
-                await this.onComplete(this); // custom onComplete may send additional messages
-            }
-            catch {
-                // When 'complete' gets called concurrently with connection break or over a broken
-                // transaction stream (server decided it should drop transaction), server would close
-                // connection anyway on its end. We can safely ignore error here and just continue working.
-            }
-            this.sendCompleted = true;
-        },
-    };
-    responses = {
-        [Symbol.asyncIterator]: () => this.createResponseIterator(),
-    };
-    close() {
-        this.reconnection.cancel();
-        if (this.connectionState < ConnectionState.CONNECTED) {
-            // Never reached CONNECTED state. ws.close() will never trigger 'close' event.
-            this.ws?.close();
-            this.onClose();
-            return;
-        }
-        if (!this.progressConnectionState(ConnectionState.CLOSING))
-            return;
-        this.ws.close();
-    }
-    constructor(url, serializeClientMessage, parseServerMessage, options = {}) {
-        this.url = url;
-        this.serializeClientMessage = serializeClientMessage;
-        this.parseServerMessage = parseServerMessage;
-        this.options = options;
-        this.onComplete = this.options.onComplete ?? ((stream) => stream.close());
-        const retryConfig = this.options.retryConfig ?? {};
-        this.reconnection = new retry_strategy.RetryStrategy(retryConfig, {
-            onRetry: () => {
-                void this.connect();
-            },
-            onMaxAttemptsReached: (error) => this.handleError(error),
-        });
-        if (this.options.abortSignal?.aborted) {
-            this.progressConnectionState(ConnectionState.CLOSED);
-            return;
-        }
-        this.options.abortSignal?.addEventListener("abort", () => this.close());
-        this.connect();
-    }
-    // === Connection Lifecycle ===
-    connect() {
-        if (this.options.abortSignal?.aborted)
-            return;
-        // Prevent reconnecting after first successful connection.
-        if (!this.progressConnectionState(ConnectionState.CONNECTING))
-            return;
-        try {
-            this.ws = this.createWebSocket();
-            this.ws.addEventListener("open", () => this.onOpen());
-            this.ws.addEventListener("message", (event) => this.onMessage(event.data));
-            this.ws.addEventListener("error", (error) => this.onError(error));
-            this.ws.addEventListener("close", () => this.onClose());
-        }
-        catch (error) {
-            this.lastError = this.toError(error);
-            this.reconnection.schedule();
-        }
-    }
-    createWebSocket() {
-        const options = {};
-        if (this.options.jwtToken)
-            options.headers = { authorization: `Bearer ${this.options.jwtToken}` };
-        if (this.options.dispatcher)
-            options.dispatcher = this.options.dispatcher;
-        const ws = new undici.WebSocket(this.url, options);
-        ws.binaryType = "arraybuffer";
-        return ws;
-    }
-    onOpen() {
-        this.progressConnectionState(ConnectionState.CONNECTED);
-        this.processSendQueue();
-    }
-    onMessage(data) {
-        if (!(data instanceof ArrayBuffer)) {
-            this.handleError(new Error(`Unexpected WS message format: ${typeof data}`));
-            return;
-        }
-        try {
-            const message = this.parseServerMessage(new Uint8Array(data));
-            this.deliverResponse(message);
-        }
-        catch (error) {
-            this.handleError(this.toError(error));
-        }
-    }
-    onError(error) {
-        if (this.connectionState < ConnectionState.CONNECTED) {
-            // Try to connect several times until we succeed or run out of attempts.
-            this.lastError = this.toError(error);
-            this.reconnection.schedule();
-            return;
-        }
-        this.handleError(this.toError(error));
-    }
-    onClose() {
-        this.progressConnectionState(ConnectionState.CLOSED);
-        // If abort signal was triggered, use that as the error source
-        if (this.options.abortSignal?.aborted && !this.lastError) {
-            const reason = this.options.abortSignal.reason;
-            if (reason instanceof Error) {
-                this.lastError = reason;
-            }
-            else if (reason !== undefined) {
-                this.lastError = new Error(String(reason), { cause: reason });
-            }
-            else {
-                this.lastError = this.createStreamClosedError();
-            }
-        }
-        if (!this.lastError) {
-            this.rejectAllSendOperations(this.createStreamClosedError());
-            this.resolveAllPendingResponses(); // unblock active async iterator
-        }
-        else {
-            this.rejectAllPendingOperations(this.lastError);
-        }
-    }
-    // === Send Queue Management ===
-    enqueueSend(message) {
-        if (this.sendCompleted) {
-            throw new Error("Cannot send: stream already completed");
-        }
-        if (this.options.abortSignal?.aborted) {
-            throw new Error("Cannot send: stream aborted");
-        }
-        return new Promise((resolve, reject) => {
-            this.sendQueue.push({ message, resolve, reject });
-            this.processSendQueue();
-        });
-    }
-    processSendQueue() {
-        if (!this.canSendMessages())
-            return;
-        while (this.sendQueue.length > 0) {
-            const queued = this.sendQueue.shift();
-            this.sendQueuedMessage(queued);
-        }
-    }
-    canSendMessages() {
-        return this.connectionState === ConnectionState.CONNECTED;
-    }
-    sendQueuedMessage(queued) {
-        try {
-            const ws = this.ws;
-            if (!ws) {
-                throw new Error("WebSocket is not connected");
-            }
-            // Check if WebSocket is in a valid state for sending
-            if (ws.readyState !== undici.WebSocket.OPEN) {
-                throw new Error(`WebSocket is not open (readyState: ${ws.readyState})`);
-            }
-            const binary = this.serializeClientMessage(queued.message);
-            ws.send(binary);
-            queued.resolve();
-        }
-        catch (error) {
-            queued.reject(this.toError(error));
-        }
-    }
-    async drainSendQueue() {
-        const POLL_INTERVAL_MS = 5;
-        while (this.sendQueue.length > 0) {
-            await this.waitForCondition(() => this.sendQueue.length === 0, POLL_INTERVAL_MS);
-        }
-    }
-    waitForCondition(condition, intervalMs) {
-        return new Promise((resolve, reject) => {
-            if (this.options.abortSignal?.aborted) {
-                return reject(this.toError(this.options.abortSignal.reason) ?? new Error("Stream aborted"));
-            }
-            let timeoutId;
-            const onAbort = () => {
-                clearTimeout(timeoutId);
-                reject(this.toError(this.options.abortSignal?.reason) ?? new Error("Stream aborted"));
-            };
-            this.options.abortSignal?.addEventListener("abort", onAbort, { once: true });
-            const check = () => {
-                if (condition() || this.isStreamEnded()) {
-                    this.options.abortSignal?.removeEventListener("abort", onAbort);
-                    resolve();
-                }
-                else {
-                    timeoutId = setTimeout(check, intervalMs);
-                }
-            };
-            check();
-        });
-    }
-    // === Response Delivery ===
-    deliverResponse(message) {
-        if (this.responseResolvers.length > 0) {
-            const resolver = this.responseResolvers.shift();
-            resolver.resolve({ value: message, done: false });
-        }
-        else {
-            this.responseQueue.push(message);
-        }
-    }
-    async *createResponseIterator() {
-        while (true) {
-            const result = await this.nextResponse();
-            if (result.done)
-                break;
-            yield result.value;
-        }
-    }
-    nextResponse() {
-        return new Promise((resolve, reject) => {
-            // Fast path: message already available
-            if (this.responseQueue.length > 0) {
-                const message = this.responseQueue.shift();
-                resolve({ value: message, done: false });
-                return;
-            }
-            // Stream ended
-            if (this.isStreamEnded()) {
-                if (this.lastError) {
-                    reject(this.lastError);
-                }
-                else {
-                    resolve({ value: undefined, done: true });
-                }
-                return;
-            }
-            // Wait for next message
-            this.responseResolvers.push({ resolve, reject });
-        });
-    }
-    resolveAllPendingResponses() {
-        while (this.responseResolvers.length > 0) {
-            const resolver = this.responseResolvers.shift();
-            resolver.resolve({ value: undefined, done: true });
-        }
-    }
-    // === Error Handling ===
-    handleError(error) {
-        this.lastError = error;
-        this.close();
-    }
-    rejectAllPendingOperations(error) {
-        this.rejectAllSendOperations(error);
-        this.rejectAllResponseResolvers(error);
-    }
-    rejectAllSendOperations(error) {
-        while (this.sendQueue.length > 0) {
-            const queued = this.sendQueue.shift();
-            queued.reject(error);
-        }
-    }
-    rejectAllResponseResolvers(error) {
-        while (this.responseResolvers.length > 0) {
-            const resolver = this.responseResolvers.shift();
-            resolver.reject(error);
-        }
-    }
-    createStreamClosedError() {
-        if (this.options.abortSignal?.aborted) {
-            const reason = this.options.abortSignal.reason;
-            if (reason instanceof Error) {
-                return reason;
-            }
-            return new Error("Stream aborted", { cause: reason });
-        }
-        return new Error("Stream closed");
-    }
-    // === Helpers ===
-    isStreamEnded() {
-        return (this.connectionState === ConnectionState.CLOSED || this.options.abortSignal?.aborted || false);
-    }
-    toError(error) {
-        if (error instanceof Error)
-            return error;
-        if (error instanceof undici.ErrorEvent) {
-            const err = error.error;
-            // undici WebSocket throws TypeError with empty message on socket close
-            // (e.g., when connection is lost or server disconnects)
-            if (err instanceof TypeError && !err.message) {
-                return new errors.DisconnectedError("WebSocket connection closed unexpectedly");
-            }
-            return err instanceof Error ? err : new Error("WebSocket error", { cause: error });
-        }
-        return new Error(String(error));
-    }
-    /**
-     * Connection state progresses linearly from NEW to CLOSED and never goes back.
-     * This internal contract dramatically simplifies the internal stream state management.
-     *
-     * If you ever feel the need to make this contract less strict, think twice.
-     */
-    progressConnectionState(newState) {
-        if (newState < this.connectionState) {
-            return false;
-        }
-        this.connectionState = newState;
-        return true;
-    }
-}
+* WebSocket-based bidirectional stream implementation for LLTransaction.
+* Implements BiDiStream interface which is compatible with DuplexStreamingCall.
+*/
+var WebSocketBiDiStream = class {
+	ws = null;
+	connectionState = ConnectionState.NEW;
+	reconnection;
+	sendQueue = new denque.default();
+	sendCompleted = false;
+	onComplete;
+	responseQueue = new denque.default();
+	responseResolvers = [];
+	lastError;
+	abortHandler;
+	requests = {
+		send: async (message) => {
+			return await this.enqueueSend(message);
+		},
+		complete: async () => {
+			if (this.sendCompleted) return;
+			await this.drainSendQueue();
+			try {
+				await this.onComplete(this);
+			} catch {}
+			this.sendCompleted = true;
+		}
+	};
+	responses = { [Symbol.asyncIterator]: () => this.createResponseIterator() };
+	close() {
+		this.reconnection.cancel();
+		if (this.connectionState < ConnectionState.CONNECTED) {
+			this.ws?.close();
+			this.onClose();
+			return;
+		}
+		if (!this.progressConnectionState(ConnectionState.CLOSING)) return;
+		this.ws.close();
+	}
+	constructor(url, serializeClientMessage, parseServerMessage, options = {}) {
+		this.url = url;
+		this.serializeClientMessage = serializeClientMessage;
+		this.parseServerMessage = parseServerMessage;
+		this.options = options;
+		this.onComplete = this.options.onComplete ?? ((stream) => stream.close());
+		this.reconnection = new require_retry_strategy.RetryStrategy(this.options.retryConfig ?? {}, {
+			onRetry: () => {
+				this.connect();
+			},
+			onMaxAttemptsReached: (error) => this.handleError(error)
+		});
+		if (this.options.abortSignal?.aborted) {
+			this.progressConnectionState(ConnectionState.CLOSED);
+			return;
+		}
+		this.abortHandler = () => this.close();
+		this.options.abortSignal?.addEventListener("abort", this.abortHandler, { once: true });
+		this.connect();
+	}
+	connect() {
+		if (this.options.abortSignal?.aborted) return;
+		if (!this.progressConnectionState(ConnectionState.CONNECTING)) return;
+		try {
+			this.ws = this.createWebSocket();
+			this.ws.addEventListener("open", () => this.onOpen());
+			this.ws.addEventListener("message", (event) => this.onMessage(event.data));
+			this.ws.addEventListener("error", (error) => this.onError(error));
+			this.ws.addEventListener("close", () => this.onClose());
+		} catch (error) {
+			this.lastError = this.toError(error);
+			this.reconnection.schedule();
+		}
+	}
+	createWebSocket() {
+		const options = {};
+		if (this.options.jwtToken) options.headers = { authorization: `Bearer ${this.options.jwtToken}` };
+		if (this.options.dispatcher) options.dispatcher = this.options.dispatcher;
+		const ws = new undici.WebSocket(this.url, options);
+		ws.binaryType = "arraybuffer";
+		return ws;
+	}
+	onOpen() {
+		this.progressConnectionState(ConnectionState.CONNECTED);
+		this.processSendQueue();
+	}
+	onMessage(data) {
+		if (!(data instanceof ArrayBuffer)) {
+			this.handleError(/* @__PURE__ */ new Error(`Unexpected WS message format: ${typeof data}`));
+			return;
+		}
+		try {
+			const message = this.parseServerMessage(new Uint8Array(data));
+			this.deliverResponse(message);
+		} catch (error) {
+			this.handleError(this.toError(error));
+		}
+	}
+	onError(error) {
+		if (this.connectionState < ConnectionState.CONNECTED) {
+			this.lastError = this.toError(error);
+			this.reconnection.schedule();
+			return;
+		}
+		this.handleError(this.toError(error));
+	}
+	onClose() {
+		this.progressConnectionState(ConnectionState.CLOSED);
+		if (this.abortHandler) this.options.abortSignal?.removeEventListener("abort", this.abortHandler);
+		if (this.options.abortSignal?.aborted && !this.lastError) {
+			const reason = this.options.abortSignal.reason;
+			if (reason instanceof Error) this.lastError = reason;
+			else if (reason !== void 0) this.lastError = new Error(String(reason), { cause: reason });
+			else this.lastError = this.createStreamClosedError();
+		}
+		if (!this.lastError) {
+			this.rejectAllSendOperations(this.createStreamClosedError());
+			this.resolveAllPendingResponses();
+		} else this.rejectAllPendingOperations(this.lastError);
+	}
+	enqueueSend(message) {
+		if (this.sendCompleted) throw new Error("Cannot send: stream already completed");
+		if (this.options.abortSignal?.aborted) throw new Error("Cannot send: stream aborted");
+		return new Promise((resolve, reject) => {
+			this.sendQueue.push({
+				message,
+				resolve,
+				reject
+			});
+			this.processSendQueue();
+		});
+	}
+	processSendQueue() {
+		if (!this.canSendMessages()) return;
+		while (this.sendQueue.length > 0) {
+			const queued = this.sendQueue.shift();
+			this.sendQueuedMessage(queued);
+		}
+	}
+	canSendMessages() {
+		return this.connectionState === ConnectionState.CONNECTED;
+	}
+	sendQueuedMessage(queued) {
+		try {
+			const ws = this.ws;
+			if (!ws) throw new Error("WebSocket is not connected");
+			if (ws.readyState !== undici.WebSocket.OPEN) throw new Error(`WebSocket is not open (readyState: ${ws.readyState})`);
+			const binary = this.serializeClientMessage(queued.message);
+			ws.send(binary);
+			queued.resolve();
+		} catch (error) {
+			queued.reject(this.toError(error));
+		}
+	}
+	async drainSendQueue() {
+		const POLL_INTERVAL_MS = 5;
+		while (this.sendQueue.length > 0) await this.waitForCondition(() => this.sendQueue.length === 0, POLL_INTERVAL_MS);
+	}
+	waitForCondition(condition, intervalMs) {
+		return new Promise((resolve, reject) => {
+			if (this.options.abortSignal?.aborted) return reject(this.toError(this.options.abortSignal.reason) ?? /* @__PURE__ */ new Error("Stream aborted"));
+			let timeoutId;
+			const onAbort = () => {
+				clearTimeout(timeoutId);
+				reject(this.toError(this.options.abortSignal?.reason) ?? /* @__PURE__ */ new Error("Stream aborted"));
+			};
+			this.options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+			const check = () => {
+				if (condition() || this.isStreamEnded()) {
+					this.options.abortSignal?.removeEventListener("abort", onAbort);
+					resolve();
+				} else timeoutId = setTimeout(check, intervalMs);
+			};
+			check();
+		});
+	}
+	deliverResponse(message) {
+		if (this.responseResolvers.length > 0) this.responseResolvers.shift().resolve({
+			value: message,
+			done: false
+		});
+		else this.responseQueue.push(message);
+	}
+	async *createResponseIterator() {
+		while (true) {
+			const result = await this.nextResponse();
+			if (result.done) break;
+			yield result.value;
+		}
+	}
+	nextResponse() {
+		return new Promise((resolve, reject) => {
+			if (this.responseQueue.length > 0) {
+				resolve({
+					value: this.responseQueue.shift(),
+					done: false
+				});
+				return;
+			}
+			if (this.isStreamEnded()) {
+				if (this.lastError) reject(this.lastError);
+				else resolve({
+					value: void 0,
+					done: true
+				});
+				return;
+			}
+			this.responseResolvers.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	resolveAllPendingResponses() {
+		while (this.responseResolvers.length > 0) this.responseResolvers.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	handleError(error) {
+		this.lastError = error;
+		this.close();
+	}
+	rejectAllPendingOperations(error) {
+		this.rejectAllSendOperations(error);
+		this.rejectAllResponseResolvers(error);
+	}
+	rejectAllSendOperations(error) {
+		while (this.sendQueue.length > 0) this.sendQueue.shift().reject(error);
+	}
+	rejectAllResponseResolvers(error) {
+		while (this.responseResolvers.length > 0) this.responseResolvers.shift().reject(error);
+	}
+	createStreamClosedError() {
+		if (this.options.abortSignal?.aborted) {
+			const reason = this.options.abortSignal.reason;
+			if (reason instanceof Error) return reason;
+			return new Error("Stream aborted", { cause: reason });
+		}
+		return /* @__PURE__ */ new Error("Stream closed");
+	}
+	isStreamEnded() {
+		return this.connectionState === ConnectionState.CLOSED || this.options.abortSignal?.aborted || false;
+	}
+	toError(error) {
+		if (error instanceof Error) return error;
+		if (error instanceof undici.ErrorEvent) {
+			const err = error.error;
+			if (err instanceof TypeError && !err.message) return new require_errors.DisconnectedError("WebSocket connection closed unexpectedly");
+			return err instanceof Error ? err : new Error("WebSocket error", { cause: error });
+		}
+		return new Error(String(error));
+	}
+	/**
+	* Connection state progresses linearly from NEW to CLOSED and never goes back.
+	* This internal contract dramatically simplifies the internal stream state management.
+	*
+	* If you ever feel the need to make this contract less strict, think twice.
+	*/
+	progressConnectionState(newState) {
+		if (newState < this.connectionState) return false;
+		this.connectionState = newState;
+		return true;
+	}
+};
 
+//#endregion
 exports.WebSocketBiDiStream = WebSocketBiDiStream;
-//# sourceMappingURL=websocket_stream.cjs.map
+//# sourceMappingURL=websocket_stream.cjs.map