@trpc/client 11.0.0-rc.772 → 11.0.0-rc.781

package/dist/links/wsLink.mjs

@@ -1,495 +0,0 @@
-import { behaviorSubject, observable } from '@trpc/server/observable';
-import { transformResult } from '@trpc/server/unstable-core-do-not-import';
-import { TRPCClientError } from '../TRPCClientError.mjs';
-import { getTransformer } from '../internals/transformer.mjs';
-import { resultOf } from './internals/urlWithConnectionParams.mjs';
-
-const run = (fn)=>fn();
-const exponentialBackoff = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
-const lazyDefaults = {
-    enabled: false,
-    closeMs: 0
-};
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */ function createWSClient(opts) {
-    const { WebSocket: WebSocketImpl = WebSocket, retryDelayMs: retryDelayFn = exponentialBackoff } = opts;
-    const lazyOpts = {
-        ...lazyDefaults,
-        ...opts.lazy
-    };
-    /* istanbul ignore next -- @preserve */ if (!WebSocketImpl) {
-        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");
-    }
-    /**
-   * outgoing messages buffer whilst not open
-   */ let outgoing = [];
-    const pendingRequests = Object.create(null);
-    let connectAttempt = 0;
-    let connectTimer = undefined;
-    let connectionIndex = 0;
-    let lazyDisconnectTimer = undefined;
-    let activeConnection = lazyOpts.enabled ? null : createConnection();
-    const initState = activeConnection ? {
-        type: 'state',
-        state: 'connecting',
-        error: null
-    } : {
-        type: 'state',
-        state: 'idle',
-        error: null
-    };
-    const connectionState = behaviorSubject(initState);
-    /**
-   * tries to send the list of messages
-   */ function dispatch() {
-        if (!activeConnection) {
-            reconnect(null);
-            return;
-        }
-        // using a timeout to batch messages
-        setTimeout(()=>{
-            if (activeConnection?.state !== 'open') {
-                return;
-            }
-            for (const pending of Object.values(pendingRequests)){
-                if (!pending.connection) {
-                    pending.connection = activeConnection;
-                }
-            }
-            if (outgoing.length === 1) {
-                // single send
-                activeConnection.ws.send(JSON.stringify(outgoing.pop()));
-            } else {
-                // batch send
-                activeConnection.ws.send(JSON.stringify(outgoing));
-            }
-            // clear
-            outgoing = [];
-            startLazyDisconnectTimer();
-        });
-    }
-    function tryReconnect(cause) {
-        if (!!connectTimer) {
-            return;
-        }
-        const timeout = retryDelayFn(connectAttempt++);
-        reconnectInMs(timeout, cause);
-    }
-    function hasPendingRequests(conn) {
-        const requests = Object.values(pendingRequests);
-        if (!conn) {
-            return requests.length > 0;
-        }
-        return requests.some((req)=>req.connection === conn);
-    }
-    function reconnect(cause) {
-        if (lazyOpts.enabled && !hasPendingRequests()) {
-            // Skip reconnecting if there aren't pending requests and we're in lazy mode
-            return;
-        }
-        const oldConnection = activeConnection;
-        activeConnection = createConnection();
-        if (oldConnection) {
-            closeIfNoPending(oldConnection);
-        }
-        const currentState = connectionState.get();
-        if (currentState.state !== 'connecting') {
-            connectionState.next({
-                type: 'state',
-                state: 'connecting',
-                error: cause ? TRPCClientError.from(cause) : null
-            });
-        }
-    }
-    function reconnectInMs(ms, cause) {
-        if (connectTimer) {
-            return;
-        }
-        connectTimer = setTimeout(()=>{
-            reconnect(cause);
-        }, ms);
-    }
-    function closeIfNoPending(conn) {
-        // disconnect as soon as there are are no pending requests
-        if (!hasPendingRequests(conn)) {
-            conn.ws?.close();
-        }
-    }
-    function resumeSubscriptionOnReconnect(req) {
-        if (outgoing.some((r)=>r.id === req.op.id)) {
-            return;
-        }
-        request({
-            op: req.op,
-            callbacks: req.callbacks,
-            lastEventId: req.lastEventId
-        });
-    }
-    const startLazyDisconnectTimer = ()=>{
-        if (!lazyOpts.enabled) {
-            return;
-        }
-        clearTimeout(lazyDisconnectTimer);
-        lazyDisconnectTimer = setTimeout(()=>{
-            if (!activeConnection) {
-                return;
-            }
-            if (!hasPendingRequests()) {
-                activeConnection.ws?.close();
-                activeConnection = null;
-                connectionState.next({
-                    type: 'state',
-                    state: 'idle',
-                    error: null
-                });
-            }
-        }, lazyOpts.closeMs);
-    };
-    function createConnection() {
-        let pingTimeout = undefined;
-        let pongTimeout = undefined;
-        const self = {
-            id: ++connectionIndex,
-            state: 'connecting'
-        };
-        clearTimeout(lazyDisconnectTimer);
-        function destroy() {
-            const noop = ()=>{
-            // no-op
-            };
-            const { ws } = self;
-            if (ws) {
-                ws.onclose = noop;
-                ws.onerror = noop;
-                ws.onmessage = noop;
-                ws.onopen = noop;
-                ws.close();
-            }
-            self.state = 'closed';
-        }
-        const onCloseOrError = (cause)=>{
-            clearTimeout(pingTimeout);
-            clearTimeout(pongTimeout);
-            self.state = 'closed';
-            if (activeConnection === self) {
-                // connection might have been replaced already
-                tryReconnect(cause);
-            }
-            for (const [key, req] of Object.entries(pendingRequests)){
-                if (req.connection !== self) {
-                    continue;
-                }
-                // The connection was closed either unexpectedly or because of a reconnect
-                if (req.type === 'subscription') {
-                    // Subscriptions will resume after we've reconnected
-                    resumeSubscriptionOnReconnect(req);
-                } else {
-                    // Queries and mutations will error if interrupted
-                    delete pendingRequests[key];
-                    req.callbacks.error?.(TRPCClientError.from(cause ?? new TRPCWebSocketClosedError()));
-                }
-            }
-        };
-        const onError = (evt)=>{
-            onCloseOrError(new TRPCWebSocketClosedError({
-                cause: evt
-            }));
-            opts.onError?.(evt);
-        };
-        function connect(url) {
-            if (opts.connectionParams) {
-                // append `?connectionParams=1` when connection params are used
-                const prefix = url.includes('?') ? '&' : '?';
-                url += prefix + 'connectionParams=1';
-            }
-            const ws = new WebSocketImpl(url);
-            self.ws = ws;
-            clearTimeout(connectTimer);
-            connectTimer = undefined;
-            ws.onopen = ()=>{
-                async function sendConnectionParams() {
-                    if (!opts.connectionParams) {
-                        return;
-                    }
-                    const connectMsg = {
-                        method: 'connectionParams',
-                        data: await resultOf(opts.connectionParams)
-                    };
-                    ws.send(JSON.stringify(connectMsg));
-                }
-                function handleKeepAlive() {
-                    if (!opts.keepAlive?.enabled) {
-                        return;
-                    }
-                    const { pongTimeoutMs = 1000, intervalMs = 5000 } = opts.keepAlive;
-                    const schedulePing = ()=>{
-                        const schedulePongTimeout = ()=>{
-                            pongTimeout = setTimeout(()=>{
-                                const wasOpen = self.state === 'open';
-                                destroy();
-                                if (wasOpen) {
-                                    opts.onClose?.();
-                                }
-                            }, pongTimeoutMs);
-                        };
-                        pingTimeout = setTimeout(()=>{
-                            ws.send('PING');
-                            schedulePongTimeout();
-                        }, intervalMs);
-                    };
-                    ws.addEventListener('message', ()=>{
-                        clearTimeout(pingTimeout);
-                        clearTimeout(pongTimeout);
-                        schedulePing();
-                    });
-                    schedulePing();
-                }
-                run(async ()=>{
-                    /* istanbul ignore next -- @preserve */ if (activeConnection?.ws !== ws) {
-                        return;
-                    }
-                    handleKeepAlive();
-                    await sendConnectionParams();
-                    connectAttempt = 0;
-                    self.state = 'open';
-                    // Update connection state
-                    connectionState.next({
-                        type: 'state',
-                        state: 'pending',
-                        error: null
-                    });
-                    opts.onOpen?.();
-                    dispatch();
-                }).catch((cause)=>{
-                    ws.close(// "Status codes in the range 3000-3999 are reserved for use by libraries, frameworks, and applications"
-                    3000);
-                    onCloseOrError(new TRPCWebSocketClosedError({
-                        message: 'Initialization error',
-                        cause
-                    }));
-                });
-            };
-            ws.onerror = onError;
-            const handleIncomingRequest = (req)=>{
-                if (self !== activeConnection) {
-                    return;
-                }
-                if (req.method === 'reconnect') {
-                    reconnect(new TRPCWebSocketClosedError({
-                        message: 'Server requested reconnect'
-                    }));
-                    // notify subscribers
-                    for (const pendingReq of Object.values(pendingRequests)){
-                        if (pendingReq.type === 'subscription') {
-                            resumeSubscriptionOnReconnect(pendingReq);
-                        }
-                    }
-                }
-            };
-            const handleIncomingResponse = (data)=>{
-                const req = data.id !== null && pendingRequests[data.id];
-                if (!req) {
-                    // do something?
-                    return;
-                }
-                req.callbacks.next?.(data);
-                if (self === activeConnection && req.connection !== activeConnection) {
-                    // gracefully replace old connection with a new connection
-                    req.connection = self;
-                }
-                if (req.connection !== self) {
-                    // the connection has been replaced
-                    return;
-                }
-                if ('result' in data && data.result.type === 'data' && typeof data.result.id === 'string') {
-                    req.lastEventId = data.result.id;
-                }
-                if ('result' in data && data.result.type === 'stopped' && activeConnection === self) {
-                    req.callbacks.complete();
-                }
-            };
-            ws.onmessage = (event)=>{
-                const { data } = event;
-                if (data === 'PONG') {
-                    return;
-                }
-                if (data === 'PING') {
-                    ws.send('PONG');
-                    return;
-                }
-                startLazyDisconnectTimer();
-                const msg = JSON.parse(data);
-                if ('method' in msg) {
-                    handleIncomingRequest(msg);
-                } else {
-                    handleIncomingResponse(msg);
-                }
-                if (self !== activeConnection) {
-                    // when receiving a message, we close old connection that has no pending requests
-                    closeIfNoPending(self);
-                }
-            };
-            ws.onclose = (event)=>{
-                const wasOpen = self.state === 'open';
-                destroy();
-                onCloseOrError(new TRPCWebSocketClosedError({
-                    cause: event
-                }));
-                if (wasOpen) {
-                    opts.onClose?.(event);
-                }
-            };
-        }
-        Promise.resolve(resultOf(opts.url)).then(connect).catch(()=>{
-            onCloseOrError(new Error('Failed to resolve url'));
-        });
-        return self;
-    }
-    function request(opts) {
-        const { op, callbacks, lastEventId } = opts;
-        const { type, input, path, id } = op;
-        const envelope = {
-            id,
-            method: type,
-            params: {
-                input,
-                path,
-                lastEventId
-            }
-        };
-        pendingRequests[id] = {
-            connection: null,
-            type,
-            callbacks,
-            op,
-            lastEventId
-        };
-        // enqueue message
-        outgoing.push(envelope);
-        dispatch();
-        return ()=>{
-            const callbacks = pendingRequests[id]?.callbacks;
-            delete pendingRequests[id];
-            outgoing = outgoing.filter((msg)=>msg.id !== id);
-            callbacks?.complete?.();
-            if (activeConnection?.state === 'open' && op.type === 'subscription') {
-                outgoing.push({
-                    id,
-                    method: 'subscription.stop'
-                });
-                dispatch();
-            }
-            startLazyDisconnectTimer();
-        };
-    }
-    return {
-        close: ()=>{
-            connectAttempt = 0;
-            for (const req of Object.values(pendingRequests)){
-                if (req.type === 'subscription') {
-                    req.callbacks.complete();
-                } else if (!req.connection) {
-                    // close pending requests that aren't attached to a connection yet
-                    req.callbacks.error(TRPCClientError.from(new TRPCWebSocketClosedError({
-                        message: 'Closed before connection was established'
-                    })));
-                }
-            }
-            if (activeConnection) {
-                closeIfNoPending(activeConnection);
-            }
-            clearTimeout(connectTimer);
-            connectTimer = undefined;
-            activeConnection = null;
-        },
-        request,
-        get connection () {
-            return activeConnection;
-        },
-        /**
-     * Reconnect to the WebSocket server
-     */ reconnect,
-        connectionState: connectionState
-    };
-}
-class TRPCWebSocketClosedError extends Error {
-    constructor(opts){
-        super(opts?.message ?? 'WebSocket closed', // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore https://github.com/tc39/proposal-error-cause
-        {
-            cause: opts?.cause
-        });
-        this.name = 'TRPCWebSocketClosedError';
-        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
-    }
-}
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */ function wsLink(opts) {
-    const transformer = getTransformer(opts.transformer);
-    return ()=>{
-        const { client } = opts;
-        return ({ op })=>{
-            return observable((observer)=>{
-                const { type, path, id, context } = op;
-                const input = transformer.input.serialize(op.input);
-                const connState = type === 'subscription' ? client.connectionState.subscribe({
-                    next (result) {
-                        observer.next({
-                            result,
-                            context
-                        });
-                    }
-                }) : null;
-                const unsubscribeRequest = client.request({
-                    op: {
-                        type,
-                        path,
-                        input,
-                        id,
-                        context,
-                        signal: null
-                    },
-                    callbacks: {
-                        error (err) {
-                            observer.error(err);
-                            unsubscribeRequest();
-                        },
-                        complete () {
-                            observer.complete();
-                        },
-                        next (event) {
-                            const transformed = transformResult(event, transformer.output);
-                            if (!transformed.ok) {
-                                observer.error(TRPCClientError.from(transformed.error));
-                                return;
-                            }
-                            observer.next({
-                                result: transformed.result
-                            });
-                            if (op.type !== 'subscription') {
-                                // if it isn't a subscription we don't care about next response
-                                unsubscribeRequest();
-                                observer.complete();
-                            }
-                        }
-                    },
-                    lastEventId: undefined
-                });
-                return ()=>{
-                    unsubscribeRequest();
-                    connState?.unsubscribe();
-                };
-            });
-        };
-    };
-}
-
-export { createWSClient, wsLink };

package/links/wsLink/index.d.ts

@@ -1 +0,0 @@
-export * from '../../dist/links/wsLink';

package/links/wsLink/index.js

@@ -1 +0,0 @@
-module.exports = require('../../dist/links/wsLink');