@trpc/client 11.3.1 → 11.3.2-canary.4

package/dist/links/wsLink/wsClient/wsClient.mjs

@@ -1,323 +0,0 @@
-import { observable, behaviorSubject } from '@trpc/server/observable';
-import { transformResult, run, sleep } from '@trpc/server/unstable-core-do-not-import';
-import { TRPCClientError } from '../../../TRPCClientError.mjs';
-import { lazyDefaults, keepAliveDefaults, exponentialBackoff } from './options.mjs';
-import { RequestManager } from './requestManager.mjs';
-import { TRPCWebSocketClosedError, ResettableTimeout } from './utils.mjs';
-import { backwardCompatibility, WsConnection } from './wsConnection.mjs';
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * A WebSocket client for managing TRPC operations, supporting lazy initialization,
- * reconnection, keep-alive, and request management.
- */ class WsClient {
-    /**
-   * Opens the WebSocket connection. Handles reconnection attempts and updates
-   * the connection state accordingly.
-   */ async open() {
-        this.allowReconnect = true;
-        if (this.connectionState.get().state !== 'connecting') {
-            this.connectionState.next({
-                type: 'state',
-                state: 'connecting',
-                error: null
-            });
-        }
-        try {
-            await this.activeConnection.open();
-        } catch (error) {
-            this.reconnect(new TRPCWebSocketClosedError({
-                message: 'Initialization error',
-                cause: error
-            }));
-            return this.reconnecting;
-        }
-    }
-    /**
-   * Closes the WebSocket connection and stops managing requests.
-   * Ensures all outgoing and pending requests are properly finalized.
-   */ async close() {
-        this.allowReconnect = false;
-        this.inactivityTimeout.stop();
-        const requestsToAwait = [];
-        for (const request of this.requestManager.getRequests()){
-            if (request.message.method === 'subscription') {
-                request.callbacks.complete();
-            } else if (request.state === 'outgoing') {
-                request.callbacks.error(TRPCClientError.from(new TRPCWebSocketClosedError({
-                    message: 'Closed before connection was established'
-                })));
-            } else {
-                requestsToAwait.push(request.end);
-            }
-        }
-        await Promise.all(requestsToAwait).catch(()=>null);
-        await this.activeConnection.close().catch(()=>null);
-        this.connectionState.next({
-            type: 'state',
-            state: 'idle',
-            error: null
-        });
-    }
-    /**
-   * Method to request the server.
-   * Handles data transformation, batching of requests, and subscription lifecycle.
-   *
-   * @param op - The operation details including id, type, path, input and signal
-   * @param transformer - Data transformer for serializing requests and deserializing responses
-   * @param lastEventId - Optional ID of the last received event for subscriptions
-   *
-   * @returns An observable that emits operation results and handles cleanup
-   */ request({ op: { id, type, path, input, signal }, transformer, lastEventId }) {
-        return observable((observer)=>{
-            const abort = this.batchSend({
-                id,
-                method: type,
-                params: {
-                    input: transformer.input.serialize(input),
-                    path,
-                    lastEventId
-                }
-            }, {
-                ...observer,
-                next (event) {
-                    const transformed = transformResult(event, transformer.output);
-                    if (!transformed.ok) {
-                        observer.error(TRPCClientError.from(transformed.error));
-                        return;
-                    }
-                    observer.next({
-                        result: transformed.result
-                    });
-                }
-            });
-            return ()=>{
-                abort();
-                if (type === 'subscription' && this.activeConnection.isOpen()) {
-                    this.send({
-                        id,
-                        method: 'subscription.stop'
-                    });
-                }
-                signal?.removeEventListener('abort', abort);
-            };
-        });
-    }
-    get connection() {
-        return backwardCompatibility(this.activeConnection);
-    }
-    reconnect(closedError) {
-        this.connectionState.next({
-            type: 'state',
-            state: 'connecting',
-            error: TRPCClientError.from(closedError)
-        });
-        if (this.reconnecting) return;
-        const tryReconnect = async (attemptIndex)=>{
-            try {
-                await sleep(this.reconnectRetryDelay(attemptIndex));
-                if (this.allowReconnect) {
-                    await this.activeConnection.close();
-                    await this.activeConnection.open();
-                    if (this.requestManager.hasPendingRequests()) {
-                        this.send(this.requestManager.getPendingRequests().map(({ message })=>message));
-                    }
-                }
-                this.reconnecting = null;
-            } catch  {
-                await tryReconnect(attemptIndex + 1);
-            }
-        };
-        this.reconnecting = tryReconnect(0);
-    }
-    setupWebSocketListeners(ws) {
-        const handleCloseOrError = (cause)=>{
-            const reqs = this.requestManager.getPendingRequests();
-            for (const { message, callbacks } of reqs){
-                if (message.method === 'subscription') continue;
-                callbacks.error(TRPCClientError.from(cause ?? new TRPCWebSocketClosedError({
-                    message: 'WebSocket closed',
-                    cause
-                })));
-                this.requestManager.delete(message.id);
-            }
-        };
-        ws.addEventListener('open', ()=>{
-            run(async ()=>{
-                if (this.lazyMode) {
-                    this.inactivityTimeout.start();
-                }
-                this.callbacks.onOpen?.();
-                this.connectionState.next({
-                    type: 'state',
-                    state: 'pending',
-                    error: null
-                });
-            }).catch((error)=>{
-                ws.close(3000);
-                handleCloseOrError(error);
-            });
-        });
-        ws.addEventListener('message', ({ data })=>{
-            this.inactivityTimeout.reset();
-            if (typeof data !== 'string' || [
-                'PING',
-                'PONG'
-            ].includes(data)) return;
-            const incomingMessage = JSON.parse(data);
-            if ('method' in incomingMessage) {
-                this.handleIncomingRequest(incomingMessage);
-                return;
-            }
-            this.handleResponseMessage(incomingMessage);
-        });
-        ws.addEventListener('close', (event)=>{
-            handleCloseOrError(event);
-            this.callbacks.onClose?.(event);
-            if (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) {
-                this.reconnect(new TRPCWebSocketClosedError({
-                    message: 'WebSocket closed',
-                    cause: event
-                }));
-            }
-        });
-        ws.addEventListener('error', (event)=>{
-            handleCloseOrError(event);
-            this.callbacks.onError?.(event);
-            this.reconnect(new TRPCWebSocketClosedError({
-                message: 'WebSocket closed',
-                cause: event
-            }));
-        });
-    }
-    handleResponseMessage(message) {
-        const request = this.requestManager.getPendingRequest(message.id);
-        if (!request) return;
-        request.callbacks.next(message);
-        let completed = true;
-        if ('result' in message && request.message.method === 'subscription') {
-            if (message.result.type === 'data') {
-                request.message.params.lastEventId = message.result.id;
-            }
-            if (message.result.type !== 'stopped') {
-                completed = false;
-            }
-        }
-        if (completed) {
-            request.callbacks.complete();
-            this.requestManager.delete(message.id);
-        }
-    }
-    handleIncomingRequest(message) {
-        if (message.method === 'reconnect') {
-            this.reconnect(new TRPCWebSocketClosedError({
-                message: 'Server requested reconnect'
-            }));
-        }
-    }
-    /**
-   * Sends a message or batch of messages directly to the server.
-   */ send(messageOrMessages) {
-        if (!this.activeConnection.isOpen()) {
-            throw new Error('Active connection is not open');
-        }
-        const messages = messageOrMessages instanceof Array ? messageOrMessages : [
-            messageOrMessages
-        ];
-        this.activeConnection.ws.send(JSON.stringify(messages.length === 1 ? messages[0] : messages));
-    }
-    /**
-   * Groups requests for batch sending.
-   *
-   * @returns A function to abort the batched request.
-   */ batchSend(message, callbacks) {
-        this.inactivityTimeout.reset();
-        run(async ()=>{
-            if (!this.activeConnection.isOpen()) {
-                await this.open();
-            }
-            await sleep(0);
-            if (!this.requestManager.hasOutgoingRequests()) return;
-            this.send(this.requestManager.flush().map(({ message })=>message));
-        }).catch((err)=>{
-            this.requestManager.delete(message.id);
-            callbacks.error(TRPCClientError.from(err));
-        });
-        return this.requestManager.register(message, callbacks);
-    }
-    constructor(opts){
-        /**
-   * Observable tracking the current connection state, including errors.
-   */ _define_property(this, "connectionState", void 0);
-        _define_property(this, "allowReconnect", false);
-        _define_property(this, "requestManager", new RequestManager());
-        _define_property(this, "activeConnection", void 0);
-        _define_property(this, "reconnectRetryDelay", void 0);
-        _define_property(this, "inactivityTimeout", void 0);
-        _define_property(this, "callbacks", void 0);
-        _define_property(this, "lazyMode", void 0);
-        /**
-   * Manages the reconnection process for the WebSocket using retry logic.
-   * Ensures that only one reconnection attempt is active at a time by tracking the current
-   * reconnection state in the `reconnecting` promise.
-   */ _define_property(this, "reconnecting", null);
-        // Initialize callbacks, connection parameters, and options.
-        this.callbacks = {
-            onOpen: opts.onOpen,
-            onClose: opts.onClose,
-            onError: opts.onError
-        };
-        const lazyOptions = {
-            ...lazyDefaults,
-            ...opts.lazy
-        };
-        // Set up inactivity timeout for lazy connections.
-        this.inactivityTimeout = new ResettableTimeout(()=>{
-            if (this.requestManager.hasOutgoingRequests() || this.requestManager.hasPendingRequests()) {
-                this.inactivityTimeout.reset();
-                return;
-            }
-            this.close().catch(()=>null);
-        }, lazyOptions.closeMs);
-        // Initialize the WebSocket connection.
-        this.activeConnection = new WsConnection({
-            WebSocketPonyfill: opts.WebSocket,
-            urlOptions: opts,
-            keepAlive: {
-                ...keepAliveDefaults,
-                ...opts.keepAlive
-            }
-        });
-        this.activeConnection.wsObservable.subscribe({
-            next: (ws)=>{
-                if (!ws) return;
-                this.setupWebSocketListeners(ws);
-            }
-        });
-        this.reconnectRetryDelay = opts.retryDelayMs ?? exponentialBackoff;
-        this.lazyMode = lazyOptions.enabled;
-        this.connectionState = behaviorSubject({
-            type: 'state',
-            state: lazyOptions.enabled ? 'idle' : 'connecting',
-            error: null
-        });
-        // Automatically open the connection if lazy mode is disabled.
-        if (!this.lazyMode) {
-            this.open().catch(()=>null);
-        }
-    }
-}
-
-export { WsClient };

