@trpc/client 10.43.0 → 11.0.0-next.91

package/src/links/wsLink.ts

@@ -1,4 +1,9 @@
-import { AnyRouter, inferRouterError, ProcedureType } from '@trpc/server';
+import {
+  AnyRouter,
+  inferRouterError,
+  MaybePromise,
+  ProcedureType,
+} from '@trpc/server';
 import { observable, Observer, UnsubscribeFn } from '@trpc/server/observable';
 import {
   TRPCClientIncomingMessage,
@@ -12,6 +17,8 @@ import { transformResult } from '../shared/transformResult';
 import { TRPCClientError } from '../TRPCClientError';
 import { Operation, TRPCLink } from './types';
 
+const run = <TResult>(fn: () => TResult): TResult => fn();
+
 type WSCallbackResult<TRouter extends AnyRouter, TOutput> = TRPCResponseMessage<
   TOutput,
   inferRouterError<TRouter>
@@ -22,13 +29,13 @@ type WSCallbackObserver<TRouter extends AnyRouter, TOutput> = Observer<
   TRPCClientError<TRouter>
 >;
 
-export interface WebSocketClientOptions {
-  url: string | (() => string);
+export type WebSocketClientOptions = {
+  url: string | (() => MaybePromise<string>);
   WebSocket?: typeof WebSocket;
   retryDelayMs?: typeof retryDelay;
   onOpen?: () => void;
   onClose?: (cause?: { code?: number }) => void;
-}
+};
 
 export function createWSClient(opts: WebSocketClientOptions) {
   const {
@@ -56,7 +63,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
     /**
      * Reference to the WebSocket instance this request was made to
      */
-    ws: WebSocket;
+    connection: Connection | null;
     type: ProcedureType;
     callbacks: TCallbacks;
     op: Operation;
@@ -64,70 +71,84 @@ export function createWSClient(opts: WebSocketClientOptions) {
   const pendingRequests: Record<number | string, TRequest> =
     Object.create(null);
   let connectAttempt = 0;
-  let dispatchTimer: NodeJS.Timer | number | null = null;
-  let connectTimer: NodeJS.Timer | number | null = null;
-  let activeConnection = createWS();
-  let state: 'closed' | 'connecting' | 'open' = 'connecting';
+  let connectTimer: ReturnType<typeof setTimeout> | undefined = undefined;
+  let connectionIndex = 0;
+  let activeConnection: null | Connection = createConnection();
+  /**
+   * Global connection has been killed
+   */
+  let killed = false;
+
+  type Connection = {
+    id: number;
+  } & (
+    | {
+        state: 'open';
+        ws: WebSocket;
+      }
+    | {
+        state: 'closed';
+        ws: WebSocket;
+      }
+    | {
+        state: 'connecting';
+        ws?: WebSocket;
+      }
+  );
+
   /**
    * 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: number) {
     if (connectTimer) {
       return;
     }
-    state = 'connecting';
     connectTimer = setTimeout(reconnect, ms);
   }
 
-  function closeIfNoPending(conn: WebSocket) {
+  function closeIfNoPending(conn: Connection) {
     // disconnect as soon as there are are no pending result
     const hasPendingRequests = Object.values(pendingRequests).some(
-      (p) => p.ws === conn,
+      (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: TRequest) {
     if (outgoing.some((r) => r.id === req.op.id)) {
       return;
@@ -135,115 +156,128 @@ export function createWSClient(opts: WebSocketClientOptions) {
     request(req.op, req.callbacks);
   }
 
-  function createWS() {
-    const urlString = typeof url === 'function' ? url() : url;
-    const conn = new WebSocketImpl(urlString);
-    clearTimeout(connectTimer as any);
-    connectTimer = null;
+  function createConnection(): Connection {
+    const self: Connection = {
+      id: ++connectionIndex,
+      state: 'connecting',
+    } as Connection;
 
-    conn.addEventListener('open', () => {
-      /* istanbul ignore next -- @preserve */
-      if (conn !== activeConnection) {
-        return;
-      }
-      connectAttempt = 0;
-      state = 'open';
-      onOpen?.();
-      dispatch();
-    });
-    conn.addEventListener('error', () => {
-      if (conn === activeConnection) {
+    const onError = () => {
+      self.state = 'closed';
+      if (self === activeConnection) {
         tryReconnect();
       }
-    });
-    const handleIncomingRequest = (req: TRPCClientIncomingRequest) => {
-      if (req.method === 'reconnect' && conn === activeConnection) {
-        if (state === 'open') {
-          onClose?.();
-        }
-        reconnect();
-        // notify subscribers
-        for (const pendingReq of Object.values(pendingRequests)) {
-          if (pendingReq.type === 'subscription') {
-            resumeSubscriptionOnReconnect(pendingReq);
-          }
-        }
-      }
     };
-    const handleIncomingResponse = (data: TRPCResponseMessage) => {
-      const req = data.id !== null && pendingRequests[data.id];
-      if (!req) {
-        // do something?
-        return;
-      }
+    run(async () => {
+      const urlString = typeof url === 'function' ? await url() : url;
+      const ws = new WebSocketImpl(urlString);
+      self.ws = ws;
 
-      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);
-      }
+      clearTimeout(connectTimer);
+      connectTimer = undefined;
 
-      if (
-        'result' in data &&
-        data.result.type === 'stopped' &&
-        conn === activeConnection
-      ) {
-        req.callbacks.complete();
-      }
-    };
-    conn.addEventListener('message', ({ data }) => {
-      const msg = JSON.parse(data) as TRPCClientIncomingMessage;
+      ws.addEventListener('open', () => {
+        /* istanbul ignore next -- @preserve */
+        if (activeConnection?.ws !== ws) {
+          return;
+        }
+        connectAttempt = 0;
+        self.state = 'open';
 
-      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);
-      }
-    });
+        onOpen?.();
+        dispatch();
+      });
+      ws.addEventListener('error', onError);
+      const handleIncomingRequest = (req: TRPCClientIncomingRequest) => {
+        if (self !== activeConnection) {
+          return;
+        }
+        if (req.method === 'reconnect') {
+          reconnect();
+          // notify subscribers
+          for (const pendingReq of Object.values(pendingRequests)) {
+            if (pendingReq.type === 'subscription') {
+              resumeSubscriptionOnReconnect(pendingReq);
+            }
+          }
+        }
+      };
+      const handleIncomingResponse = (data: TRPCResponseMessage) => {
+        const req = data.id !== null && pendingRequests[data.id];
+        if (!req) {
+          // do something?
+          return;
+        }
 
-    conn.addEventListener('close', ({ code }) => {
-      if (state === 'open') {
-        onClose?.({ code });
-      }
+        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);
+        }
 
-      if (activeConnection === conn) {
-        // connection might have been replaced already
-        tryReconnect();
-      }
+        if (
+          'result' in data &&
+          data.result.type === 'stopped' &&
+          activeConnection === self
+        ) {
+          req.callbacks.complete();
+        }
+      };
+      ws.addEventListener('message', ({ data }) => {
+        const msg = JSON.parse(data) as TRPCClientIncomingMessage;
 
-      for (const [key, req] of Object.entries(pendingRequests)) {
-        if (req.ws !== conn) {
-          continue;
+        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);
+        }
+      });
 
-        if (state === 'closed') {
-          // If the connection was closed, we just call `complete()` on the request
-          delete pendingRequests[key];
-          req.callbacks.complete?.();
-          continue;
+      ws.addEventListener('close', ({ code }) => {
+        if (self.state === 'open') {
+          onClose?.({ code });
         }
-        // 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'),
-            ),
-          );
+        self.state = 'closed';
+
+        if (activeConnection === self) {
+          // connection might have been replaced already
+          tryReconnect();
         }
-      }
-    });
-    return conn;
+
+        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: Operation, callbacks: TCallbacks): UnsubscribeFn {
@@ -257,7 +291,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
       },
     };
     pendingRequests[id] = {
-      ws: activeConnection,
+      connection: null,
       type,
       callbacks,
       op,
@@ -273,10 +307,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
       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',
@@ -287,12 +318,24 @@ export function createWSClient(opts: WebSocketClientOptions) {
   }
   return {
     close: () => {
-      state = 'closed';
-      onClose?.();
-      closeActiveSubscriptions();
-      closeIfNoPending(activeConnection);
-      clearTimeout(connectTimer as any);
-      connectTimer = null;
+      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 = undefined;
     },
     request,
     getConnection() {

package/dist/createTRPCClientProxy.d.ts

@@ -1,49 +0,0 @@
-import type { AnyMutationProcedure, AnyProcedure, AnyQueryProcedure, AnyRouter, AnySubscriptionProcedure, IntersectionError, ProcedureArgs, ProcedureRouterRecord, ProcedureType } from '@trpc/server';
-import type { Unsubscribable } from '@trpc/server/observable';
-import { inferTransformedProcedureOutput, inferTransformedSubscriptionOutput } from '@trpc/server/shared';
-import { TRPCClient } from './createTRPCClient';
-import { CreateTRPCClientOptions } from './createTRPCUntypedClient';
-import { TRPCSubscriptionObserver, TRPCUntypedClient, UntypedClientProperties } from './internals/TRPCUntypedClient';
-import { TRPCClientError } from './TRPCClientError';
-/**
- * @public
- **/
-export type inferRouterProxyClient<TRouter extends AnyRouter> = DecoratedProcedureRecord<TRouter, TRouter['_def']['record']>;
-/** @internal */
-export type Resolver<TProcedure extends AnyProcedure> = (...args: ProcedureArgs<TProcedure['_def']>) => Promise<inferTransformedProcedureOutput<TProcedure>>;
-type SubscriptionResolver<TProcedure extends AnyProcedure> = (...args: [
-    input: ProcedureArgs<TProcedure['_def']>[0],
-    opts: Partial<TRPCSubscriptionObserver<inferTransformedSubscriptionOutput<TProcedure>, TRPCClientError<TProcedure>>> & ProcedureArgs<TProcedure['_def']>[1]
-]) => Unsubscribable;
-type DecorateProcedure<TProcedure extends AnyProcedure> = TProcedure extends AnyQueryProcedure ? {
-    query: Resolver<TProcedure>;
-} : TProcedure extends AnyMutationProcedure ? {
-    mutate: Resolver<TProcedure>;
-} : TProcedure extends AnySubscriptionProcedure ? {
-    subscribe: SubscriptionResolver<TProcedure>;
-} : never;
-/**
- * @internal
- */
-type DecoratedProcedureRecord<TRouter extends AnyRouter, TProcedures extends ProcedureRouterRecord> = {
-    [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter ? DecoratedProcedureRecord<TRouter, TProcedures[TKey]['_def']['record']> : TProcedures[TKey] extends AnyProcedure ? DecorateProcedure<TProcedures[TKey]> : never;
-};
-/** @internal */
-export declare const clientCallTypeToProcedureType: (clientCallType: string) => ProcedureType;
-/**
- * Creates a proxy client and shows type errors if you have query names that collide with built-in properties
- */
-export type CreateTRPCProxyClient<TRouter extends AnyRouter> = inferRouterProxyClient<TRouter> extends infer $ProcedureRecord ? UntypedClientProperties & keyof $ProcedureRecord extends never ? inferRouterProxyClient<TRouter> : IntersectionError<UntypedClientProperties & keyof $ProcedureRecord> : never;
-/**
- * @deprecated use `createTRPCProxyClient` instead
- * @internal
- */
-export declare function createTRPCClientProxy<TRouter extends AnyRouter>(client: TRPCClient<TRouter>): CreateTRPCProxyClient<TRouter>;
-export declare function createTRPCProxyClient<TRouter extends AnyRouter>(opts: CreateTRPCClientOptions<TRouter>): CreateTRPCProxyClient<TRouter>;
-/**
- * Get an untyped client from a proxy client
- * @internal
- */
-export declare function getUntypedClient<TRouter extends AnyRouter>(client: inferRouterProxyClient<TRouter>): TRPCUntypedClient<TRouter>;
-export {};
-//# sourceMappingURL=createTRPCClientProxy.d.ts.map

package/dist/createTRPCClientProxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTRPCClientProxy.d.ts","sourceRoot":"","sources":["../src/createTRPCClientProxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,wBAAwB,EACxB,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,aAAa,EACd,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAGL,+BAA+B,EAC/B,kCAAkC,EACnC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;IAEI;AACJ,MAAM,MAAM,sBAAsB,CAAC,OAAO,SAAS,SAAS,IAC1D,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE/D,gBAAgB;AAChB,MAAM,MAAM,QAAQ,CAAC,UAAU,SAAS,YAAY,IAAI,CACtD,GAAG,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,KACvC,OAAO,CAAC,+BAA+B,CAAC,UAAU,CAAC,CAAC,CAAC;AAE1D,KAAK,oBAAoB,CAAC,UAAU,SAAS,YAAY,IAAI,CAC3D,GAAG,IAAI,EAAE;IACP,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,EAAE,OAAO,CACX,wBAAwB,CACtB,kCAAkC,CAAC,UAAU,CAAC,EAC9C,eAAe,CAAC,UAAU,CAAC,CAC5B,CACF,GACC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;CACvC,KACE,cAAc,CAAC;AAEpB,KAAK,iBAAiB,CAAC,UAAU,SAAS,YAAY,IACpD,UAAU,SAAS,iBAAiB,GAChC;IACE,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC7B,GACD,UAAU,SAAS,oBAAoB,GACvC;IACE,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC9B,GACD,UAAU,SAAS,wBAAwB,GAC3C;IACE,SAAS,EAAE,oBAAoB,CAAC,UAAU,CAAC,CAAC;CAC7C,GACD,KAAK,CAAC;AAEZ;;GAEG;AACH,KAAK,wBAAwB,CAC3B,OAAO,SAAS,SAAS,EACzB,WAAW,SAAS,qBAAqB,IACvC;KACD,IAAI,IAAI,MAAM,WAAW,GAAG,WAAW,CAAC,IAAI,CAAC,SAAS,SAAS,GAC5D,wBAAwB,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,GACtE,WAAW,CAAC,IAAI,CAAC,SAAS,YAAY,GACtC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,GACpC,KAAK;CACV,CAAC;AAQF,gBAAgB;AAChB,eAAO,MAAM,6BAA6B,mBACxB,MAAM,KACrB,aAEF,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,OAAO,SAAS,SAAS,IACzD,sBAAsB,CAAC,OAAO,CAAC,SAAS,MAAM,gBAAgB,GAC1D,uBAAuB,GAAG,MAAM,gBAAgB,SAAS,KAAK,GAC5D,sBAAsB,CAAC,OAAO,CAAC,GAC/B,iBAAiB,CAAC,uBAAuB,GAAG,MAAM,gBAAgB,CAAC,GACrE,KAAK,CAAC;AAEZ;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,SAAS,EAC7D,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAC1B,qBAAqB,CAAC,OAAO,CAAC,CAiBhC;AAED,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,SAAS,EAC7D,IAAI,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACrC,qBAAqB,CAAC,OAAO,CAAC,CAIhC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,SAAS,EACxD,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACtC,iBAAiB,CAAC,OAAO,CAAC,CAE5B"}

package/links/formDataLink/index.d.ts

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

package/links/formDataLink/index.js

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

package/links/httpTuplesonLink/index.d.ts

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

package/links/httpTuplesonLink/index.js

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

package/src/createTRPCClientProxy.ts

@@ -1,146 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import type {
-  AnyMutationProcedure,
-  AnyProcedure,
-  AnyQueryProcedure,
-  AnyRouter,
-  AnySubscriptionProcedure,
-  IntersectionError,
-  ProcedureArgs,
-  ProcedureRouterRecord,
-  ProcedureType,
-} from '@trpc/server';
-import type { Unsubscribable } from '@trpc/server/observable';
-import {
-  createFlatProxy,
-  createRecursiveProxy,
-  inferTransformedProcedureOutput,
-  inferTransformedSubscriptionOutput,
-} from '@trpc/server/shared';
-import { TRPCClient } from './createTRPCClient';
-import { CreateTRPCClientOptions } from './createTRPCUntypedClient';
-import {
-  TRPCSubscriptionObserver,
-  TRPCUntypedClient,
-  UntypedClientProperties,
-} from './internals/TRPCUntypedClient';
-import { TRPCClientError } from './TRPCClientError';
-
-/**
- * @public
- **/
-export type inferRouterProxyClient<TRouter extends AnyRouter> =
-  DecoratedProcedureRecord<TRouter, TRouter['_def']['record']>;
-
-/** @internal */
-export type Resolver<TProcedure extends AnyProcedure> = (
-  ...args: ProcedureArgs<TProcedure['_def']>
-) => Promise<inferTransformedProcedureOutput<TProcedure>>;
-
-type SubscriptionResolver<TProcedure extends AnyProcedure> = (
-  ...args: [
-    input: ProcedureArgs<TProcedure['_def']>[0],
-    opts: Partial<
-      TRPCSubscriptionObserver<
-        inferTransformedSubscriptionOutput<TProcedure>,
-        TRPCClientError<TProcedure>
-      >
-    > &
-      ProcedureArgs<TProcedure['_def']>[1],
-  ]
-) => Unsubscribable;
-
-type DecorateProcedure<TProcedure extends AnyProcedure> =
-  TProcedure extends AnyQueryProcedure
-    ? {
-        query: Resolver<TProcedure>;
-      }
-    : TProcedure extends AnyMutationProcedure
-    ? {
-        mutate: Resolver<TProcedure>;
-      }
-    : TProcedure extends AnySubscriptionProcedure
-    ? {
-        subscribe: SubscriptionResolver<TProcedure>;
-      }
-    : never;
-
-/**
- * @internal
- */
-type DecoratedProcedureRecord<
-  TRouter extends AnyRouter,
-  TProcedures extends ProcedureRouterRecord,
-> = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<TRouter, TProcedures[TKey]['_def']['record']>
-    : TProcedures[TKey] extends AnyProcedure
-    ? DecorateProcedure<TProcedures[TKey]>
-    : never;
-};
-
-const clientCallTypeMap: Record<keyof DecorateProcedure<any>, ProcedureType> = {
-  query: 'query',
-  mutate: 'mutation',
-  subscribe: 'subscription',
-};
-
-/** @internal */
-export const clientCallTypeToProcedureType = (
-  clientCallType: string,
-): ProcedureType => {
-  return clientCallTypeMap[clientCallType as keyof typeof clientCallTypeMap];
-};
-
-/**
- * Creates a proxy client and shows type errors if you have query names that collide with built-in properties
- */
-export type CreateTRPCProxyClient<TRouter extends AnyRouter> =
-  inferRouterProxyClient<TRouter> extends infer $ProcedureRecord
-    ? UntypedClientProperties & keyof $ProcedureRecord extends never
-      ? inferRouterProxyClient<TRouter>
-      : IntersectionError<UntypedClientProperties & keyof $ProcedureRecord>
-    : never;
-
-/**
- * @deprecated use `createTRPCProxyClient` instead
- * @internal
- */
-export function createTRPCClientProxy<TRouter extends AnyRouter>(
-  client: TRPCClient<TRouter>,
-): CreateTRPCProxyClient<TRouter> {
-  return createFlatProxy<CreateTRPCProxyClient<TRouter>>((key) => {
-    if (client.hasOwnProperty(key)) {
-      return (client as any)[key as any];
-    }
-    if (key === '__untypedClient') {
-      return client;
-    }
-    return createRecursiveProxy(({ path, args }) => {
-      const pathCopy = [key, ...path];
-      const procedureType = clientCallTypeToProcedureType(pathCopy.pop()!);
-
-      const fullPath = pathCopy.join('.');
-
-      return (client as any)[procedureType](fullPath, ...args);
-    });
-  });
-}
-
-export function createTRPCProxyClient<TRouter extends AnyRouter>(
-  opts: CreateTRPCClientOptions<TRouter>,
-): CreateTRPCProxyClient<TRouter> {
-  const client = new TRPCUntypedClient(opts);
-  const proxy = createTRPCClientProxy(client as TRPCClient<TRouter>);
-  return proxy;
-}
-
-/**
- * Get an untyped client from a proxy client
- * @internal
- */
-export function getUntypedClient<TRouter extends AnyRouter>(
-  client: inferRouterProxyClient<TRouter>,
-): TRPCUntypedClient<TRouter> {
-  return (client as any).__untypedClient;
-}