@trpc/client 11.0.0-next.92 → 11.0.0-rc.329

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "11.0.0-next.92+06cebb01",
+  "version": "11.0.0-rc.329+fdcb4a7d8",
   "description": "The tRPC client library",
   "author": "KATT",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "build": "rollup --config rollup.config.ts --configPlugin rollup-plugin-swc3",
     "dev": "pnpm build --watch",
     "codegen-entrypoints": "tsx entrypoints.script.ts",
-    "lint": "eslint --cache --ext \".js,.ts,.tsx\" --ignore-path ../../.gitignore --report-unused-disable-directives src",
-    "ts-watch": "tsc --project tsconfig.watch.json --watch"
+    "lint": "eslint --cache --ext \".js,.ts,.tsx\" --ignore-path ../../.gitignore src",
+    "ts-watch": "tsc --watch"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -35,35 +35,35 @@
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./links/httpLink": {
-      "import": "./dist/links/httpLink.mjs",
-      "require": "./dist/links/httpLink.js",
-      "default": "./dist/links/httpLink.js"
-    },
     "./links/httpBatchLink": {
       "import": "./dist/links/httpBatchLink.mjs",
       "require": "./dist/links/httpBatchLink.js",
       "default": "./dist/links/httpBatchLink.js"
     },
-    "./links/splitLink": {
-      "import": "./dist/links/splitLink.mjs",
-      "require": "./dist/links/splitLink.js",
-      "default": "./dist/links/splitLink.js"
+    "./links/httpLink": {
+      "import": "./dist/links/httpLink.mjs",
+      "require": "./dist/links/httpLink.js",
+      "default": "./dist/links/httpLink.js"
     },
     "./links/loggerLink": {
       "import": "./dist/links/loggerLink.mjs",
       "require": "./dist/links/loggerLink.js",
       "default": "./dist/links/loggerLink.js"
     },
+    "./links/splitLink": {
+      "import": "./dist/links/splitLink.mjs",
+      "require": "./dist/links/splitLink.js",
+      "default": "./dist/links/splitLink.js"
+    },
     "./links/wsLink": {
       "import": "./dist/links/wsLink.mjs",
       "require": "./dist/links/wsLink.js",
       "default": "./dist/links/wsLink.js"
     },
-    "./shared": {
-      "import": "./dist/shared/index.mjs",
-      "require": "./dist/shared/index.js",
-      "default": "./dist/shared/index.js"
+    "./unstable-internals": {
+      "import": "./dist/unstable-internals.mjs",
+      "require": "./dist/unstable-internals.js",
+      "default": "./dist/unstable-internals.js"
     }
   },
   "files": [
@@ -72,24 +72,22 @@
     "README.md",
     "package.json",
     "links",
-    "shared",
+    "unstable-internals",
     "!**/*.test.*"
   ],
   "peerDependencies": {
-    "@trpc/server": "11.0.0-next.92+06cebb01"
+    "@trpc/server": "11.0.0-rc.329+fdcb4a7d8"
   },
   "devDependencies": {
-    "@testing-library/dom": "^9.0.0",
-    "@trpc/server": "11.0.0-next.92+06cebb01",
-    "@types/isomorphic-fetch": "^0.0.38",
-    "@types/node": "^18.16.16",
-    "eslint": "^8.40.0",
+    "@trpc/server": "11.0.0-rc.329+fdcb4a7d8",
+    "@types/isomorphic-fetch": "^0.0.39",
+    "@types/node": "^20.10.0",
+    "eslint": "^8.56.0",
     "isomorphic-fetch": "^3.0.0",
     "node-fetch": "^3.3.0",
-    "rollup": "^2.79.1",
-    "tsx": "^3.12.7",
-    "undici": "^5.14.0",
-    "vitest": "^0.32.0"
+    "rollup": "^4.9.5",
+    "tsx": "^4.0.0",
+    "undici": "^6.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -97,5 +95,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "06cebb015144e438281edace5dc4a5328477e495"
+  "gitHead": "fdcb4a7d8168d19f9bcbc816b80db815b06a134c"
 }

package/src/TRPCClientError.ts

@@ -1,14 +1,23 @@
-import { DefaultErrorShape, Maybe } from '@trpc/server';
-import { TRPCErrorResponse } from '@trpc/server/rpc';
-import { inferErrorShape, TRPCInferrable } from '@trpc/server/shared';
-import { isObject } from './internals/isObject';
+import type {
+  inferClientTypes,
+  InferrableClientTypes,
+  Maybe,
+  TRPCErrorResponse,
+} from '@trpc/server/unstable-core-do-not-import';
+import {
+  getCauseFromUnknown,
+  isObject,
+  type DefaultErrorShape,
+} from '@trpc/server/unstable-core-do-not-import';
 
+type inferErrorShape<TInferrable extends InferrableClientTypes> =
+  inferClientTypes<TInferrable>['errorShape'];
 export interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
   readonly message: string;
   readonly shape: Maybe<TShape>;
   readonly data: Maybe<TShape['data']>;
 }