package/dist/links/wsLink/wsClient/wsConnection.d.ts

@@ -1,79 +0,0 @@
-import type { UrlOptionsWithConnectionParams } from '../../internals/urlWithConnectionParams';
-interface PingPongOptions {
-    /**
-     * The interval (in milliseconds) between "PING" messages.
-     */
-    intervalMs: number;
-    /**
-     * The timeout (in milliseconds) to wait for a "PONG" response before closing the connection.
-     */
-    pongTimeoutMs: number;
-}
-export interface WebSocketConnectionOptions {
-    WebSocketPonyfill?: typeof WebSocket;
-    urlOptions: UrlOptionsWithConnectionParams;
-    keepAlive: PingPongOptions & {
-        enabled: boolean;
-    };
-}
-/**
- * Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,
- * and observable state tracking.
- */
-export declare class WsConnection {
-    static connectCount: number;
-    id: number;
-    private readonly WebSocketPonyfill;
-    private readonly urlOptions;
-    private readonly keepAliveOpts;
-    readonly wsObservable: import("@trpc/server/observable").BehaviorSubject<WebSocket | null>;
-    constructor(opts: WebSocketConnectionOptions);
-    get ws(): WebSocket | null;
-    private set ws(value);
-    /**
-     * Checks if the WebSocket connection is open and ready to communicate.
-     */
-    isOpen(): this is {
-        ws: WebSocket;
-    };
-    /**
-     * Checks if the WebSocket connection is closed or in the process of closing.
-     */
-    isClosed(): this is {
-        ws: WebSocket;
-    };
-    /**
-     * Manages the WebSocket opening process, ensuring that only one open operation
-     * occurs at a time. Tracks the ongoing operation with `openPromise` to avoid
-     * redundant calls and ensure proper synchronization.
-     *
-     * Sets up the keep-alive mechanism and necessary event listeners for the connection.
-     *
-     * @returns A promise that resolves once the WebSocket connection is successfully opened.
-     */
-    private openPromise;
-    open(): Promise<void>;
-    /**
-     * Closes the WebSocket connection gracefully.
-     * Waits for any ongoing open operation to complete before closing.
-     */
-    close(): Promise<void>;
-}
-/**
- * Provides a backward-compatible representation of the connection state.
- */
-export declare function backwardCompatibility(connection: WsConnection): {
-    readonly id: number;
-    readonly state: "open";
-    readonly ws: WebSocket;
-} | {
-    readonly id: number;
-    readonly state: "closed";
-    readonly ws: WebSocket;
-} | {
-    readonly id: number;
-    readonly state: "connecting";
-    readonly ws: WebSocket;
-} | null;
-export {};
-//# sourceMappingURL=wsConnection.d.ts.map

