@trpc/client 10.0.0-alpha.4 → 10.0.0-alpha.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "10.0.0-alpha.4",
+  "version": "10.0.0-alpha.42",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -10,6 +10,14 @@
     "url": "git+https://github.com/trpc/trpc.git",
     "directory": "packages/client"
   },
+  "eslintConfig": {
+    "rules": {
+      "no-restricted-imports": [
+        "error",
+        "@trpc/client"
+      ]
+    }
+  },
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "typings": "dist/index.d.ts",
@@ -19,68 +27,53 @@
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./links/httpBatchLink": {
-      "import": "./dist/links/httpBatchLink.mjs",
-      "require": "./dist/links/httpBatchLink.js",
-      "default": "./dist/links/httpBatchLink.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/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/transformerLink": {
-      "import": "./dist/links/transformerLink.mjs",
-      "require": "./dist/links/transformerLink.js",
-      "default": "./dist/links/transformerLink.js"
+    "./links/loggerLink": {
+      "import": "./dist/links/loggerLink.mjs",
+      "require": "./dist/links/loggerLink.js",
+      "default": "./dist/links/loggerLink.js"
     },
     "./links/wsLink": {
       "import": "./dist/links/wsLink.mjs",
       "require": "./dist/links/wsLink.js",
       "default": "./dist/links/wsLink.js"
-    },
-    "./rx": {
-      "import": "./dist/rx/index.mjs",
-      "require": "./dist/rx/index.js",
-      "default": "./dist/rx/index.js"
-    },
-    "./rx/operators": {
-      "import": "./dist/rx/operators/index.mjs",
-      "require": "./dist/rx/operators/index.js",
-      "default": "./dist/rx/operators/index.js"
     }
   },
   "files": [
     "README.md",
     "dist",
     "links",
-    "src",
-    "rx"
+    "src"
   ],
   "scripts": {
-    "build": "rollup -c"
+    "build": "rollup -c",
+    "ts-watch": "tsc --project tsconfig.watch.json"
   },
   "dependencies": {
     "@babel/runtime": "^7.9.0"
   },
   "peerDependencies": {
-    "@trpc/server": "10.0.0-alpha.4"
+    "@trpc/server": "10.0.0-alpha.42"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.4"
+    "@trpc/server": "10.0.0-alpha.42"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ef9f7f1d36a26339b96069bba001ea0fe5768bb3"
+  "gitHead": "d5909785e8d024ef7869d9f5423dbe3bfd80cd59"
 }

package/src/TRPCClientError.ts