-export type TRPCClientErrorLike<TInferrable extends TRPCInferrable> =
+export type TRPCClientErrorLike<TInferrable extends InferrableClientTypes> =
   TRPCClientErrorBase<inferErrorShape<TInferrable>>;
 
 function isTRPCClientError(cause: unknown): cause is TRPCClientError<any> {
@@ -25,17 +34,19 @@ function isTRPCClientError(cause: unknown): cause is TRPCClientError<any> {
 function isTRPCErrorResponse(obj: unknown): obj is TRPCErrorResponse<any> {
   return (
     isObject(obj) &&
-    isObject(obj.error) &&
-    typeof obj.error.code === 'number' &&
-    typeof obj.error.message === 'string'
+    isObject(obj['error']) &&
+    typeof obj['error']['code'] === 'number' &&
+    typeof obj['error']['message'] === 'string'
   );
 }
 
-export class TRPCClientError<TRouterOrProcedure extends TRPCInferrable>
+export class TRPCClientError<TRouterOrProcedure extends InferrableClientTypes>
   extends Error
   implements TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>>
 {
-  public readonly cause;
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
+  public override readonly cause;
   public readonly shape: Maybe<inferErrorShape<TRouterOrProcedure>>;
   public readonly data: Maybe<inferErrorShape<TRouterOrProcedure>['data']>;
 
@@ -48,7 +59,7 @@ export class TRPCClientError<TRouterOrProcedure extends TRPCInferrable>
   constructor(
     message: string,
     opts?: {
-      result?: Maybe<inferErrorShape<TRouterOrProcedure>>;
+      result?: Maybe<TRPCErrorResponse<inferErrorShape<TRouterOrProcedure>>>;
       cause?: Error;
       meta?: Record<string, unknown>;
     },
@@ -69,7 +80,7 @@ export class TRPCClientError<TRouterOrProcedure extends TRPCInferrable>
     Object.setPrototypeOf(this, TRPCClientError.prototype);
   }
 
-  public static from<TRouterOrProcedure extends TRPCInferrable>(
+  public static from<TRouterOrProcedure extends InferrableClientTypes>(
     _cause: Error | TRPCErrorResponse<any>,
     opts: { meta?: Record<string, unknown> } = {},
   ): TRPCClientError<TRouterOrProcedure> {
@@ -100,7 +111,7 @@ export class TRPCClientError<TRouterOrProcedure extends TRPCInferrable>
 
     return new TRPCClientError(cause.message, {
       ...opts,
-      cause,
+      cause: getCauseFromUnknown(cause),
     });
   }
 }

package/src/createTRPCClient.ts

@@ -1,30 +1,27 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import type { Unsubscribable } from '@trpc/server/observable';
 import type {
-  AnyMutationProcedure,
   AnyProcedure,
-  AnyQueryProcedure,
-  AnyRootConfig,
   AnyRouter,
-  AnySubscriptionProcedure,
+  inferClientTypes,
+  inferProcedureInput,
+  inferTransformedProcedureOutput,
   IntersectionError,
-  ProcedureArgs,
-  ProcedureRouterRecord,
+  ProcedureOptions,
   ProcedureType,
-} from '@trpc/server';
-import type { Unsubscribable } from '@trpc/server/observable';
+  RouterRecord,
+} from '@trpc/server/unstable-core-do-not-import';
 import {
   createFlatProxy,
   createRecursiveProxy,
-  inferTransformedProcedureOutput,
-  inferTransformedSubscriptionOutput,
-} from '@trpc/server/shared';
-import { CreateTRPCClientOptions } from './createTRPCUntypedClient';
-import {
+} from '@trpc/server/unstable-core-do-not-import';
+import type { CreateTRPCClientOptions } from './createTRPCUntypedClient';
+import type {
   TRPCSubscriptionObserver,
-  TRPCUntypedClient,
   UntypedClientProperties,
 } from './internals/TRPCUntypedClient';
-import { TRPCClientError } from './TRPCClientError';
+import { TRPCUntypedClient } from './internals/TRPCUntypedClient';
+import type { TRPCClientError } from './TRPCClientError';
 
 /**
  * @public
@@ -32,44 +29,41 @@ import { TRPCClientError } from './TRPCClientError';
 export type inferRouterClient<TRouter extends AnyRouter> =
   DecoratedProcedureRecord<TRouter, TRouter['_def']['record']>;
 
+type ResolverDef = {
+  input: any;
+  output: any;
+  transformer: boolean;
+  errorShape: any;
+};
+
 /** @internal */
-export type Resolver<
-  TConfig extends AnyRootConfig,
-  TProcedure extends AnyProcedure,
-> = (
-  ...args: ProcedureArgs<TProcedure['_def']>
-) => Promise<inferTransformedProcedureOutput<TConfig, TProcedure>>;
+export type Resolver<TDef extends ResolverDef> = (
+  input: TDef['input'],
+  opts?: ProcedureOptions,
+) => Promise<TDef['output']>;
 
-type SubscriptionResolver<
-  TConfig extends AnyRootConfig,
-  TProcedure extends AnyProcedure,
-> = (
-  ...args: [
-    input: ProcedureArgs<TProcedure['_def']>[0],
-    opts: Partial<
-      TRPCSubscriptionObserver<
-        inferTransformedSubscriptionOutput<TConfig, TProcedure>,
-        TRPCClientError<TConfig>
-      >
-    > &
-      ProcedureArgs<TProcedure['_def']>[1],
-  ]
+type SubscriptionResolver<TDef extends ResolverDef> = (
+  input: TDef['input'],
+  opts?: Partial<
+    TRPCSubscriptionObserver<TDef['output'], TRPCClientError<TDef>>
+  > &
+    ProcedureOptions,
 ) => Unsubscribable;
 
 type DecorateProcedure<
-  TConfig extends AnyRootConfig,
-  TProcedure extends AnyProcedure,
-> = TProcedure extends AnyQueryProcedure
+  TType extends ProcedureType,
+  TDef extends ResolverDef,
+> = TType extends 'query'
   ? {
-      query: Resolver<TConfig, TProcedure>;
+      query: Resolver<TDef>;
     }
-  : TProcedure extends AnyMutationProcedure
+  : TType extends 'mutation'
   ? {
-      mutate: Resolver<TConfig, TProcedure>;
+      mutate: Resolver<TDef>;
     }
-  : TProcedure extends AnySubscriptionProcedure
+  : TType extends 'subscription'
   ? {
-      subscribe: SubscriptionResolver<TConfig, TProcedure>;
+      subscribe: SubscriptionResolver<TDef>;
     }
   : never;
 
@@ -78,12 +72,25 @@ type DecorateProcedure<
  */
 type DecoratedProcedureRecord<
   TRouter extends AnyRouter,
-  TProcedures extends ProcedureRouterRecord,
+  TRecord extends RouterRecord,
 > = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<TRouter, TProcedures[TKey]['_def']['record']>
-    : TProcedures[TKey] extends AnyProcedure
-    ? DecorateProcedure<TRouter['_def']['_config'], TProcedures[TKey]>
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends RouterRecord
+      ? DecoratedProcedureRecord<TRouter, $Value>
+      : $Value extends AnyProcedure
+      ? DecorateProcedure<
+          $Value['_def']['type'],
+          {
+            input: inferProcedureInput<$Value>;
+            output: inferTransformedProcedureOutput<
+              inferClientTypes<TRouter>,
+              $Value
+            >;
+            errorShape: inferClientTypes<TRouter>['errorShape'];
+            transformer: inferClientTypes<TRouter>['transformer'];
+          }
+        >
+      : never
     : never;
 };
 
@@ -107,10 +114,10 @@ export const clientCallTypeToProcedureType = (
  * Creates a proxy client and shows type errors if you have query names that collide with built-in properties
  */
 export type CreateTRPCClient<TRouter extends AnyRouter> =
-  inferRouterClient<TRouter> extends infer $ProcedureRecord
-    ? UntypedClientProperties & keyof $ProcedureRecord extends never
+  inferRouterClient<TRouter> extends infer $Value
+    ? UntypedClientProperties & keyof $Value extends never
       ? inferRouterClient<TRouter>
-      : IntersectionError<UntypedClientProperties & keyof $ProcedureRecord>
+      : IntersectionError<UntypedClientProperties & keyof $Value>
     : never;
 
 /**

package/src/createTRPCUntypedClient.ts

@@ -1,8 +1,6 @@
-import { AnyRouter } from '@trpc/server';
-import {
-  CreateTRPCClientOptions,
-  TRPCUntypedClient,
-} from './internals/TRPCUntypedClient';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import type { CreateTRPCClientOptions } from './internals/TRPCUntypedClient';
+import { TRPCUntypedClient } from './internals/TRPCUntypedClient';
 
 export function createTRPCUntypedClient<TRouter extends AnyRouter>(
   opts: CreateTRPCClientOptions<TRouter>,

package/src/getFetch.ts

@@ -1,4 +1,4 @@
-import { FetchEsque, NativeFetchEsque } from './internals/types';
+import type { FetchEsque, NativeFetchEsque } from './internals/types';
 
 type AnyFn = (...args: any[]) => unknown;
 

package/src/index.ts

@@ -1,3 +1,5 @@
+// TODO: Be explicit about what we export here
+
 export * from './createTRPCUntypedClient';
 export * from './createTRPCClient';
 export * from './getFetch';

package/src/internals/TRPCUntypedClient.ts

@@ -1,18 +1,15 @@
-import {
-  AnyRouter,
-  ClientDataTransformerOptions,
-  CombinedDataTransformer,
-  DataTransformerOptions,
-  DefaultDataTransformer,
-} from '@trpc/server';
-import {
+import type {
   inferObservableValue,
-  observableToPromise,
-  share,
   Unsubscribable,
 } from '@trpc/server/observable';
+import { observableToPromise, share } from '@trpc/server/observable';
+import type {
+  AnyRouter,
+  InferrableClientTypes,
+  TypeError,
+} from '@trpc/server/unstable-core-do-not-import';
 import { createChain } from '../links/internals/createChain';
-import {
+import type {
   OperationContext,
   OperationLink,
   TRPCClientRuntime,
@@ -20,41 +17,6 @@ import {
 } from '../links/types';
 import { TRPCClientError } from '../TRPCClientError';
 
-type CreateTRPCClientBaseOptions<TRouter extends AnyRouter> =
-  TRouter['_def']['_config']['transformer'] extends DefaultDataTransformer
-    ? {
-        /**
-         * Data transformer
-         *
-         * You must use the same transformer on the backend and frontend
-         * @link https://trpc.io/docs/data-transformers
-         **/
-        transformer?: 'You must set a transformer on the backend router';
-      }
-    : TRouter['_def']['_config']['transformer'] extends DataTransformerOptions
-    ? {
-        /**
-         * Data transformer
-         *
-         * You must use the same transformer on the backend and frontend
-         * @link https://trpc.io/docs/data-transformers
-         **/
-        transformer: TRouter['_def']['_config']['transformer'] extends CombinedDataTransformer
-          ? DataTransformerOptions
-          : TRouter['_def']['_config']['transformer'];
-      }
-    : {
-        /**
-         * Data transformer
-         *
-         * You must use the same transformer on the backend and frontend
-         * @link https://trpc.io/docs/data-transformers
-         **/
-        transformer?:
-          | /** @deprecated **/ ClientDataTransformerOptions
-          | CombinedDataTransformer;
-      };
-
 type TRPCType = 'mutation' | 'query' | 'subscription';
 export interface TRPCRequestOptions {
   /**
@@ -73,10 +35,10 @@ export interface TRPCSubscriptionObserver<TValue, TError> {
 }
 
 /** @internal */
-export type CreateTRPCClientOptions<TRouter extends AnyRouter> =
-  | CreateTRPCClientBaseOptions<TRouter> & {
-      links: TRPCLink<TRouter>[];
-    };
+export type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {
+  links: TRPCLink<TRouter>[];
+  transformer?: TypeError<'The transformer property has moved to httpLink/httpBatchLink/wsLink'>;
+};
 
 /** @internal */
 export type UntypedClientProperties =
@@ -97,39 +59,7 @@ export class TRPCUntypedClient<TRouter extends AnyRouter> {
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
     this.requestId = 0;
 
-    const combinedTransformer: CombinedDataTransformer = (() => {
-      const transformer = opts.transformer as
-        | DataTransformerOptions
-        | undefined;
-
-      if (!transformer) {
-        return {
-          input: {
-            serialize: (data) => data,
-            deserialize: (data) => data,
-          },
-          output: {
-            serialize: (data) => data,
-            deserialize: (data) => data,
-          },
-        };
-      }
-      if ('input' in transformer) {
-        return opts.transformer as CombinedDataTransformer;
-      }
-      return {
-        input: transformer,
-        output: transformer,
-      };
-    })();
-
-    this.runtime = {
-      transformer: {
-        serialize: (data) => combinedTransformer.input.serialize(data),
-        deserialize: (data) => combinedTransformer.output.deserialize(data),
-      },
-      combinedTransformer,
-    };
+    this.runtime = {};
 
     // Initialize the links
     this.links = opts.links.map((link) => link(this.runtime));
@@ -222,7 +152,7 @@ export class TRPCUntypedClient<TRouter extends AnyRouter> {
         } else if (envelope.result.type === 'stopped') {
           opts.onStopped?.();
         } else {
-          opts.onData?.((envelope.result as any).data);
+          opts.onData?.(envelope.result.data);
         }
       },
       error(err) {

package/src/internals/dataLoader.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { CancelFn, PromiseAndCancel } from '../links/types';
+import type { CancelFn, PromiseAndCancel } from '../links/types';
 
 type BatchItem<TKey, TValue> = {
   aborted: boolean;

package/src/internals/getAbortController.ts

@@ -1,5 +1,5 @@
-import { Maybe } from '@trpc/server';
-import { AbortControllerEsque } from './types';
+import type { Maybe } from '@trpc/server/unstable-core-do-not-import';
+import type { AbortControllerEsque } from './types';
 
 export function getAbortController(
   customAbortControllerImpl: Maybe<AbortControllerEsque>,

package/src/internals/transformer.ts

@@ -0,0 +1,76 @@
+import type {
+  AnyClientTypes,
+  CombinedDataTransformer,
+  DataTransformerOptions,
+  TypeError,
+} from '@trpc/server/unstable-core-do-not-import';
+
+/**
+ * @internal
+ */
+export type CoercedTransformerParameters = {
+  transformer?: DataTransformerOptions;
+};
+
+type TransformerOptionYes = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @link https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer: DataTransformerOptions;
+};
+type TransformerOptionNo = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @link https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer?: TypeError<'You must define a transformer on your your `initTRPC`-object first'>;
+};
+
+/**
+ * @internal
+ */
+export type TransformerOptions<
+  TRoot extends Pick<AnyClientTypes, 'transformer'>,
+> = TRoot['transformer'] extends true
+  ? TransformerOptionYes
+  : TransformerOptionNo;
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+export function getTransformer(
+  transformer:
+    | TransformerOptions<{ transformer: false }>['transformer']
+    | TransformerOptions<{ transformer: true }>['transformer']
+    | undefined,
+): CombinedDataTransformer {
+  const _transformer =
+    transformer as CoercedTransformerParameters['transformer'];
+  if (!_transformer) {
+    return {
+      input: {
+        serialize: (data) => data,
+        deserialize: (data) => data,
+      },
+      output: {
+        serialize: (data) => data,
+        deserialize: (data) => data,
+      },
+    };
+  }
+  if ('input' in _transformer) {
+    return _transformer;
+  }
+  return {
+    input: _transformer,
+    output: _transformer,
+  };
+}

package/src/internals/types.ts

@@ -78,12 +78,19 @@ export type WebReadableStreamEsque = {
   getReader: () => ReadableStreamDefaultReader<Uint8Array>;
 };
 
+export type NodeJSReadableStreamEsque = {
+  on(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): NodeJSReadableStreamEsque;
+};
+
 /**
  * A subset of the standard Response properties needed by tRPC internally.
  * @see Response from lib.dom.d.ts
  */
 export interface ResponseEsque {
-  readonly body?: NodeJS.ReadableStream | WebReadableStreamEsque | null;
+  readonly body?: NodeJSReadableStreamEsque | WebReadableStreamEsque | null;
   /**
    * @remarks
    * The built-in Response::json() method returns Promise<any>, but

package/src/links/HTTPBatchLinkOptions.ts

@@ -1,16 +1,18 @@
-import { NonEmptyArray } from '../internals/types';
-import { HTTPLinkBaseOptions } from './internals/httpUtils';
-import { HTTPHeaders, Operation } from './types';
+import type { AnyClientTypes } from '@trpc/server/unstable-core-do-not-import';
+import type { NonEmptyArray } from '../internals/types';
+import type { HTTPLinkBaseOptions } from './internals/httpUtils';
+import type { HTTPHeaders, Operation } from './types';
 
-export interface HTTPBatchLinkOptions extends HTTPLinkBaseOptions {
-  maxURLLength?: number;
-  /**
-   * Headers to be set on outgoing requests or a callback that of said headers
-   * @link http://trpc.io/docs/client/headers
-   */
-  headers?:
-    | HTTPHeaders
-    | ((opts: {
-        opList: NonEmptyArray<Operation>;
-      }) => HTTPHeaders | Promise<HTTPHeaders>);
-}
+export type HTTPBatchLinkOptions<TRoot extends AnyClientTypes> =
+  HTTPLinkBaseOptions<TRoot> & {
+    maxURLLength?: number;
+    /**
+     * Headers to be set on outgoing requests or a callback that of said headers
+     * @link http://trpc.io/docs/client/headers
+     */
+    headers?:
+      | HTTPHeaders
+      | ((opts: {
+          opList: NonEmptyArray<Operation>;
+        }) => HTTPHeaders | Promise<HTTPHeaders>);
+  };