@trpc/client 10.43.0 → 11.0.0-next.91

package/dist/links/wsLink.js

@@ -8,6 +8,7 @@ var TRPCClientError = require('../TRPCClientError-e224e397.js');
 
 /* istanbul ignore next -- @preserve */ const retryDelay = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
 
+const run = (fn)=>fn();
 function createWSClient(opts) {
     const { url , WebSocket: WebSocketImpl = WebSocket , retryDelayMs: retryDelayFn = retryDelay , onOpen , onClose ,  } = opts;
     /* istanbul ignore next -- @preserve */ if (!WebSocketImpl) {
@@ -18,163 +19,171 @@ function createWSClient(opts) {
    */ let outgoing = [];
     const pendingRequests = Object.create(null);
     let connectAttempt = 0;
-    let dispatchTimer = null;
-    let connectTimer = null;
-    let activeConnection = createWS();
-    let state = 'connecting';
+    let connectTimer = undefined;
+    let connectionIndex = 0;
+    let activeConnection = createConnection();
+    /**
+   * Global connection has been killed
+   */ let killed = false;
     /**
    * tries to send the list of messages
    */ function dispatch() {
-        if (state !== 'open' || dispatchTimer) {
-            return;
-        }
-        dispatchTimer = setTimeout(()=>{
-            dispatchTimer = null;
+        // 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.send(JSON.stringify(outgoing.pop()));
+                activeConnection.ws.send(JSON.stringify(outgoing.pop()));
             } else {
                 // batch send
-                activeConnection.send(JSON.stringify(outgoing));
+                activeConnection.ws.send(JSON.stringify(outgoing));
             }
             // clear
             outgoing = [];
         });
     }
     function tryReconnect() {
-        if (connectTimer !== null || state === 'closed') {
+        if (!!connectTimer || killed) {
             return;
         }
         const timeout = retryDelayFn(connectAttempt++);
         reconnectInMs(timeout);
     }
     function reconnect() {
-        state = 'connecting';
         const oldConnection = activeConnection;
-        activeConnection = createWS();
-        closeIfNoPending(oldConnection);
+        activeConnection = createConnection();
+        oldConnection && closeIfNoPending(oldConnection);
     }
     function reconnectInMs(ms) {
         if (connectTimer) {
             return;
         }
-        state = 'connecting';
         connectTimer = setTimeout(reconnect, ms);
     }
     function closeIfNoPending(conn) {
         // disconnect as soon as there are are no pending result
-        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.ws === conn);
+        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.connection === conn);
         if (!hasPendingRequests) {
-            conn.close();
+            conn.ws?.close();
         }
     }
-    function closeActiveSubscriptions() {
-        Object.values(pendingRequests).forEach((req)=>{
-            if (req.type === 'subscription') {
-                req.callbacks.complete();
-            }
-        });
-    }
     function resumeSubscriptionOnReconnect(req) {
         if (outgoing.some((r)=>r.id === req.op.id)) {
             return;
         }
         request(req.op, req.callbacks);
     }
-    function createWS() {
-        const urlString = typeof url === 'function' ? url() : url;
-        const conn = new WebSocketImpl(urlString);
-        clearTimeout(connectTimer);
-        connectTimer = null;
-        conn.addEventListener('open', ()=>{
-            /* istanbul ignore next -- @preserve */ if (conn !== activeConnection) {
-                return;
-            }
-            connectAttempt = 0;
-            state = 'open';
-            onOpen?.();
-            dispatch();
-        });
-        conn.addEventListener('error', ()=>{
-            if (conn === activeConnection) {
+    function createConnection() {
+        const self = {
+            id: ++connectionIndex,
+            state: 'connecting'
+        };
+        const onError = ()=>{
+            self.state = 'closed';
+            if (self === activeConnection) {
                 tryReconnect();
             }
-        });
-        const handleIncomingRequest = (req)=>{
-            if (req.method === 'reconnect' && conn === activeConnection) {
-                if (state === 'open') {
-                    onClose?.();
+        };
+        run(async ()=>{
+            const urlString = typeof url === 'function' ? await url() : url;
+            const ws = new WebSocketImpl(urlString);
+            self.ws = ws;
+            clearTimeout(connectTimer);
+            connectTimer = undefined;
+            ws.addEventListener('open', ()=>{
+                /* istanbul ignore next -- @preserve */ if (activeConnection?.ws !== ws) {
+                    return;
+                }
+                connectAttempt = 0;
+                self.state = 'open';
+                onOpen?.();
+                dispatch();
+            });
+            ws.addEventListener('error', onError);
+            const handleIncomingRequest = (req)=>{
+                if (self !== activeConnection) {
+                    return;
                 }
-                reconnect();
-                // notify subscribers
-                for (const pendingReq of Object.values(pendingRequests)){
-                    if (pendingReq.type === 'subscription') {
-                        resumeSubscriptionOnReconnect(pendingReq);
+                if (req.method === 'reconnect') {
+                    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 (req.ws !== activeConnection && conn === activeConnection) {
-                const oldWs = req.ws;
-                // gracefully replace old connection with this
-                req.ws = activeConnection;
-                closeIfNoPending(oldWs);
-            }
-            if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
-                req.callbacks.complete();
-            }
-        };
-        conn.addEventListener('message', ({ data  })=>{
-            const msg = JSON.parse(data);
-            if ('method' in msg) {
-                handleIncomingRequest(msg);
-            } else {
-                handleIncomingResponse(msg);
-            }
-            if (conn !== activeConnection || state === 'closed') {
-                // when receiving a message, we close old connection that has no pending requests
-                closeIfNoPending(conn);
-            }
-        });
-        conn.addEventListener('close', ({ code  })=>{
-            if (state === 'open') {
-                onClose?.({
-                    code
-                });
-            }
-            if (activeConnection === conn) {
-                // connection might have been replaced already
-                tryReconnect();
-            }
-            for (const [key, req] of Object.entries(pendingRequests)){
-                if (req.ws !== conn) {
-                    continue;
+            };
+            const handleIncomingResponse = (data)=>{
+                const req = data.id !== null && pendingRequests[data.id];
+                if (!req) {
+                    // do something?
+                    return;
                 }
-                if (state === 'closed') {
-                    // If the connection was closed, we just call `complete()` on the request
-                    delete pendingRequests[key];
-                    req.callbacks.complete?.();
-                    continue;
+                req.callbacks.next?.(data);
+                if (self === activeConnection && req.connection !== activeConnection) {
+                    // gracefully replace old connection with this
+                    const oldConn = req.connection;
+                    req.connection = self;
+                    oldConn && closeIfNoPending(oldConn);
                 }
-                // The connection was closed either unexpectedly or because of a reconnect
-                if (req.type === 'subscription') {
-                    // Subscriptions will resume after we've reconnected
-                    resumeSubscriptionOnReconnect(req);
+                if ('result' in data && data.result.type === 'stopped' && activeConnection === self) {
+                    req.callbacks.complete();
+                }
+            };
+            ws.addEventListener('message', ({ data  })=>{
+                const msg = JSON.parse(data);
+                if ('method' in msg) {
+                    handleIncomingRequest(msg);
                 } else {
-                    // Queries and mutations will error if interrupted
-                    delete pendingRequests[key];
-                    req.callbacks.error?.(TRPCClientError.TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                    handleIncomingResponse(msg);
                 }
-            }
-        });
-        return conn;
+                if (self !== activeConnection) {
+                    // when receiving a message, we close old connection that has no pending requests
+                    closeIfNoPending(self);
+                }
+            });
+            ws.addEventListener('close', ({ code  })=>{
+                if (self.state === 'open') {
+                    onClose?.({
+                        code
+                    });
+                }
+                self.state = 'closed';
+                if (activeConnection === self) {
+                    // connection might have been replaced already
+                    tryReconnect();
+                }
+                for (const [key, req] of Object.entries(pendingRequests)){
+                    if (req.connection !== self) {
+                        continue;
+                    }
+                    if (self.state === 'closed') {
+                        // If the connection was closed, we just call `complete()` on the request
+                        delete pendingRequests[key];
+                        req.callbacks.complete?.();
+                        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.TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                    }
+                }
+            });
+        }).catch(onError);
+        return self;
     }
     function request(op, callbacks) {
         const { type , input , path , id  } = op;
@@ -187,7 +196,7 @@ function createWSClient(opts) {
             }
         };
         pendingRequests[id] = {
-            ws: activeConnection,
+            connection: null,
             type,
             callbacks,
             op
@@ -200,7 +209,7 @@ function createWSClient(opts) {
             delete pendingRequests[id];
             outgoing = outgoing.filter((msg)=>msg.id !== id);
             callbacks?.complete?.();
-            if (activeConnection.readyState === WebSocketImpl.OPEN && op.type === 'subscription') {
+            if (activeConnection?.state === 'open' && op.type === 'subscription') {
                 outgoing.push({
                     id,
                     method: 'subscription.stop'
@@ -211,12 +220,18 @@ function createWSClient(opts) {
     }
     return {
         close: ()=>{
-            state = 'closed';
-            onClose?.();
-            closeActiveSubscriptions();
-            closeIfNoPending(activeConnection);
+            killed = true;
+            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.TRPCClientError.from(new Error('Closed before connection was established')));
+                }
+            }
+            activeConnection && closeIfNoPending(activeConnection);
             clearTimeout(connectTimer);
-            connectTimer = null;
+            connectTimer = undefined;
         },
         request,
         getConnection () {

package/dist/links/wsLink.mjs

@@ -4,6 +4,7 @@ import { T as TRPCClientError } from '../TRPCClientError-0de4d231.mjs';
 
 /* istanbul ignore next -- @preserve */ const retryDelay = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
 
+const run = (fn)=>fn();
 function createWSClient(opts) {
     const { url , WebSocket: WebSocketImpl = WebSocket , retryDelayMs: retryDelayFn = retryDelay , onOpen , onClose ,  } = opts;
     /* istanbul ignore next -- @preserve */ if (!WebSocketImpl) {
@@ -14,163 +15,171 @@ function createWSClient(opts) {
    */ let outgoing = [];
     const pendingRequests = Object.create(null);
     let connectAttempt = 0;
-    let dispatchTimer = null;
-    let connectTimer = null;
-    let activeConnection = createWS();
-    let state = 'connecting';
+    let connectTimer = undefined;
+    let connectionIndex = 0;
+    let activeConnection = createConnection();
+    /**
+   * Global connection has been killed
+   */ let killed = false;
     /**
    * tries to send the list of messages
    */ function dispatch() {
-        if (state !== 'open' || dispatchTimer) {
-            return;
-        }
-        dispatchTimer = setTimeout(()=>{
-            dispatchTimer = null;
+        // 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.send(JSON.stringify(outgoing.pop()));
+                activeConnection.ws.send(JSON.stringify(outgoing.pop()));
             } else {
                 // batch send
-                activeConnection.send(JSON.stringify(outgoing));
+                activeConnection.ws.send(JSON.stringify(outgoing));
             }
             // clear
             outgoing = [];
         });
     }
     function tryReconnect() {
-        if (connectTimer !== null || state === 'closed') {
+        if (!!connectTimer || killed) {
             return;
         }
         const timeout = retryDelayFn(connectAttempt++);
         reconnectInMs(timeout);
     }
     function reconnect() {
-        state = 'connecting';
         const oldConnection = activeConnection;
-        activeConnection = createWS();
-        closeIfNoPending(oldConnection);
+        activeConnection = createConnection();
+        oldConnection && closeIfNoPending(oldConnection);
     }
     function reconnectInMs(ms) {
         if (connectTimer) {
             return;
         }
-        state = 'connecting';
         connectTimer = setTimeout(reconnect, ms);
     }
     function closeIfNoPending(conn) {
         // disconnect as soon as there are are no pending result
-        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.ws === conn);
+        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.connection === conn);
         if (!hasPendingRequests) {
-            conn.close();
+            conn.ws?.close();
         }
     }
-    function closeActiveSubscriptions() {
-        Object.values(pendingRequests).forEach((req)=>{
-            if (req.type === 'subscription') {
-                req.callbacks.complete();
-            }
-        });
-    }
     function resumeSubscriptionOnReconnect(req) {
         if (outgoing.some((r)=>r.id === req.op.id)) {
             return;
         }
         request(req.op, req.callbacks);
     }
-    function createWS() {
-        const urlString = typeof url === 'function' ? url() : url;
-        const conn = new WebSocketImpl(urlString);
-        clearTimeout(connectTimer);
-        connectTimer = null;
-        conn.addEventListener('open', ()=>{
-            /* istanbul ignore next -- @preserve */ if (conn !== activeConnection) {
-                return;
-            }
-            connectAttempt = 0;
-            state = 'open';
-            onOpen?.();
-            dispatch();
-        });
-        conn.addEventListener('error', ()=>{
-            if (conn === activeConnection) {
+    function createConnection() {
+        const self = {
+            id: ++connectionIndex,
+            state: 'connecting'
+        };
+        const onError = ()=>{
+            self.state = 'closed';
+            if (self === activeConnection) {
                 tryReconnect();
             }
-        });
-        const handleIncomingRequest = (req)=>{
-            if (req.method === 'reconnect' && conn === activeConnection) {
-                if (state === 'open') {
-                    onClose?.();
+        };
+        run(async ()=>{
+            const urlString = typeof url === 'function' ? await url() : url;
+            const ws = new WebSocketImpl(urlString);
+            self.ws = ws;
+            clearTimeout(connectTimer);
+            connectTimer = undefined;
+            ws.addEventListener('open', ()=>{
+                /* istanbul ignore next -- @preserve */ if (activeConnection?.ws !== ws) {
+                    return;
+                }
+                connectAttempt = 0;
+                self.state = 'open';
+                onOpen?.();
+                dispatch();
+            });
+            ws.addEventListener('error', onError);
+            const handleIncomingRequest = (req)=>{
+                if (self !== activeConnection) {
+                    return;
                 }
-                reconnect();
-                // notify subscribers
-                for (const pendingReq of Object.values(pendingRequests)){
-                    if (pendingReq.type === 'subscription') {
-                        resumeSubscriptionOnReconnect(pendingReq);
+                if (req.method === 'reconnect') {
+                    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 (req.ws !== activeConnection && conn === activeConnection) {
-                const oldWs = req.ws;
-                // gracefully replace old connection with this
-                req.ws = activeConnection;
-                closeIfNoPending(oldWs);
-            }
-            if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
-                req.callbacks.complete();
-            }
-        };
-        conn.addEventListener('message', ({ data  })=>{
-            const msg = JSON.parse(data);
-            if ('method' in msg) {
-                handleIncomingRequest(msg);
-            } else {
-                handleIncomingResponse(msg);
-            }
-            if (conn !== activeConnection || state === 'closed') {
-                // when receiving a message, we close old connection that has no pending requests
-                closeIfNoPending(conn);
-            }
-        });
-        conn.addEventListener('close', ({ code  })=>{
-            if (state === 'open') {
-                onClose?.({
-                    code
-                });
-            }
-            if (activeConnection === conn) {
-                // connection might have been replaced already
-                tryReconnect();
-            }
-            for (const [key, req] of Object.entries(pendingRequests)){
-                if (req.ws !== conn) {
-                    continue;
+            };
+            const handleIncomingResponse = (data)=>{
+                const req = data.id !== null && pendingRequests[data.id];
+                if (!req) {
+                    // do something?
+                    return;
                 }
-                if (state === 'closed') {
-                    // If the connection was closed, we just call `complete()` on the request
-                    delete pendingRequests[key];
-                    req.callbacks.complete?.();
-                    continue;
+                req.callbacks.next?.(data);
+                if (self === activeConnection && req.connection !== activeConnection) {
+                    // gracefully replace old connection with this
+                    const oldConn = req.connection;
+                    req.connection = self;
+                    oldConn && closeIfNoPending(oldConn);
                 }
-                // The connection was closed either unexpectedly or because of a reconnect
-                if (req.type === 'subscription') {
-                    // Subscriptions will resume after we've reconnected
-                    resumeSubscriptionOnReconnect(req);
+                if ('result' in data && data.result.type === 'stopped' && activeConnection === self) {
+                    req.callbacks.complete();
+                }
+            };
+            ws.addEventListener('message', ({ data  })=>{
+                const msg = JSON.parse(data);
+                if ('method' in msg) {
+                    handleIncomingRequest(msg);
                 } else {
-                    // Queries and mutations will error if interrupted
-                    delete pendingRequests[key];
-                    req.callbacks.error?.(TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                    handleIncomingResponse(msg);
                 }
-            }
-        });
-        return conn;
+                if (self !== activeConnection) {
+                    // when receiving a message, we close old connection that has no pending requests
+                    closeIfNoPending(self);
+                }
+            });
+            ws.addEventListener('close', ({ code  })=>{
+                if (self.state === 'open') {
+                    onClose?.({
+                        code
+                    });
+                }
+                self.state = 'closed';
+                if (activeConnection === self) {
+                    // connection might have been replaced already
+                    tryReconnect();
+                }
+                for (const [key, req] of Object.entries(pendingRequests)){
+                    if (req.connection !== self) {
+                        continue;
+                    }
+                    if (self.state === 'closed') {
+                        // If the connection was closed, we just call `complete()` on the request
+                        delete pendingRequests[key];
+                        req.callbacks.complete?.();
+                        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(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                    }
+                }
+            });
+        }).catch(onError);
+        return self;
     }
     function request(op, callbacks) {
         const { type , input , path , id  } = op;
@@ -183,7 +192,7 @@ function createWSClient(opts) {
             }
         };
         pendingRequests[id] = {
-            ws: activeConnection,
+            connection: null,
             type,
             callbacks,
             op
@@ -196,7 +205,7 @@ function createWSClient(opts) {
             delete pendingRequests[id];
             outgoing = outgoing.filter((msg)=>msg.id !== id);
             callbacks?.complete?.();
-            if (activeConnection.readyState === WebSocketImpl.OPEN && op.type === 'subscription') {
+            if (activeConnection?.state === 'open' && op.type === 'subscription') {
                 outgoing.push({
                     id,
                     method: 'subscription.stop'
@@ -207,12 +216,18 @@ function createWSClient(opts) {
     }
     return {
         close: ()=>{
-            state = 'closed';
-            onClose?.();
-            closeActiveSubscriptions();
-            closeIfNoPending(activeConnection);
+            killed = true;
+            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 Error('Closed before connection was established')));
+                }
+            }
+            activeConnection && closeIfNoPending(activeConnection);
             clearTimeout(connectTimer);
-            connectTimer = null;
+            connectTimer = undefined;
         },
         request,
         getConnection () {