package/dist/links/wsLink/wsClient/wsConnection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wsConnection.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/wsConnection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAoB9F,UAAU,eAAe;IACvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAuDD,MAAM,WAAW,0BAA0B;IACzC,iBAAiB,CAAC,EAAE,OAAO,SAAS,CAAC;IACrC,UAAU,EAAE,8BAA8B,CAAC;IAC3C,SAAS,EAAE,eAAe,GAAG;QAC3B,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED;;;GAGG;AACH,qBAAa,YAAY;IACvB,MAAM,CAAC,YAAY,SAAK;IACjB,EAAE,SAA+B;IAExC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0C;IACxE,SAAgB,YAAY,sEAA2C;gBAE3D,IAAI,EAAE,0BAA0B;IAY5C,IAAW,EAAE,qBAEZ;IAED,OAAO,KAAK,EAAE,QAEb;IAED;;OAEG;IACI,MAAM,IAAI,IAAI,IAAI;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAQ1C;;OAEG;IACI,QAAQ,IAAI,IAAI,IAAI;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAQ5C;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW,CAA8B;IACpC,IAAI;IAyCjB;;;OAGG;IACU,KAAK;CAOnB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,YAAY;;;;;;;;;;;;SA0B7D"}

package/dist/links/wsLink/wsClient/wsConnection.js

