@trpc/client 10.0.0-alpha.8 → 10.0.0-proxy-alpha.53

package/src/TRPCClientError.ts

@@ -1,38 +1,45 @@
-import { AnyRouter, inferRouterError, Maybe } from '@trpc/server';
+import {
+  AnyRouter,
+  DefaultErrorShape,
+  Maybe,
+  Procedure,
+  inferRouterError,
+} from '@trpc/server';
 import { TRPCErrorResponse } from '@trpc/server/rpc';
 
-export interface TRPCClientErrorLike<TRouter extends AnyRouter> {
+type RouterOrProcedure = AnyRouter | Procedure<any>;
+
+type inferErrorShape<TRouterOrProcedure extends AnyRouter | Procedure<any>> =
+  TRouterOrProcedure extends AnyRouter
+    ? inferRouterError<TRouterOrProcedure>
+    : TRouterOrProcedure['_def']['_config']['errorShape'];
+
+export interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
   readonly message: string;
-  readonly shape: Maybe<inferRouterError<TRouter>>;
-  readonly data: Maybe<inferRouterError<TRouter>['data']>;
+  readonly shape: Maybe<TShape>;
+  readonly data: Maybe<TShape['data']>;
 }
+export type TRPCClientErrorLike<TRouterOrProcedure extends RouterOrProcedure> =
+  TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>>;
 
-export class TRPCClientError<TRouter extends AnyRouter>
+export class TRPCClientError<TRouterOrProcedure extends RouterOrProcedure>
   extends Error
