@trpc/client 10.0.0-proxy-alpha.75 → 10.0.0-proxy-alpha.77

package/src/TRPCClientError.ts

@@ -1,15 +1,15 @@
 import {
+  AnyProcedure,
   AnyRouter,
   DefaultErrorShape,
   Maybe,
-  Procedure,
   inferRouterError,
 } from '@trpc/server';
 import { TRPCErrorResponse } from '@trpc/server/rpc';
 
-type RouterOrProcedure = AnyRouter | Procedure<any>;
+type RouterOrProcedure = AnyRouter | AnyProcedure;
 
-type inferErrorShape<TRouterOrProcedure extends AnyRouter | Procedure<any>> =
+type inferErrorShape<TRouterOrProcedure extends RouterOrProcedure> =
   TRouterOrProcedure extends AnyRouter
     ? inferRouterError<TRouterOrProcedure>
     : TRouterOrProcedure['_def']['_config']['errorShape'];

package/src/createTRPCClient.ts

@@ -1,27 +1,57 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { AnyRouter } from '@trpc/server';
+import type { AnyRouter, ClientDataTransformerOptions } from '@trpc/server';
 import {
   TRPCClient as Client,
   CreateTRPCClientOptions,
 } from './internals/TRPCClient';
+import { httpBatchLink } from './links';
+import { HTTPLinkOptions } from './links/internals/httpUtils';
 
 /**
  * @deprecated use `createTRPCProxyClient` instead
  */
 export function createTRPCClient<TRouter extends AnyRouter>(
-  opts: CreateTRPCClientOptions<TRouter>,
+  opts:
+    | CreateTRPCClientOptions<TRouter>
+    | {
+        transformer?: ClientDataTransformerOptions;
+        /**
+         * @deprecated use `links` instead
+         */
+        url: string;
+        /**
+         * @deprecated use `links` instead
+         */
+        headers?: HTTPLinkOptions['headers'];
+        /**
+         * @deprecated use `links` instead
+         */
+        fetch?: HTTPLinkOptions['fetch'];
+        /**
+         * @deprecated use `links` instead
+         */
+        AbortController?: HTTPLinkOptions['AbortController'];
+      },
 ) {
-  const client = new Client<TRouter>(opts);
+  const getLinks = () => {
+    if ('links' in opts) {
+      return opts.links;
+    }
+    return [httpBatchLink(opts)];
+  };
+  const client = new Client<TRouter>({
+    transformer: opts.transformer,
+    links: getLinks(),
+  });
   return client;
 }
 
 // Also the client created above needs to somehow be like `TRPCClient<Router> & Omit<Router, 'createCaller' | 'createProcedure' | '_def' | 'transformer' | 'errorFormatter' | 'getErrorShape>`
 
 export type {
-  TRPCRequestOptions,
   CreateTRPCClientOptions,
   TRPCClient,
-  AssertLegacyDef,
+  TRPCRequestOptions,
 } from './internals/TRPCClient';

package/src/createTRPCClientProxy.ts