@@ -1,4 +1,4 @@
-import { AnyRouter, inferRouterError, Maybe } from '@trpc/server';
+import { AnyRouter, Maybe, inferRouterError } from '@trpc/server';
 import { TRPCErrorResponse } from '@trpc/server/rpc';
 
 export interface TRPCClientErrorLike<TRouter extends AnyRouter> {
@@ -11,10 +11,6 @@ export class TRPCClientError<TRouter extends AnyRouter>
   extends Error
   implements TRPCClientErrorLike<TRouter>
 {
-  /**
-   * @deprecated use `cause`
-   */
-  public readonly originalError;
   public readonly cause;
   public readonly shape: Maybe<inferRouterError<TRouter>>;
   public readonly data: Maybe<inferRouterError<TRouter>['data']>;
@@ -24,15 +20,11 @@ export class TRPCClientError<TRouter extends AnyRouter>
     message: string,
     opts?: {
       result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
-      /**
-       * @deprecated use `cause`
-       **/
-      originalError?: Maybe<Error>;
-      cause?: Maybe<Error>;
+      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 +32,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';
@@ -55,7 +47,7 @@ export class TRPCClientError<TRouter extends AnyRouter>
     if (!(cause instanceof Error)) {
       return new TRPCClientError<TRouter>((cause.error as any).message ?? '', {
         ...opts,
-        cause: null,
+        cause: undefined,
         result: cause,
       });
     }

package/src/createTRPCClient.ts

@@ -1,19 +1,23 @@
+/* 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,
 } from './internals/TRPCClient';

package/src/createTRPCClientProxy.ts

@@ -0,0 +1,98 @@
+/* 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 {
+  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,
+> = {
+  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
+    ? DecoratedProcedureRecord<
+        TProcedures[TKey]['_def']['record'],
+        TProcedures[TKey]
+      >
+    : DecorateProcedure<assertProcedure<TProcedures[TKey]>, TRouter>;
+};
+
+const clientCallTypeMap: Record<
+  keyof DecorateProcedure<any, any>,
+  ProcedureType
+> = {
+  query: 'query',
+  mutate: 'mutation',
+  subscribe: 'subscription',
+};
+
+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>;
+}

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,42 +1,40 @@
 import {
   AnyRouter,
+  ClientDataTransformerOptions,
+  DataTransformer,
   inferHandlerInput,
   inferProcedureInput,
   inferProcedureOutput,
   inferSubscriptionOutput,
 } from '@trpc/server';
-import { TRPCResult } from '@trpc/server/rpc';
+import {
+  Unsubscribable,
+  inferObservableValue,
+  observableToPromise,
+  share,
+} from '@trpc/server/observable';
 import { CancelFn } from '..';
+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 {
+  transformOperationResult,
+  transformSubscriptionOperationResult,
+} 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;
@@ -54,6 +52,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 +72,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>[];
 }
@@ -79,7 +82,15 @@ export interface TRPCRequestOptions {
   /**
    * Pass additional context to links
    */
-  context?: OperationContext;
+  requestContext?: OperationContext;
+}
+
+export interface TRPCSubscriptionObserver<TValue, TError> {
+  onStarted: () => void;
+  onData: (value: TValue) => void;
+  onError: (err: TError) => void;
+  onStopped: () => void;
+  onComplete: () => void;
 }
 
 /** @internal */
@@ -88,23 +99,37 @@ export type CreateTRPCClientOptions<TRouter extends AnyRouter> =
   | CreateTRPCClientWithURLOptions;
 export class TRPCClient<TRouter extends AnyRouter> {
   private readonly links: OperationLink<TRouter>[];
-  public readonly runtime: LinkRuntime;
+  public readonly runtime: TRPCClientRuntime;
 
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
     const _fetch = getFetch(opts?.fetch);
     const AC = getAbortController(opts?.AbortController);
 
-    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,
       fetch: _fetch,
       headers: getHeadersFn(),
+      transformer,
     };
 
     if ('links' in opts) {
@@ -155,9 +180,9 @@ export class TRPCClient<TRouter extends AnyRouter> {
       (resolve, reject) => {
         promise
           .then((result) => {
-            const transformed = transformOperationResult(result);
+            const transformed = transformOperationResult(result, this.runtime);
             if (transformed.ok) {
-              resolve(transformed.data as any);
+              resolve(transformed.data);
               return;
             }
             reject(transformed.error);
@@ -178,7 +203,7 @@ export class TRPCClient<TRouter extends AnyRouter> {
     path: TPath,
     ...args: [...inferHandlerInput<TQueries[TPath]>, TRPCRequestOptions?]
   ) {
-    const context = (args[1] as TRPCRequestOptions | undefined)?.context;
+    const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
       inferHandlerInput<TQueries[TPath]>,
       inferProcedureOutput<TQueries[TPath]>
@@ -189,7 +214,6 @@ export class TRPCClient<TRouter extends AnyRouter> {
       context,
     });
   }
-
   public mutation<
     TMutations extends TRouter['_def']['mutations'],
     TPath extends string & keyof TMutations,
@@ -197,7 +221,7 @@ export class TRPCClient<TRouter extends AnyRouter> {
     path: TPath,
     ...args: [...inferHandlerInput<TMutations[TPath]>, TRPCRequestOptions?]
   ) {
-    const context = (args[1] as TRPCRequestOptions | undefined)?.context;
+    const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
       inferHandlerInput<TMutations[TPath]>,
       inferProcedureOutput<TMutations[TPath]>
@@ -217,35 +241,39 @@ export class TRPCClient<TRouter extends AnyRouter> {
     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.requestContext,
     });
-    const observer = observable$.subscribe({
+    const runtime = this.runtime;
+    return observable$.subscribe({
       next(result) {
-        if ('error' in result.data) {
-          const err = TRPCClientError.from(result.data, {
-            meta: result.context,
-          });
-
-          opts.error?.(err);
+        const transformed = transformSubscriptionOperationResult(
+          result,
+          runtime,
+        );
+        if (transformed.ok) {
+          if (transformed.data.type === 'started') {
+            opts.onStarted?.();
+          } else if (transformed.data.type === 'stopped') {
+            opts.onStopped?.();
+          } else if (transformed.data.type === 'data') {
+            opts.onData?.(transformed.data.data);
+          }
           return;
         }
-        opts.next?.(result.data.result);
+        opts.onError?.(transformed.error);
       },
       error(err) {
-        opts.error?.(err);
+        opts.onError?.(err);
       },
       complete() {
-        opts.complete?.();
+        opts.onComplete?.();
       },
     });
-    return () => {
-      observer.unsubscribe();
-    };
   }
 }