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

package/links/httpBatchLink/dist/trpc-client-links-httpBatchLink.cjs.prod.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var TRPCClientError = require('../../../dist/TRPCClientError-e9bf96e9.cjs.prod.js');
-var transformRPCResponse = require('../../../dist/transformRPCResponse-e6daeb02.cjs.prod.js');
+var httpRequest = require('../../../dist/httpRequest-66400297.cjs.prod.js');
 var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
 require('@babel/runtime/helpers/objectSpread2');
 require('@babel/runtime/helpers/classCallCheck');
@@ -133,7 +133,7 @@ function httpBatchLink(opts) {
           return op.input;
         });
 
-        var _httpRequest = transformRPCResponse.httpRequest({
+        var _httpRequest = httpRequest.httpRequest({
           url: url,
           inputs: inputs,
           path: path,
@@ -194,13 +194,13 @@ function httpBatchLink(opts) {
       };
 
       onDestroy(function () {
-        prevOnce(TRPCClientError.TRPCClientError.from(new transformRPCResponse.TRPCAbortError(), {
+        prevOnce(TRPCClientError.TRPCClientError.from(new httpRequest.TRPCAbortError(), {
           isDone: true
         }));
         cancel();
       });
       promise.then(function (envelope) {
-        prevOnce(transformRPCResponse.transformRPCResponse({
+        prevOnce(httpRequest.transformRPCResponse({
           envelope: envelope,
           runtime: runtime
         }));

package/links/httpBatchLink/dist/trpc-client-links-httpBatchLink.esm.js

@@ -1,5 +1,5 @@
 import { T as TRPCClientError } from '../../../dist/TRPCClientError-09b8a26b.esm.js';
-import { T as TRPCAbortError, t as transformRPCResponse, h as httpRequest } from '../../../dist/transformRPCResponse-3700ef8b.esm.js';
+import { T as TRPCAbortError, t as transformRPCResponse, h as httpRequest } from '../../../dist/httpRequest-62c5cce4.esm.js';
 import _createForOfIteratorHelper from '@babel/runtime/helpers/esm/createForOfIteratorHelper';
 import '@babel/runtime/helpers/objectSpread2';
 import '@babel/runtime/helpers/classCallCheck';

package/links/httpLink/dist/trpc-client-links-httpLink.cjs.dev.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var TRPCClientError = require('../../../dist/TRPCClientError-bfee2bf5.cjs.dev.js');
-var transformRPCResponse = require('../../../dist/transformRPCResponse-0ad3cc9f.cjs.dev.js');
+var httpRequest = require('../../../dist/httpRequest-6b1f0c6f.cjs.dev.js');
 require('@babel/runtime/helpers/objectSpread2');
 require('@babel/runtime/helpers/classCallCheck');
 require('@babel/runtime/helpers/createClass');
@@ -25,7 +25,7 @@ function httpLink(opts) {
           input = op.input,
           type = op.type;
 
-      var _httpRequest = transformRPCResponse.httpRequest({
+      var _httpRequest = httpRequest.httpRequest({
         runtime: runtime,
         type: type,
         input: input,
@@ -47,13 +47,13 @@ function httpLink(opts) {
       };
 
       onDestroy(function () {
-        prevOnce(TRPCClientError.TRPCClientError.from(new transformRPCResponse.TRPCAbortError(), {
+        prevOnce(TRPCClientError.TRPCClientError.from(new httpRequest.TRPCAbortError(), {
           isDone: true
         }));
         cancel();
       });
       promise.then(function (envelope) {
-        prevOnce(transformRPCResponse.transformRPCResponse({
+        prevOnce(httpRequest.transformRPCResponse({
           envelope: envelope,
           runtime: runtime
         }));

package/links/httpLink/dist/trpc-client-links-httpLink.cjs.prod.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var TRPCClientError = require('../../../dist/TRPCClientError-e9bf96e9.cjs.prod.js');
-var transformRPCResponse = require('../../../dist/transformRPCResponse-e6daeb02.cjs.prod.js');
+var httpRequest = require('../../../dist/httpRequest-66400297.cjs.prod.js');
 require('@babel/runtime/helpers/objectSpread2');
 require('@babel/runtime/helpers/classCallCheck');
 require('@babel/runtime/helpers/createClass');
@@ -25,7 +25,7 @@ function httpLink(opts) {
           input = op.input,
           type = op.type;
 
-      var _httpRequest = transformRPCResponse.httpRequest({
+      var _httpRequest = httpRequest.httpRequest({
         runtime: runtime,
         type: type,
         input: input,
@@ -47,13 +47,13 @@ function httpLink(opts) {
       };
 
       onDestroy(function () {
-        prevOnce(TRPCClientError.TRPCClientError.from(new transformRPCResponse.TRPCAbortError(), {
+        prevOnce(TRPCClientError.TRPCClientError.from(new httpRequest.TRPCAbortError(), {
           isDone: true
         }));
         cancel();
       });
       promise.then(function (envelope) {
-        prevOnce(transformRPCResponse.transformRPCResponse({
+        prevOnce(httpRequest.transformRPCResponse({
           envelope: envelope,
           runtime: runtime
         }));

package/links/httpLink/dist/trpc-client-links-httpLink.esm.js

@@ -1,5 +1,5 @@
 import { T as TRPCClientError } from '../../../dist/TRPCClientError-09b8a26b.esm.js';
-import { h as httpRequest, T as TRPCAbortError, t as transformRPCResponse } from '../../../dist/transformRPCResponse-3700ef8b.esm.js';
+import { h as httpRequest, T as TRPCAbortError, t as transformRPCResponse } from '../../../dist/httpRequest-62c5cce4.esm.js';
 import '@babel/runtime/helpers/objectSpread2';
 import '@babel/runtime/helpers/classCallCheck';
 import '@babel/runtime/helpers/createClass';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "10.0.0-alpha.42",
+  "version": "10.0.0-alpha.45",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -67,13 +67,13 @@
     "@babel/runtime": "^7.9.0"
   },
   "peerDependencies": {
-    "@trpc/server": "10.0.0-alpha.42"
+    "@trpc/server": "10.0.0-alpha.45"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.42"
+    "@trpc/server": "10.0.0-alpha.45"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d5909785e8d024ef7869d9f5423dbe3bfd80cd59"
+  "gitHead": "337fc1ec6ff60b1cd38a85ba4d564e96d6ba7a40"
 }

package/src/TRPCClientError.ts

@@ -1,25 +1,40 @@
-import { AnyRouter, Maybe, inferRouterError } 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>>
 {
   public readonly cause;
-  public readonly shape: Maybe<inferRouterError<TRouter>>;
-  public readonly data: Maybe<inferRouterError<TRouter>['data']>;
+  public readonly shape;
+  public readonly data;
   public readonly meta;
 
   constructor(
     message: string,
     opts?: {
-      result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
+      result?: Maybe<inferErrorShape<TRouterOrProcedure>>;
       cause?: Error;
       meta?: Record<string, unknown>;
     },
@@ -40,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: undefined,
-        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

@@ -20,4 +20,5 @@ export type {
   TRPCRequestOptions,
   CreateTRPCClientOptions,
   TRPCClient,
+  AssertLegacyDef,
 } from './internals/TRPCClient';

package/src/createTRPCClientProxy.ts

@@ -17,6 +17,7 @@ import type {
 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,
@@ -65,14 +66,16 @@ type assertProcedure<T> = T extends Procedure<any> ? T : never;
 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>,
@@ -83,6 +86,10 @@ const clientCallTypeMap: Record<
   subscribe: 'subscription',
 };
 
+/**
+ * @deprecated use createTRPCProxyClient instead
+ * @internal
+ */
 export function createTRPCClientProxy<TRouter extends AnyRouter>(
   client: Client<TRouter>,
 ) {
@@ -96,3 +103,11 @@ export function createTRPCClientProxy<TRouter extends AnyRouter>(
   });
   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/internals/TRPCClient.ts

@@ -7,6 +7,7 @@ import {
   inferProcedureOutput,
   inferSubscriptionOutput,
 } from '@trpc/server';
+import { ProcedureRecord } from '@trpc/server';
 import {
   Unsubscribable,
   inferObservableValue,
@@ -18,10 +19,6 @@ import { TRPCClientError } from '../TRPCClientError';
 import { getFetch } from '../getFetch';
 import { httpBatchLink } from '../links';
 import { createChain } from '../links/internals/createChain';
-import {
-  transformOperationResult,
-  transformSubscriptionOperationResult,
-} from '../links/internals/transformOperationResult';
 import {
   HTTPHeaders,
   OperationContext,
@@ -97,6 +94,23 @@ export interface TRPCSubscriptionObserver<TValue, TError> {
 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: TRPCClientRuntime;
@@ -179,13 +193,8 @@ export class TRPCClient<TRouter extends AnyRouter> {
     const cancellablePromise: CancellablePromise<any> = new Promise<TOutput>(
       (resolve, reject) => {
         promise
-          .then((result) => {
-            const transformed = transformOperationResult(result, this.runtime);
-            if (transformed.ok) {
-              resolve(transformed.data);
-              return;
-            }
-            reject(transformed.error);
+          .then((envelope) => {
+            resolve((envelope.result as any).data);
           })
           .catch((err) => {
             reject(TRPCClientError.from(err));
@@ -197,15 +206,18 @@ export class TRPCClient<TRouter extends AnyRouter> {
     return cancellablePromise;
   }
   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?,
+    ]
   ) {
     const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
-      inferHandlerInput<TQueries[TPath]>,
+      inferHandlerInput<AssertType<TQueries, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TQueries[TPath]>
     >({
       type: 'query',
@@ -215,15 +227,18 @@ export class TRPCClient<TRouter extends AnyRouter> {
     });
   }
   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?,
+    ]
   ) {
     const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
-      inferHandlerInput<TMutations[TPath]>,
+      inferHandlerInput<AssertType<TMutations, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TMutations[TPath]>
     >({
       type: 'mutation',
@@ -233,10 +248,12 @@ export class TRPCClient<TRouter extends AnyRouter> {
     });
   }
   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,
@@ -249,24 +266,15 @@ export class TRPCClient<TRouter extends AnyRouter> {
       input,
       context: opts.requestContext,
     });
-    const runtime = this.runtime;
     return observable$.subscribe({
-      next(result) {
-        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;
+      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.onError?.(transformed.error);
       },
       error(err) {
         opts.onError?.(err);

package/src/links/dedupeLink.test.ts

@@ -17,13 +17,10 @@ test('dedupeLink', async () => {
         const timer = setTimeout(() => {
           timerTriggered();
           subscribe.next({
-            data: {
-              id: null,
-              result: {
-                type: 'data',
-                data: {
-                  input: op.input,
-                },
+            result: {
+              type: 'data',
+              data: {
+                input: op.input,
               },
             },
           });
@@ -80,13 +77,10 @@ test('dedupe - cancel one does not cancel the other', async () => {
         const timer = setTimeout(() => {
           timerTriggered();
           subscribe.next({
-            data: {
-              id: null,
-              result: {
-                type: 'data',
-                data: {
-                  input: op.input,
-                },
+            result: {
+              type: 'data',
+              data: {
+                input: op.input,
               },
             },
           });

package/src/links/httpBatchLink.ts

@@ -1,12 +1,14 @@
 import { AnyRouter, ProcedureType } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
+import { TRPCClientError } from '../TRPCClientError';
 import { dataLoader } from '../internals/dataLoader';
 import {
   HTTPLinkOptions,
-  ResponseShape,
+  HTTPResult,
   getUrl,
   httpRequest,
 } from './internals/httpUtils';
+import { transformResult } from './internals/transformResult';
 import { TRPCLink } from './types';
 
 export interface HttpBatchLinkOptions extends HTTPLinkOptions {
@@ -67,13 +69,11 @@ export function httpBatchLink<TRouter extends AnyRouter>(
       return { validate, fetch };
     };
 
-    const query = dataLoader<BatchOperation, ResponseShape>(
-      batchLoader('query'),
-    );
-    const mutation = dataLoader<BatchOperation, ResponseShape>(
+    const query = dataLoader<BatchOperation, HTTPResult>(batchLoader('query'));
+    const mutation = dataLoader<BatchOperation, HTTPResult>(
       batchLoader('mutation'),
     );
-    const subscription = dataLoader<BatchOperation, ResponseShape>(
+    const subscription = dataLoader<BatchOperation, HTTPResult>(
       batchLoader('subscription'),
     );
 
@@ -85,9 +85,19 @@ export function httpBatchLink<TRouter extends AnyRouter>(
 
         promise
           .then((res) => {
+            const transformed = transformResult(res.json, runtime);
+
+            if (!transformed.ok) {
+              observer.error(
+                TRPCClientError.from(transformed.error, {
+                  meta: res.meta,
+                }),
+              );
+              return;
+            }
             observer.next({
               context: res.meta,
-              data: res.json as any,
+              result: transformed.result,
             });
             observer.complete();
           })

package/src/links/httpLink.ts

@@ -1,6 +1,8 @@
 import { AnyRouter } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
+import { TRPCClientError } from '../TRPCClientError';
 import { HTTPLinkOptions, httpRequest } from './internals/httpUtils';
+import { transformResult } from './internals/transformResult';
 import { TRPCLink } from './types';
 
 export function httpLink<TRouter extends AnyRouter>(
@@ -20,13 +22,23 @@ export function httpLink<TRouter extends AnyRouter>(
         });
         promise
           .then((res) => {
+            const transformed = transformResult(res.json, runtime);
+
+            if (!transformed.ok) {
+              observer.error(
+                TRPCClientError.from(transformed.error, {
+                  meta: res.meta,
+                }),
+              );
+              return;
+            }
             observer.next({
               context: res.meta,
-              data: res.json as any,
+              result: transformed.result,
             });
             observer.complete();
           })
-          .catch(observer.error);
+          .catch((cause) => TRPCClientError.from(cause));
 
         return () => {
           cancel();

package/src/links/internals/createChain.test.ts

@@ -18,13 +18,10 @@ describe('chain', () => {
           return observable((observer) => {
             observer.next({
               context: {},
-              data: {
-                id: null,
-                result: {
-                  type: 'data',
-                  data: {
-                    input: op.input,
-                  },
+              result: {
+                type: 'data',
+                data: {
+                  input: op.input,
                 },
               },
             });
@@ -54,12 +51,9 @@ describe('chain', () => {
           return observable((observer) => {
             observer.next({
               context: {},
-              data: {
-                id: null,
-                result: {
-                  type: 'data',
-                  data: 'from cache',
-                },
+              result: {
+                type: 'data',
+                data: 'from cache',
               },
             });
             const subscription = next(op).subscribe(observer);
@@ -71,13 +65,10 @@ describe('chain', () => {
         ({ op }) => {
           return observable((observer) => {
             observer.next({
-              data: {
-                id: null,
-                result: {
-                  type: 'data',
-                  data: {
-                    input: op.input,
-                  },
+              result: {
+                type: 'data',
+                data: {
+                  input: op.input,
                 },
               },
             });
@@ -103,12 +94,9 @@ describe('chain', () => {
       Array [
         Object {
           "context": Object {},
-          "data": Object {
-            "id": null,
-            "result": Object {
-              "data": "from cache",
-              "type": "data",
-            },
+          "result": Object {
+            "data": "from cache",
+            "type": "data",
           },
         },
       ]
@@ -116,14 +104,11 @@ describe('chain', () => {
     expect(next.mock.calls[1]).toMatchInlineSnapshot(`
       Array [
         Object {
-          "data": Object {
-            "id": null,
-            "result": Object {
-              "data": Object {
-                "input": "world",
-              },
-              "type": "data",
+          "result": Object {
+            "data": Object {
+              "input": "world",
             },
+            "type": "data",
           },
         },
       ]