@@ -2,8 +2,11 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type {
+  AnyMutationProcedure,
+  AnyProcedure,
+  AnyQueryProcedure,
   AnyRouter,
-  Procedure,
+  AnySubscriptionProcedure,
   ProcedureArgs,
   ProcedureRouterRecord,
   ProcedureType,
@@ -13,23 +16,24 @@ import type {
   Unsubscribable,
   inferObservableValue,
 } from '@trpc/server/observable';
-import { LegacyV9ProcedureTag, createProxy } from '@trpc/server/shared';
+import { createProxy } from '@trpc/server/shared';
 import { TRPCClientError } from './TRPCClientError';
 import { CreateTRPCClientOptions, createTRPCClient } from './createTRPCClient';
 import {
   TRPCClient as Client,
+  TRPCClient,
   TRPCSubscriptionObserver,
 } from './internals/TRPCClient';
 
 export type inferRouterProxyClient<TRouter extends AnyRouter> =
   DecoratedProcedureRecord<TRouter['_def']['record'], TRouter>;
 
-type Resolver<TProcedure extends Procedure<any>> = (
+type Resolver<TProcedure extends AnyProcedure> = (
   ...args: ProcedureArgs<TProcedure['_def']>
 ) => Promise<inferProcedureOutput<TProcedure>>;
 
 type SubscriptionResolver<
-  TProcedure extends Procedure<any>,
+  TProcedure extends AnyProcedure,
   TRouter extends AnyRouter,
 > = (
   ...args: [
@@ -45,24 +49,22 @@ type SubscriptionResolver<
 ) => Unsubscribable;
 
 type DecorateProcedure<
-  TProcedure extends Procedure<any>,
+  TProcedure extends AnyProcedure,
   TRouter extends AnyRouter,
-> = TProcedure extends { _type: 'query' }
+> = TProcedure extends AnyQueryProcedure
   ? {
       query: Resolver<TProcedure>;
     }
-  : TProcedure extends { _type: 'mutation' }
+  : TProcedure extends AnyMutationProcedure
   ? {
       mutate: Resolver<TProcedure>;
     }
-  : TProcedure extends { _type: 'subscription' }
+  : TProcedure extends AnySubscriptionProcedure
   ? {
       subscribe: SubscriptionResolver<TProcedure, TRouter>;
     }
   : never;
 
-type assertProcedure<T> = T extends Procedure<any> ? T : never;
-
 /**
  * @internal
  */
@@ -70,14 +72,14 @@ type DecoratedProcedureRecord<
   TProcedures extends ProcedureRouterRecord,
   TRouter extends AnyRouter,
 > = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends LegacyV9ProcedureTag
-    ? never
-    : TProcedures[TKey] extends AnyRouter
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
     ? DecoratedProcedureRecord<
         TProcedures[TKey]['_def']['record'],
         TProcedures[TKey]
       >
-    : DecorateProcedure<assertProcedure<TProcedures[TKey]>, TRouter>;
+    : TProcedures[TKey] extends AnyProcedure
+    ? DecorateProcedure<TProcedures[TKey], TRouter>
+    : never;
 };
 
 const clientCallTypeMap: Record<
@@ -110,7 +112,7 @@ export function createTRPCClientProxy<TRouter extends AnyRouter>(
 export function createTRPCProxyClient<TRouter extends AnyRouter>(
   opts: CreateTRPCClientOptions<TRouter>,
 ) {
-  const client = createTRPCClient<TRouter>(opts);
+  const client = new TRPCClient<TRouter>(opts);
   const proxy = createTRPCClientProxy(client);
   return proxy;
 }

package/src/internals/TRPCClient.ts

@@ -2,11 +2,11 @@ import {
   AnyRouter,
   ClientDataTransformerOptions,
   DataTransformer,
+  ProcedureRecord,
   inferProcedureInput,
   inferProcedureOutput,
   inferSubscriptionOutput,
 } from '@trpc/server';
-import { ProcedureRecord } from '@trpc/server';
 import {
   Unsubscribable,
   inferObservableValue,
@@ -14,32 +14,15 @@ import {
   share,
 } from '@trpc/server/observable';
 import { TRPCClientError } from '../TRPCClientError';
-import { getFetch } from '../getFetch';
-import { httpBatchLink } from '../links';
 import { createChain } from '../links/internals/createChain';
 import {
-  HTTPHeaders,
   OperationContext,
   OperationLink,
   TRPCClientRuntime,
   TRPCLink,
 } from '../links/types';
-import { getAbortController } from './fetchHelpers';
 
 interface CreateTRPCClientBaseOptions {
-  /**
-   * Add ponyfill for fetch
-   */
-  fetch?: typeof fetch;
-  /**
-   * Add ponyfill for AbortController
-   */
-  AbortController?: typeof AbortController;
-  /**
-   * Headers to be set on outgoing requests or a callback that of said headers
-   * @link http://localhost:3000/docs/v10/header
-   */
-  headers?: HTTPHeaders | (() => HTTPHeaders | Promise<HTTPHeaders>);
   /**
    * Data transformer
    * @link https://trpc.io/docs/data-transformers
@@ -69,32 +52,9 @@ export interface TRPCSubscriptionObserver<TValue, TError> {
  * @internal
  */
 export type CreateTRPCClientOptions<TRouter extends AnyRouter> =
-  | CreateTRPCClientBaseOptions &
-      (
-        | {
-            links: TRPCLink<TRouter>[];
-          }
-        | {
-            url: string;
-            links?: never;
-          }
-      );
-
-export type AssertType<T, K> = T extends K ? T : never;
-/**
- * @deprecated
- */
-export type AssertLegacyDef<TRouter extends AnyRouter> =
-  TRouter['_def']['legacy'] extends Record<
-    'subscriptions' | 'queries' | 'mutations',
-    ProcedureRecord
-  >
-    ? TRouter['_def']['legacy']
-    : {
-        subscriptions: {};
-        queries: {};
-        mutations: {};
-      };
+  | CreateTRPCClientBaseOptions & {
+      links: TRPCLink<TRouter>[];
+    };
 
 export class TRPCClient<TRouter extends AnyRouter> {
   private readonly links: OperationLink<TRouter>[];
@@ -105,18 +65,8 @@ export class TRPCClient<TRouter extends AnyRouter> {
   }
 
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
-    const _fetch = getFetch(opts?.fetch);
-    const AC = getAbortController(opts?.AbortController);
     this.requestId = 0;
 
-    function getHeadersFn(): TRPCClientRuntime['headers'] {
-      if (opts.headers) {
-        const headers = opts.headers;
-        return typeof headers === 'function' ? headers : () => headers;
-      }
-      return () => ({});
-    }
-
     function getTransformer(): DataTransformer {
       if (!opts.transformer)
         return {
@@ -132,20 +82,10 @@ export class TRPCClient<TRouter extends AnyRouter> {
     }
 
     this.runtime = {
-      AbortController: AC,
-      fetch: _fetch,
-      headers: getHeadersFn(),
       transformer: getTransformer(),
     };
-
-    const getLinks = (): OperationLink<TRouter>[] => {
-      if (opts.links) {
-        return opts.links.map((link) => link(this.runtime));
-      }
-      return [httpBatchLink({ url: opts.url })(this.runtime)];
-    };
-
-    this.links = getLinks();
+    // Initialize the links
+    this.links = opts.links.map((link) => link(this.runtime));
   }
 
   private $request<TInput = unknown, TOutput = unknown>({
@@ -197,11 +137,9 @@ export class TRPCClient<TRouter extends AnyRouter> {
     return abortablePromise;
   }
   public query<
-    TQueries extends AssertLegacyDef<TRouter>['queries'],
+    TQueries extends TRouter['_def']['queries'],
     TPath extends string & keyof TQueries,
-    TInput extends inferProcedureInput<
-      AssertType<TQueries, ProcedureRecord>[TPath]
-    >,
+    TInput extends inferProcedureInput<TQueries[TPath]>,
   >(path: TPath, input?: TInput, opts?: TRPCRequestOptions) {
     type TOutput = inferProcedureOutput<TQueries[TPath]>;
     return this.requestAsPromise<TInput, TOutput>({
@@ -213,11 +151,9 @@ export class TRPCClient<TRouter extends AnyRouter> {
     });
   }
   public mutation<
-    TMutations extends AssertLegacyDef<TRouter>['mutations'],
+    TMutations extends TRouter['_def']['mutations'],
     TPath extends string & keyof TMutations,
-    TInput extends inferProcedureInput<
-      AssertType<TMutations, ProcedureRecord>[TPath]
-    >,
+    TInput extends inferProcedureInput<TMutations[TPath]>,
   >(path: TPath, input?: TInput, opts?: TRPCRequestOptions) {
     type TOutput = inferProcedureOutput<TMutations[TPath]>;
     return this.requestAsPromise<TInput, TOutput>({
@@ -229,12 +165,10 @@ export class TRPCClient<TRouter extends AnyRouter> {
     });
   }
   public subscription<
-    TSubscriptions extends AssertLegacyDef<TRouter>['subscriptions'],
+    TSubscriptions extends TRouter['_def']['subscriptions'],
     TPath extends string & keyof TSubscriptions,
     TOutput extends inferSubscriptionOutput<TRouter, TPath>,
-    TInput extends inferProcedureInput<
-      AssertType<TSubscriptions, ProcedureRecord>[TPath]
-    >,
+    TInput extends inferProcedureInput<TSubscriptions[TPath]>,
   >(
     path: TPath,
     input: TInput,

package/src/internals/fetchHelpers.ts

@@ -1,3 +1,5 @@
+import { Maybe } from '@trpc/server';
+
 export function getWindow() {
   if (typeof window !== 'undefined') {
     return window;
@@ -5,7 +7,7 @@ export function getWindow() {
   return globalThis;
 }
 export function getAbortController(
-  ac?: typeof AbortController,
-): typeof AbortController | undefined {
-  return ac ?? getWindow().AbortController ?? undefined;
+  ac: Maybe<typeof AbortController>,
+): typeof AbortController | null {
+  return ac ?? getWindow().AbortController ?? null;
 }

package/src/links/httpBatchLink.ts

@@ -7,6 +7,7 @@ import {
   HTTPResult,
   getUrl,
   httpRequest,
+  resolveHTTPLinkOptions,
 } from './internals/httpUtils';
 import { transformResult } from './internals/transformResult';
 import { TRPCLink } from './types';
@@ -18,6 +19,7 @@ export interface HttpBatchLinkOptions extends HTTPLinkOptions {
 export function httpBatchLink<TRouter extends AnyRouter>(
   opts: HttpBatchLinkOptions,
 ): TRPCLink<TRouter> {
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
   // initialized config
   return (runtime) => {
     type BatchOperation = { id: number; path: string; input: unknown };
@@ -33,7 +35,13 @@ export function httpBatchLink<TRouter extends AnyRouter>(
         const path = batchOps.map((op) => op.path).join(',');
         const inputs = batchOps.map((op) => op.input);
 
-        const url = getUrl({ url: opts.url, runtime, type, path, inputs });
+        const url = getUrl({
+          ...resolvedOpts,
+          runtime,
+          type,
+          path,
+          inputs,
+        });
         return url.length <= maxURLLength;
       };
 
@@ -42,7 +50,7 @@ export function httpBatchLink<TRouter extends AnyRouter>(
         const inputs = batchOps.map((op) => op.input);
 
         const { promise, cancel } = httpRequest({
-          url: opts.url,
+          ...resolvedOpts,
           runtime,
           type,
           path,

package/src/links/httpLink.ts

@@ -1,20 +1,24 @@
 import { AnyRouter } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
 import { TRPCClientError } from '../TRPCClientError';
-import { HTTPLinkOptions, httpRequest } from './internals/httpUtils';
+import {
+  HTTPLinkOptions,
+  httpRequest,
+  resolveHTTPLinkOptions,
+} from './internals/httpUtils';
 import { transformResult } from './internals/transformResult';
 import { TRPCLink } from './types';
 
 export function httpLink<TRouter extends AnyRouter>(
   opts: HTTPLinkOptions,
 ): TRPCLink<TRouter> {
-  const { url } = opts;
+  const resolvedOpts = resolveHTTPLinkOptions(opts);
   return (runtime) =>
     ({ op }) =>
       observable((observer) => {
         const { path, input, type } = op;
         const { promise, cancel } = httpRequest({
-          url,
+          ...resolvedOpts,
           runtime,
           type,
           path,

package/src/links/internals/httpUtils.ts

@@ -1,9 +1,47 @@
 import { ProcedureType } from '@trpc/server';
 import { TRPCResponse } from '@trpc/server/rpc';
-import { PromiseAndCancel, TRPCClientRuntime } from '../types';
+import { getFetch } from '../../getFetch';
+import { getAbortController } from '../../internals/fetchHelpers';
+import { HTTPHeaders, PromiseAndCancel, TRPCClientRuntime } from '../types';
 
 export interface HTTPLinkOptions {
   url: string;
+  /**
+   * Add ponyfill for fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Add ponyfill for AbortController
+   */
+  AbortController?: typeof AbortController | null;
+  /**
+   * Headers to be set on outgoing requests or a callback that of said headers
+   * @link http://trpc.io/docs/v10/header
+   */
+  headers?: HTTPHeaders | (() => HTTPHeaders | Promise<HTTPHeaders>);
+}
+
+export interface ResolvedHTTPLinkOptions {
+  url: string;
+  fetch: typeof fetch;
+  AbortController: typeof AbortController | null;
+  /**
+   * Headers to be set on outgoing request
+   * @link http://trpc.io/docs/v10/header
+   */
+  headers: () => HTTPHeaders | Promise<HTTPHeaders>;
+}
+
+export function resolveHTTPLinkOptions(
+  opts: HTTPLinkOptions,
+): ResolvedHTTPLinkOptions {
+  const headers = opts.headers || (() => ({}));
+  return {
+    url: opts.url,
+    fetch: getFetch(opts.fetch),
+    AbortController: getAbortController(opts.AbortController),
+    headers: typeof headers === 'function' ? headers : () => headers,
+  };
 }
 
 // https://github.com/trpc/trpc/pull/669
@@ -40,7 +78,7 @@ function getInput(opts: GetInputOptions) {
       );
 }
 
-export type HTTPRequestOptions = HTTPLinkOptions &
+export type HTTPRequestOptions = ResolvedHTTPLinkOptions &
   GetInputOptions & {
     type: ProcedureType;
     path: string;
@@ -77,20 +115,20 @@ export function getBody(opts: GetBodyOptions) {
 export function httpRequest(
   opts: HTTPRequestOptions,
 ): PromiseAndCancel<HTTPResult> {
-  const { type, runtime } = opts;
-  const ac = runtime.AbortController ? new runtime.AbortController() : null;
+  const { type } = opts;
+  const ac = opts.AbortController ? new opts.AbortController() : null;
 
   const promise = new Promise<HTTPResult>((resolve, reject) => {
     const url = getUrl(opts);
     const body = getBody(opts);
 
     const meta = {} as HTTPResult['meta'];
-    Promise.resolve(runtime.headers())
+    Promise.resolve(opts.headers())
       .then((headers) => {
         if (type === 'subscription') {
           throw new Error('Subscriptions should use wsLink');
         }
-        return runtime.fetch(url, {
+        return opts.fetch(url, {
           method: METHOD[type],
           signal: ac?.signal,
           body: body,

package/src/links/types.ts

@@ -3,14 +3,26 @@ import { Observable, Observer } from '@trpc/server/observable';
 import { TRPCResultMessage, TRPCSuccessResponse } from '@trpc/server/rpc';
 import { TRPCClientError } from '../TRPCClientError';
 
+/**
+ * @internal
+ */
 export type CancelFn = () => void;
 
+/**
+ * @internal
+ */
 export type PromiseAndCancel<TValue> = {
   promise: Promise<TValue>;
   cancel: CancelFn;
 };
 
+/**
+ * @internal
+ */
 export type OperationContext = Record<string, unknown>;
+/**
+ * @internal
+ */
 export type Operation<TInput = unknown> = {
   id: number;
   type: 'query' | 'mutation' | 'subscription';
@@ -19,6 +31,9 @@ export type Operation<TInput = unknown> = {
   context: OperationContext;
 };
 
+/**
+ * @internal
+ */
 export type HTTPHeaders = Record<string, string | string[] | undefined>;
 
 /**
@@ -31,12 +46,12 @@ export type TRPCFetch = (
 ) => Promise<Response>;
 
 export interface TRPCClientRuntime {
-  fetch: TRPCFetch;
-  AbortController?: typeof AbortController;
-  headers: () => HTTPHeaders | Promise<HTTPHeaders>;
   transformer: DataTransformer;
 }
 
+/**
+ * @internal
+ */
 export interface OperationResultEnvelope<TOutput> {
   result:
     | TRPCSuccessResponse<TOutput>['result']
@@ -44,16 +59,25 @@ export interface OperationResultEnvelope<TOutput> {
   context?: OperationContext;
 }
 
+/**
+ * @internal
+ */
 export type OperationResultObservable<
   TRouter extends AnyRouter,
   TOutput,
 > = Observable<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
 
+/**
+ * @internal
+ */
 export type OperationResultObserver<
   TRouter extends AnyRouter,
   TOutput,
 > = Observer<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
 
+/**
+ * @internal
+ */
 export type OperationLink<
   TRouter extends AnyRouter,
   TInput = unknown,
@@ -63,6 +87,9 @@ export type OperationLink<
   next: (op: Operation<TInput>) => OperationResultObservable<TRouter, TOutput>;
 }) => OperationResultObservable<TRouter, TOutput>;
 
+/**
+ * @public
+ */
 export type TRPCLink<TRouter extends AnyRouter> = (
   opts: TRPCClientRuntime,
 ) => OperationLink<TRouter>;