@trpc/client 10.43.0 → 11.0.0-next.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "10.43.0",
+  "version": "11.0.0-next.91+ca021e61",
   "description": "The tRPC client library",
   "author": "KATT",
   "license": "MIT",
@@ -76,11 +76,11 @@
     "!**/*.test.*"
   ],
   "peerDependencies": {
-    "@trpc/server": "10.43.0"
+    "@trpc/server": "11.0.0-next.91+ca021e61"
   },
   "devDependencies": {
     "@testing-library/dom": "^9.0.0",
-    "@trpc/server": "10.43.0",
+    "@trpc/server": "11.0.0-next.91+ca021e61",
     "@types/isomorphic-fetch": "^0.0.38",
     "@types/node": "^18.16.16",
     "eslint": "^8.40.0",
@@ -97,5 +97,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "0d505fd7415f537bd3e263971686b13a78584167"
+  "gitHead": "ca021e61ba8e6eb6e1715f124489cda75a00b5aa"
 }

package/src/TRPCClientError.ts

@@ -1,29 +1,15 @@
-import {
-  AnyProcedure,
-  AnyRouter,
-  DefaultErrorShape,
-  inferRouterError,
-  Maybe,
-} from '@trpc/server';
-import { TRPCErrorResponse, TRPCErrorShape } from '@trpc/server/rpc';
+import { DefaultErrorShape, Maybe } from '@trpc/server';
+import { TRPCErrorResponse } from '@trpc/server/rpc';
+import { inferErrorShape, TRPCInferrable } from '@trpc/server/shared';
 import { isObject } from './internals/isObject';
 
-type ErrorInferrable = AnyProcedure | AnyRouter | TRPCErrorShape<number>;
-
-type inferErrorShape<TInferrable extends ErrorInferrable> =
-  TInferrable extends AnyRouter
-    ? inferRouterError<TInferrable>
-    : TInferrable extends AnyProcedure
-    ? TInferrable['_def']['_config']['$types']['errorShape']
-    : TInferrable;
-
 export interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
   readonly message: string;
   readonly shape: Maybe<TShape>;
   readonly data: Maybe<TShape['data']>;
 }
-export type TRPCClientErrorLike<TRouterOrProcedure extends ErrorInferrable> =
-  TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>>;
+export type TRPCClientErrorLike<TInferrable extends TRPCInferrable> =
+  TRPCClientErrorBase<inferErrorShape<TInferrable>>;
 
 function isTRPCClientError(cause: unknown): cause is TRPCClientError<any> {
   return (
@@ -45,7 +31,7 @@ function isTRPCErrorResponse(obj: unknown): obj is TRPCErrorResponse<any> {
   );
 }
 
-export class TRPCClientError<TRouterOrProcedure extends ErrorInferrable>
+export class TRPCClientError<TRouterOrProcedure extends TRPCInferrable>
   extends Error
   implements TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>>
 {
@@ -83,7 +69,7 @@ export class TRPCClientError<TRouterOrProcedure extends ErrorInferrable>
     Object.setPrototypeOf(this, TRPCClientError.prototype);
   }
 
-  public static from<TRouterOrProcedure extends ErrorInferrable>(
+  public static from<TRouterOrProcedure extends TRPCInferrable>(
     _cause: Error | TRPCErrorResponse<any>,
     opts: { meta?: Record<string, unknown> } = {},
   ): TRPCClientError<TRouterOrProcedure> {

package/src/createTRPCClient.ts

@@ -1,64 +1,156 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import type {
+  AnyMutationProcedure,
+  AnyProcedure,
+  AnyQueryProcedure,
+  AnyRootConfig,
   AnyRouter,
-  inferProcedureInput,
-  inferProcedureOutput,
-  inferSubscriptionOutput,
+  AnySubscriptionProcedure,
+  IntersectionError,
+  ProcedureArgs,
+  ProcedureRouterRecord,
+  ProcedureType,
 } from '@trpc/server';
-import { Unsubscribable } from '@trpc/server/observable';
-import { inferTransformedProcedureOutput } from '@trpc/server/shared';
+import type { Unsubscribable } from '@trpc/server/observable';
+import {
+  createFlatProxy,
+  createRecursiveProxy,
+  inferTransformedProcedureOutput,
+  inferTransformedSubscriptionOutput,
+} from '@trpc/server/shared';
+import { CreateTRPCClientOptions } from './createTRPCUntypedClient';
 import {
-  CreateTRPCClientOptions,
-  TRPCRequestOptions,
   TRPCSubscriptionObserver,
   TRPCUntypedClient,
+  UntypedClientProperties,
 } from './internals/TRPCUntypedClient';
-import { TRPCClientRuntime } from './links';
 import { TRPCClientError } from './TRPCClientError';
 
 /**
- * @deprecated
+ * @public
+ **/
+export type inferRouterClient<TRouter extends AnyRouter> =
+  DecoratedProcedureRecord<TRouter, TRouter['_def']['record']>;
+
+/** @internal */
+export type Resolver<
+  TConfig extends AnyRootConfig,
+  TProcedure extends AnyProcedure,
+> = (
+  ...args: ProcedureArgs<TProcedure['_def']>
+) => Promise<inferTransformedProcedureOutput<TConfig, TProcedure>>;
+
+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],
+  ]
+) => Unsubscribable;
+
+type DecorateProcedure<
+  TConfig extends AnyRootConfig,
+  TProcedure extends AnyProcedure,
+> = TProcedure extends AnyQueryProcedure
+  ? {
+      query: Resolver<TConfig, TProcedure>;
+    }
+  : TProcedure extends AnyMutationProcedure
+  ? {
+      mutate: Resolver<TConfig, TProcedure>;
+    }
+  : TProcedure extends AnySubscriptionProcedure
+  ? {
+      subscribe: SubscriptionResolver<TConfig, TProcedure>;
+    }
+  : never;
+
+/**
+ * @internal
  */