-  implements TRPCClientErrorLike<TRouter>
+  implements TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>>
 {
-  /**
-   * @deprecated use `cause`
-   */
-  public readonly originalError;
   public readonly cause;
-  public readonly shape: Maybe<inferRouterError<TRouter>>;
-  public readonly data: Maybe<inferRouterError<TRouter>['data']>;
+  public readonly shape: Maybe<inferErrorShape<TRouterOrProcedure>>;
+  public readonly data: Maybe<inferErrorShape<TRouterOrProcedure>['data']>;
   public readonly meta;
 
   constructor(
     message: string,
     opts?: {
-      result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
-      /**
-       * @deprecated use `cause`
-       **/
-      originalError?: Maybe<Error>;
-      cause?: Maybe<Error>;
+      result?: Maybe<inferErrorShape<TRouterOrProcedure>>;
+      cause?: Error;
       meta?: Record<string, unknown>;
     },
   ) {
-    const cause = opts?.cause ?? opts?.originalError;
+    const cause = opts?.cause;
 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore https://github.com/tc39/proposal-error-cause
@@ -40,7 +47,7 @@ export class TRPCClientError<TRouter extends AnyRouter>
 
     this.meta = opts?.meta;
 
-    this.cause = this.originalError = cause;
+    this.cause = cause;
     this.shape = opts?.result?.error;
     this.data = opts?.result?.error.data;
     this.name = 'TRPCClientError';
@@ -48,22 +55,25 @@ export class TRPCClientError<TRouter extends AnyRouter>
     Object.setPrototypeOf(this, TRPCClientError.prototype);
   }
 
-  public static from<TRouter extends AnyRouter>(
+  public static from<TRouterOrProcedure extends RouterOrProcedure>(
     cause: Error | TRPCErrorResponse<any>,
     opts: { meta?: Record<string, unknown> } = {},
-  ): TRPCClientError<TRouter> {
+  ): TRPCClientError<TRouterOrProcedure> {
     if (!(cause instanceof Error)) {
-      return new TRPCClientError<TRouter>((cause.error as any).message ?? '', {
-        ...opts,
-        cause: null,
-        result: cause,
-      });
+      return new TRPCClientError<TRouterOrProcedure>(
+        (cause.error as any).message ?? '',
+        {
+          ...opts,
+          cause: undefined,
+          result: cause as any,
+        },
+      );
     }
     if (cause.name === 'TRPCClientError') {
       return cause as TRPCClientError<any>;
     }
 
-    return new TRPCClientError<TRouter>(cause.message, {
+    return new TRPCClientError<TRouterOrProcedure>(cause.message, {
       ...opts,
       cause,
       result: null,

package/src/createTRPCClient.ts

@@ -1,19 +1,24 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { AnyRouter } from '@trpc/server';
 import {
-  CreateTRPCClientOptions,
   TRPCClient as Client,
+  CreateTRPCClientOptions,
 } from './internals/TRPCClient';
 
 export function createTRPCClient<TRouter extends AnyRouter>(
   opts: CreateTRPCClientOptions<TRouter>,
 ) {
-  return new Client<TRouter>(opts);
+  const client = new Client<TRouter>(opts);
+  return client;
 }
 
-export type TRPCClient<TRouter extends AnyRouter> = Client<TRouter>;
+// 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,
 } from './internals/TRPCClient';

package/src/createTRPCClientProxy.ts

@@ -0,0 +1,113 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type {
+  AnyRouter,
+  OmitNeverKeys,
+  Procedure,
+  ProcedureArgs,
+  ProcedureRouterRecord,
+  ProcedureType,
+  inferProcedureOutput,
+} from '@trpc/server';
+import type {
+  Unsubscribable,
+  inferObservableValue,
+} from '@trpc/server/observable';
+import type { TRPCResultMessage } from '@trpc/server/rpc';
+import { createProxy } from '@trpc/server/shared';
+import { TRPCClientError } from './TRPCClientError';
+import { CreateTRPCClientOptions, createTRPCClient } from './createTRPCClient';
+import {
+  TRPCClient as Client,
+  TRPCSubscriptionObserver,
+} from './internals/TRPCClient';
+
+type Resolver<TProcedure extends Procedure<any>> = (
+  ...args: ProcedureArgs<TProcedure['_def']>
+) => Promise<inferProcedureOutput<TProcedure>>;
+
+type SubscriptionResolver<
+  TProcedure extends Procedure<any>,
+  TRouter extends AnyRouter,
+> = (
+  ...args: [
+    input: ProcedureArgs<TProcedure['_def']>[0],
+    opts: ProcedureArgs<TProcedure['_def']>[1] &
+      Partial<
+        TRPCSubscriptionObserver<
+          TRPCResultMessage<
+            inferObservableValue<inferProcedureOutput<TProcedure>>
+          >,
+          TRPCClientError<TRouter>
+        >
+      >,
+  ]
+) => Unsubscribable;
+
+type DecorateProcedure<
+  TProcedure extends Procedure<any>,
+  TRouter extends AnyRouter,
+> = OmitNeverKeys<{
+  query: TProcedure extends { _query: true } ? Resolver<TProcedure> : never;
+
+  mutate: TProcedure extends { _mutation: true } ? Resolver<TProcedure> : never;
+
+  subscribe: TProcedure extends { _subscription: true }
+    ? SubscriptionResolver<TProcedure, TRouter>
+    : never;
+}>;
+
+type assertProcedure<T> = T extends Procedure<any> ? T : never;
+
+/**
+ * @internal
+ */
+type DecoratedProcedureRecord<
+  TProcedures extends ProcedureRouterRecord,
+  TRouter extends AnyRouter,
+> = OmitNeverKeys<{
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
+    ? DecoratedProcedureRecord<
+        TProcedures[TKey]['_def']['record'],
+        TProcedures[TKey]
+      >
+    : assertProcedure<TProcedures[TKey]>['_def']['_old'] extends true
+    ? never
+    : DecorateProcedure<assertProcedure<TProcedures[TKey]>, TRouter>;
+}>;
+
+const clientCallTypeMap: Record<
+  keyof DecorateProcedure<any, any>,
+  ProcedureType
+> = {
+  query: 'query',
+  mutate: 'mutation',
+  subscribe: 'subscription',
+};
+
+/**
+ * @deprecated use createTRPCProxyClient instead
+ * @internal
+ */
+export function createTRPCClientProxy<TRouter extends AnyRouter>(
+  client: Client<TRouter>,
+) {
+  const proxy = createProxy(({ path, args }) => {
+    const pathCopy = [...path];
+    const clientCallType = pathCopy.pop()! as keyof DecorateProcedure<any, any>;
+    const procedureType = clientCallTypeMap[clientCallType];
+
+    const fullPath = pathCopy.join('.');
+    return (client as any)[procedureType](fullPath, ...args);
+  });
+  return proxy as DecoratedProcedureRecord<TRouter['_def']['record'], TRouter>;
+}
+
+export function createTRPCProxyClient<TRouter extends AnyRouter>(
+  opts: CreateTRPCClientOptions<TRouter>,
+) {
+  const client = createTRPCClient<TRouter>(opts);
+  const proxy = createTRPCClientProxy(client);
+  return proxy;
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './createTRPCClient';
+export * from './createTRPCClientProxy';
 export * from './getFetch';
-export * from './links/types';
 export * from './TRPCClientError';
+export * from './links';

package/src/internals/TRPCClient.ts

@@ -1,46 +1,32 @@
 import {
   AnyRouter,
+  ClientDataTransformerOptions,
+  DataTransformer,
   inferHandlerInput,
   inferProcedureInput,
   inferProcedureOutput,
   inferSubscriptionOutput,
 } from '@trpc/server';
-import { TRPCResult } from '@trpc/server/rpc';
-import { CancelFn } from '..';
+import { ProcedureRecord } from '@trpc/server';
+import {
+  Unsubscribable,
+  inferObservableValue,
+  observableToPromise,
+  share,
+} from '@trpc/server/observable';
+import { TRPCClientError } from '../TRPCClientError';
 import { getFetch } from '../getFetch';
-import { httpBatchLink } from '../links/httpBatchLink';
+import { httpBatchLink } from '../links';
 import { createChain } from '../links/internals/createChain';
-import { transformOperationResult } from '../links/internals/transformOperationResult';
 import {
   HTTPHeaders,
-  LinkRuntime,
   OperationContext,
   OperationLink,
+  TRPCClientRuntime,
   TRPCLink,
 } from '../links/types';
-import { UnsubscribeFn } from '../rx';
-import { inferObservableValue } from '../rx/observable';
-import { share } from '../rx/operators';
-import { Observer } from '../rx/types';
-import { observableToPromise } from '../rx/util/observableToPromise';
-import { TRPCClientError } from '../TRPCClientError';
 import { getAbortController } from './fetchHelpers';
 
-type CancellablePromise<T = unknown> = Promise<T> & {
-  cancel: CancelFn;
-};
-
-/**
- * @deprecated no longer used
- */
-export interface FetchOptions {
-  fetch?: typeof fetch;
-  AbortController?: typeof AbortController;
-}
-let idCounter = 0;
-function getRequestId() {
-  return ++idCounter;
-}
 interface CreateTRPCClientBaseOptions {
   /**
    * Add ponyfill for fetch
@@ -54,6 +40,11 @@ interface CreateTRPCClientBaseOptions {
    * headers to be set on outgoing requests / callback that of said headers
    */
   headers?: HTTPHeaders | (() => HTTPHeaders | Promise<HTTPHeaders>);
+  /**
+   * Data transformer
+   * @link https://trpc.io/docs/data-transformers
+   **/
+  transformer?: ClientDataTransformerOptions;
 }
 
 /** @internal */
@@ -69,7 +60,7 @@ export interface CreateTRPCClientWithURLOptions
 export interface CreateTRPCClientWithLinksOptions<TRouter extends AnyRouter>
   extends CreateTRPCClientBaseOptions {
   /**
-   * @link http://localhost:3000/docs/links
+   * @link https://trpc.io/docs/links
    **/
   links: TRPCLink<TRouter>[];
 }
@@ -80,31 +71,76 @@ export interface TRPCRequestOptions {
    * Pass additional context to links
    */
   context?: OperationContext;
+  signal?: AbortSignal;
+}
+
+export interface TRPCSubscriptionObserver<TValue, TError> {
+  onStarted: () => void;
+  onData: (value: TValue) => void;
+  onError: (err: TError) => void;
+  onStopped: () => void;
+  onComplete: () => void;
 }
 
 /** @internal */
 export type CreateTRPCClientOptions<TRouter extends AnyRouter> =
   | CreateTRPCClientWithLinksOptions<TRouter>
   | CreateTRPCClientWithURLOptions;
+
+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: {};
+      };
+
 export class TRPCClient<TRouter extends AnyRouter> {
   private readonly links: OperationLink<TRouter>[];
-  public readonly runtime: LinkRuntime;
+  public readonly runtime: TRPCClientRuntime;
+  private requestId: number;
+  private getRequestId() {
+    return ++this.requestId;
+  }
 
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
     const _fetch = getFetch(opts?.fetch);
     const AC = getAbortController(opts?.AbortController);
+    this.requestId = 0;
 
-    function getHeadersFn(): LinkRuntime['headers'] {
+    function getHeadersFn(): TRPCClientRuntime['headers'] {
       if (opts.headers) {
         const headers = opts.headers;
         return typeof headers === 'function' ? headers : () => headers;
       }
       return () => ({});
     }
+
+    const transformer: DataTransformer = opts.transformer
+      ? 'input' in opts.transformer
+        ? {
+            serialize: opts.transformer.input.serialize,
+            deserialize: opts.transformer.output.deserialize,
+          }
+        : opts.transformer
+      : {
+          serialize: (data) => data,
+          deserialize: (data) => data,
+        };
+
     this.runtime = {
-      AbortController: AC as any,
+      AbortController: AC,
       fetch: _fetch,
       headers: getHeadersFn(),
+      transformer,
     };
 
     if ('links' in opts) {
@@ -132,7 +168,7 @@ export class TRPCClient<TRouter extends AnyRouter> {
     const chain$ = createChain<TRouter, TInput, TOutput>({
       links: this.links as OperationLink<any, any, any>[],
       op: {
-        id: getRequestId(),
+        id: this.getRequestId(),
         type,
         path,
         input,
@@ -146,106 +182,111 @@ export class TRPCClient<TRouter extends AnyRouter> {
     input: TInput;
     path: string;
     context?: OperationContext;
-  }): CancellablePromise<TOutput> {
+    signal?: AbortSignal;
+  }): Promise<TOutput> {
     const req$ = this.$request<TInput, TOutput>(opts);
     type TValue = inferObservableValue<typeof req$>;
     const { promise, abort } = observableToPromise<TValue>(req$);
 
-    const cancellablePromise: CancellablePromise<any> = new Promise<TOutput>(
-      (resolve, reject) => {
-        promise
-          .then((result) => {
-            const transformed = transformOperationResult(result);
-            if (transformed.ok) {
-              resolve(transformed.data as any);
-              return;
-            }
-            reject(transformed.error);
-          })
-          .catch((err) => {
-            reject(TRPCClientError.from(err));
-          });
-      },
-    ) as any;
-    cancellablePromise.cancel = abort;
+    const abortablePromise = new Promise<TOutput>((resolve, reject) => {
+      opts.signal?.addEventListener('abort', abort);
+
+      promise
+        .then((envelope) => {
+          resolve((envelope.result as any).data);
+        })
+        .catch((err) => {
+          reject(TRPCClientError.from(err));
+        });
+    });
 
-    return cancellablePromise;
+    return abortablePromise;
   }
   public query<
-    TQueries extends TRouter['_def']['queries'],
+    TQueries extends AssertLegacyDef<TRouter>['queries'],
     TPath extends string & keyof TQueries,
   >(
     path: TPath,
-    ...args: [...inferHandlerInput<TQueries[TPath]>, TRPCRequestOptions?]
+    ...args: [
+      ...inferHandlerInput<AssertType<TQueries, ProcedureRecord>[TPath]>,
+      TRPCRequestOptions?,
+    ]
   ) {
+    // FIXME: Should be inferred from `args`
     const context = (args[1] as TRPCRequestOptions | undefined)?.context;
+    const signal = (args[1] as TRPCRequestOptions | undefined)?.signal;
+
     return this.requestAsPromise<
-      inferHandlerInput<TQueries[TPath]>,
+      inferHandlerInput<AssertType<TQueries, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TQueries[TPath]>
     >({
       type: 'query',
       path,
       input: args[0] as any,
       context,
+      signal,
     });
   }
-
   public mutation<
-    TMutations extends TRouter['_def']['mutations'],
+    TMutations extends AssertLegacyDef<TRouter>['mutations'],
     TPath extends string & keyof TMutations,
   >(
     path: TPath,
-    ...args: [...inferHandlerInput<TMutations[TPath]>, TRPCRequestOptions?]
+    ...args: [
+      ...inferHandlerInput<AssertType<TMutations, ProcedureRecord>[TPath]>,
+      TRPCRequestOptions?,
+    ]
   ) {
+    // FIXME: Should be inferred from `args`
     const context = (args[1] as TRPCRequestOptions | undefined)?.context;
+    const signal = (args[1] as TRPCRequestOptions | undefined)?.signal;
+
     return this.requestAsPromise<
-      inferHandlerInput<TMutations[TPath]>,
+      inferHandlerInput<AssertType<TMutations, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TMutations[TPath]>
     >({
       type: 'mutation',
       path,
       input: args[0] as any,
       context,
+      signal,
     });
   }
   public subscription<
-    TSubscriptions extends TRouter['_def']['subscriptions'],
+    TSubscriptions extends AssertLegacyDef<TRouter>['subscriptions'],
     TPath extends string & keyof TSubscriptions,
     TOutput extends inferSubscriptionOutput<TRouter, TPath>,
-    TInput extends inferProcedureInput<TSubscriptions[TPath]>,
+    TInput extends inferProcedureInput<
+      AssertType<TSubscriptions, ProcedureRecord>[TPath]
+    >,
   >(
     path: TPath,
     input: TInput,
     opts: TRPCRequestOptions &
-      Partial<Observer<TRPCResult<TOutput>, TRPCClientError<TRouter>>>,
-  ): UnsubscribeFn {
+      Partial<TRPCSubscriptionObserver<TOutput, TRPCClientError<TRouter>>>,
+  ): Unsubscribable {
     const observable$ = this.$request<TInput, TOutput>({
       type: 'subscription',
       path,
       input,
-      context: opts.context,
+      context: opts?.context,
     });
-    const observer = observable$.subscribe({
-      next(result) {
-        if ('error' in result.data) {
-          const err = TRPCClientError.from(result.data, {
-            meta: result.context,
-          });
-
-          opts.error?.(err);
-          return;
+    return observable$.subscribe({
+      next(envelope) {
+        if (envelope.result.type === 'started') {
+          opts.onStarted?.();
+        } else if (envelope.result.type === 'stopped') {
+          opts.onStopped?.();
+        } else {
+          opts.onData?.((envelope.result as any).data);
         }
-        opts.next?.(result.data.result);
       },
       error(err) {
-        opts.error?.(err);
+        opts.onError?.(err);
       },
       complete() {
-        opts.complete?.();
+        opts.onComplete?.();
       },
     });
-    return () => {
-      observer.unsubscribe();
-    };
   }
 }