@trpc/client 10.0.0-alpha.40 → 10.0.0-alpha.43

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.40",
+  "version": "10.0.0-alpha.43",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -67,13 +67,13 @@
     "@babel/runtime": "^7.9.0"
   },
   "peerDependencies": {
-    "@trpc/server": "10.0.0-alpha.40"
+    "@trpc/server": "10.0.0-alpha.43"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.40"
+    "@trpc/server": "10.0.0-alpha.43"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2af7a0070f3bc01b81fe6f14f591e77c549520a7"
+  "gitHead": "aa47943ffce5844c9bc5d48a4103d766e14d42d9"
 }

package/src/TRPCClientError.ts

@@ -19,7 +19,7 @@ export class TRPCClientError<TRouter extends AnyRouter>
   constructor(
     message: string,
     opts?: {
-      result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
+      result?: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
       cause?: Error;
       meta?: Record<string, unknown>;
     },

package/src/createTRPCClient.ts

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

package/src/createTRPCClientProxy.ts

@@ -10,20 +10,51 @@ import type {
   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 { TRPCClient as Client } from './internals/TRPCClient';
+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 DecorateProcedure<TProcedure extends Procedure<any>> = OmitNeverKeys<{
+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 }
-    ? Resolver<TProcedure>
+    ? SubscriptionResolver<TProcedure, TRouter>
     : never;
 }>;
 
@@ -32,28 +63,51 @@ type assertProcedure<T> = T extends Procedure<any> ? T : never;
 /**
  * @internal
  */
-type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
+type DecoratedProcedureRecord<
+  TProcedures extends ProcedureRouterRecord,
+  TRouter extends AnyRouter,
+> = OmitNeverKeys<{
   [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
-    : DecorateProcedure<assertProcedure<TProcedures[TKey]>>;
-};
+    ? 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>, ProcedureType> = {
+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>;
+    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']>;
+  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,23 +7,18 @@ import {
   inferProcedureOutput,
   inferSubscriptionOutput,
 } from '@trpc/server';
+import { ProcedureRecord } from '@trpc/server';
 import {
-  Observer,
   Unsubscribable,
   inferObservableValue,
   observableToPromise,
   share,
 } from '@trpc/server/observable';
-import { TRPCResultMessage } from '@trpc/server/rpc';
 import { CancelFn } from '..';
 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,
@@ -84,13 +79,38 @@ 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 */
 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;
@@ -173,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));
@@ -191,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)?.context;
+    const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
-      inferHandlerInput<TQueries[TPath]>,
+      inferHandlerInput<AssertType<TQueries, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TQueries[TPath]>
     >({
       type: 'query',
@@ -209,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)?.context;
+    const context = (args[1] as TRPCRequestOptions | undefined)?.requestContext;
     return this.requestAsPromise<
-      inferHandlerInput<TMutations[TPath]>,
+      inferHandlerInput<AssertType<TMutations, ProcedureRecord>[TPath]>,
       inferProcedureOutput<TMutations[TPath]>
     >({
       type: 'mutation',
@@ -227,40 +248,39 @@ 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,
     opts: TRPCRequestOptions &
-      Partial<Observer<TRPCResultMessage<TOutput>, TRPCClientError<TRouter>>>,
+      Partial<TRPCSubscriptionObserver<TOutput, TRPCClientError<TRouter>>>,
   ): Unsubscribable {
     const observable$ = this.$request<TInput, TOutput>({
       type: 'subscription',
       path,
       input,
-      context: opts.context,
+      context: opts.requestContext,
     });
-    const runtime = this.runtime;
     return observable$.subscribe({
-      next(result) {
-        const transformed = transformSubscriptionOperationResult(
-          result,
-          runtime,
-        );
-        if (transformed.ok) {
-          opts.next?.(transformed.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.error?.(transformed.error);
       },
       error(err) {
-        opts.error?.(err);
+        opts.onError?.(err);
       },
       complete() {
-        opts.complete?.();
+        opts.onComplete?.();
       },
     });
   }

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",
           },
         },
       ]