-export interface TRPCClient<TRouter extends AnyRouter> {
-  readonly runtime: TRPCClientRuntime;
-  query<
-    TQueries extends TRouter['_def']['queries'],
-    TPath extends string & keyof TQueries,
-    TInput extends inferProcedureInput<TQueries[TPath]>,
-  >(
-    path: TPath,
-    input?: TInput,
-    opts?: TRPCRequestOptions,
-  ): Promise<inferProcedureOutput<TQueries[TPath]>>;
+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<TRouter['_def']['_config'], TProcedures[TKey]>
+    : never;
+};
 
-  mutation<
-    TMutations extends TRouter['_def']['mutations'],
-    TPath extends string & keyof TMutations,
-    TInput extends inferProcedureInput<TMutations[TPath]>,
-  >(
-    path: TPath,
-    input?: TInput,
-    opts?: TRPCRequestOptions,
-  ): Promise<inferTransformedProcedureOutput<TMutations[TPath]>>;
+const clientCallTypeMap: Record<
+  keyof DecorateProcedure<any, any>,
+  ProcedureType
+> = {
+  query: 'query',
+  mutate: 'mutation',
+  subscribe: 'subscription',
+};
+
+/** @internal */
+export const clientCallTypeToProcedureType = (
+  clientCallType: string,
+): ProcedureType => {
+  return clientCallTypeMap[clientCallType as keyof typeof clientCallTypeMap];
+};
 
-  subscription<
-    TSubscriptions extends TRouter['_def']['subscriptions'],
-    TPath extends string & keyof TSubscriptions,
-    // TODO - this should probably be updated to use inferTransformedProcedureOutput but this is only hit for legacy clients
-    TOutput extends inferSubscriptionOutput<TRouter, TPath>,
-    TInput extends inferProcedureInput<TSubscriptions[TPath]>,
-  >(
-    path: TPath,
-    input: TInput,
-    opts: Partial<TRPCSubscriptionObserver<TOutput, TRPCClientError<TRouter>>> &
-      TRPCRequestOptions,
-  ): Unsubscribable;
-}
 /**
- * @deprecated use `createTRPCProxyClient` instead
+ * 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>
+      : IntersectionError<UntypedClientProperties & keyof $ProcedureRecord>
+    : never;
+
+/**
+ * @internal
+ */
+export function createTRPCClientProxy<TRouter extends AnyRouter>(
+  client: TRPCUntypedClient<TRouter>,
+): CreateTRPCClient<TRouter> {
+  return createFlatProxy<CreateTRPCClient<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 createTRPCClient<TRouter extends AnyRouter>(
   opts: CreateTRPCClientOptions<TRouter>,
-) {
+): CreateTRPCClient<TRouter> {
   const client = new TRPCUntypedClient(opts);
-  return client as TRPCClient<TRouter>;
+  const proxy = createTRPCClientProxy<TRouter>(client);
+  return proxy;
+}
+
+/**
+ * Get an untyped client from a proxy client
+ * @internal
+ */
+export function getUntypedClient<TRouter extends AnyRouter>(
+  client: inferRouterClient<TRouter>,
+): TRPCUntypedClient<TRouter> {
+  return (client as any).__untypedClient;
 }

package/src/index.ts

@@ -1,6 +1,20 @@
 export * from './createTRPCUntypedClient';
 export * from './createTRPCClient';
-export * from './createTRPCClientProxy';
 export * from './getFetch';
 export * from './TRPCClientError';
 export * from './links';
+
+export {
+  /**
+   * @deprecated - use `createTRPCClient` instead
+   */
+  createTRPCClient as createTRPCProxyClient,
+  /**
+   * @deprecated - use `CreateTRPCClient` instead
+   */
+  type CreateTRPCClient as CreateTRPCProxyClient,
+  /**
+   * @deprecated - use `inferRouterClient` instead
+   */
+  type inferRouterClient as inferRouterProxyClient,
+} from './createTRPCClient';

package/src/links/HTTPBatchLinkOptions.ts

@@ -14,8 +14,3 @@ export interface HTTPBatchLinkOptions extends HTTPLinkBaseOptions {
         opList: NonEmptyArray<Operation>;
       }) => HTTPHeaders | Promise<HTTPHeaders>);
 }
-/**
- * @alias HttpBatchLinkOptions
- * @deprecated use `HTTPBatchLinkOptions` instead
- */
-export interface HttpBatchLinkOptions extends HTTPBatchLinkOptions {}