@@ -1,188 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var utils = require('./utils.js');
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Opens a WebSocket connection asynchronously and returns a promise
- * that resolves when the connection is successfully established.
- * The promise rejects if an error occurs during the connection attempt.
- */ function asyncWsOpen(ws) {
-    const { promise, resolve, reject } = utils.withResolvers();
-    ws.addEventListener('open', ()=>{
-        ws.removeEventListener('error', reject);
-        resolve();
-    });
-    ws.addEventListener('error', reject);
-    return promise;
-}
-/**
- * Sets up a periodic ping-pong mechanism to keep the WebSocket connection alive.
- *
- * - Sends "PING" messages at regular intervals defined by `intervalMs`.
- * - If a "PONG" response is not received within the `pongTimeoutMs`, the WebSocket is closed.
- * - The ping timer resets upon receiving any message to maintain activity.
- * - Automatically starts the ping process when the WebSocket connection is opened.
- * - Cleans up timers when the WebSocket is closed.
- *
- * @param ws - The WebSocket instance to manage.
- * @param options - Configuration options for ping-pong intervals and timeouts.
- */ function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
-    let pingTimeout;
-    let pongTimeout;
-    function start() {
-        pingTimeout = setTimeout(()=>{
-            ws.send('PING');
-            pongTimeout = setTimeout(()=>{
-                ws.close();
-            }, pongTimeoutMs);
-        }, intervalMs);
-    }
-    function reset() {
-        clearTimeout(pingTimeout);
-        start();
-    }
-    function pong() {
-        clearTimeout(pongTimeout);
-        reset();
-    }
-    ws.addEventListener('open', start);
-    ws.addEventListener('message', ({ data })=>{
-        clearTimeout(pingTimeout);
-        start();
-        if (data === 'PONG') {
-            pong();
-        }
-    });
-    ws.addEventListener('close', ()=>{
-        clearTimeout(pingTimeout);
-        clearTimeout(pongTimeout);
-    });
-}
-/**
- * Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,
- * and observable state tracking.
- */ class WsConnection {
-    get ws() {
-        return this.wsObservable.get();
-    }
-    set ws(ws) {
-        this.wsObservable.next(ws);
-    }
-    /**
-   * Checks if the WebSocket connection is open and ready to communicate.
-   */ isOpen() {
-        return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
-    }
-    /**
-   * Checks if the WebSocket connection is closed or in the process of closing.
-   */ isClosed() {
-        return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
-    }
-    async open() {
-        if (this.openPromise) return this.openPromise;
-        this.id = ++WsConnection.connectCount;
-        const wsPromise = utils.prepareUrl(this.urlOptions).then((url)=>new this.WebSocketPonyfill(url));
-        this.openPromise = wsPromise.then(async (ws)=>{
-            this.ws = ws;
-            // Setup ping listener
-            ws.addEventListener('message', function({ data }) {
-                if (data === 'PING') {
-                    this.send('PONG');
-                }
-            });
-            if (this.keepAliveOpts.enabled) {
-                setupPingInterval(ws, this.keepAliveOpts);
-            }
-            ws.addEventListener('close', ()=>{
-                if (this.ws === ws) {
-                    this.ws = null;
-                }
-            });
-            await asyncWsOpen(ws);
-            if (this.urlOptions.connectionParams) {
-                ws.send(await utils.buildConnectionMessage(this.urlOptions.connectionParams));
-            }
-        });
-        try {
-            await this.openPromise;
-        } finally{
-            this.openPromise = null;
-        }
-    }
-    /**
-   * Closes the WebSocket connection gracefully.
-   * Waits for any ongoing open operation to complete before closing.
-   */ async close() {
-        try {
-            await this.openPromise;
-        } finally{
-            this.ws?.close();
-        }
-    }
-    constructor(opts){
-        _define_property(this, "id", ++WsConnection.connectCount);
-        _define_property(this, "WebSocketPonyfill", void 0);
-        _define_property(this, "urlOptions", void 0);
-        _define_property(this, "keepAliveOpts", void 0);
-        _define_property(this, "wsObservable", observable.behaviorSubject(null));
-        /**
-   * Manages the WebSocket opening process, ensuring that only one open operation
-   * occurs at a time. Tracks the ongoing operation with `openPromise` to avoid
-   * redundant calls and ensure proper synchronization.
-   *
-   * Sets up the keep-alive mechanism and necessary event listeners for the connection.
-   *
-   * @returns A promise that resolves once the WebSocket connection is successfully opened.
-   */ _define_property(this, "openPromise", null);
-        this.WebSocketPonyfill = opts.WebSocketPonyfill ?? WebSocket;
-        if (!this.WebSocketPonyfill) {
-            throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
-        }
-        this.urlOptions = opts.urlOptions;
-        this.keepAliveOpts = opts.keepAlive;
-    }
-}
-_define_property(WsConnection, "connectCount", 0);
-/**
- * Provides a backward-compatible representation of the connection state.
- */ function backwardCompatibility(connection) {
-    if (connection.isOpen()) {
-        return {
-            id: connection.id,
-            state: 'open',
-            ws: connection.ws
-        };
-    }
-    if (connection.isClosed()) {
-        return {
-            id: connection.id,
-            state: 'closed',
-            ws: connection.ws
-        };
-    }
-    if (!connection.ws) {
-        return null;
-    }
-    return {
-        id: connection.id,
-        state: 'connecting',
-        ws: connection.ws
-    };
-}
-
-exports.WsConnection = WsConnection;
-exports.backwardCompatibility = backwardCompatibility;