@trpc/client 10.0.0-alpha.0 → 10.0.0-alpha.11

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

@@ -1,12 +1,11 @@
+import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
+import _createClass from '@babel/runtime/helpers/esm/createClass';
 import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
 import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
 import _inherits from '@babel/runtime/helpers/esm/inherits';
 import _createSuper from '@babel/runtime/helpers/esm/createSuper';
 import _wrapNativeSuper from '@babel/runtime/helpers/esm/wrapNativeSuper';
-import { o as observable } from '../../../dist/observable-01534ea8.esm.js';
-import { T as TRPCClientError } from '../../../dist/TRPCClientError-e1da1ef0.esm.js';
-import '@babel/runtime/helpers/objectSpread2';
-import '@babel/runtime/helpers/createClass';
+import { T as TRPCClientError } from '../../../dist/TRPCClientError-09b8a26b.esm.js';
 
 /* istanbul ignore next */
 var retryDelay = function retryDelay(attemptIndex) {
@@ -145,19 +144,24 @@ function createWSClient(opts) {
       }
     };
 
-    var handleIncomingResponse = function handleIncomingResponse(data) {
-      var _req$callbacks$next, _req$callbacks;
+    var handleIncomingResponse = function handleIncomingResponse(res) {
+      var _req$callbacks$onNext, _req$callbacks2;
 
-      var req = data.id !== null && pendingRequests[data.id];
+      var req = res.id !== null && pendingRequests[res.id];
 
       if (!req) {
         // do something?
         return;
       }
 
-      (_req$callbacks$next = (_req$callbacks = req.callbacks).next) === null || _req$callbacks$next === void 0 ? void 0 : _req$callbacks$next.call(_req$callbacks, {
-        data: data
-      });
+      if ('error' in res) {
+        var _req$callbacks$onErro, _req$callbacks;
+
+        (_req$callbacks$onErro = (_req$callbacks = req.callbacks).onError) === null || _req$callbacks$onErro === void 0 ? void 0 : _req$callbacks$onErro.call(_req$callbacks, res);
+        return;
+      }
+
+      (_req$callbacks$onNext = (_req$callbacks2 = req.callbacks).onNext) === null || _req$callbacks$onNext === void 0 ? void 0 : _req$callbacks$onNext.call(_req$callbacks2, res.result);
 
       if (req.ws !== activeConnection && conn === activeConnection) {
         var oldWs = req.ws; // gracefully replace old connection with this
@@ -166,8 +170,10 @@ function createWSClient(opts) {
         closeIfNoPending(oldWs);
       }
 
-      if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
-        req.callbacks.complete();
+      if (res.result.type === 'stopped' && conn === activeConnection) {
+        var _req$callbacks$onDone, _req$callbacks3;
+
+        (_req$callbacks$onDone = (_req$callbacks3 = req.callbacks).onDone) === null || _req$callbacks$onDone === void 0 ? void 0 : _req$callbacks$onDone.call(_req$callbacks3);
       }
     };
 
@@ -193,7 +199,7 @@ function createWSClient(opts) {
       }
 
       for (var key in pendingRequests) {
-        var _req$callbacks$error, _req$callbacks2;
+        var _req$callbacks$onErro2, _req$callbacks4;
 
         var req = pendingRequests[key];
 
@@ -201,13 +207,13 @@ function createWSClient(opts) {
           continue;
         }
 
-        (_req$callbacks$error = (_req$callbacks2 = req.callbacks).error) === null || _req$callbacks$error === void 0 ? void 0 : _req$callbacks$error.call(_req$callbacks2, TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+        (_req$callbacks$onErro2 = (_req$callbacks4 = req.callbacks).onError) === null || _req$callbacks$onErro2 === void 0 ? void 0 : _req$callbacks$onErro2.call(_req$callbacks4, TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
 
         if (req.type !== 'subscription') {
-          var _req$callbacks$comple, _req$callbacks3;
+          var _req$callbacks$onDone2, _req$callbacks5;
 
           delete pendingRequests[key];
-          (_req$callbacks$comple = (_req$callbacks3 = req.callbacks).complete) === null || _req$callbacks$comple === void 0 ? void 0 : _req$callbacks$comple.call(_req$callbacks3);
+          (_req$callbacks$onDone2 = (_req$callbacks5 = req.callbacks).onDone) === null || _req$callbacks$onDone2 === void 0 ? void 0 : _req$callbacks$onDone2.call(_req$callbacks5);
         } else if (state !== 'closed') {
           // request restart of sub with next connection
           resumeSubscriptionOnReconnect(req);
@@ -241,14 +247,14 @@ function createWSClient(opts) {
     outgoing.push(envelope);
     dispatch();
     return function () {
-      var _pendingRequests$id, _callbacks$complete;
+      var _pendingRequests$id, _callbacks$onDone;
 
       var callbacks = (_pendingRequests$id = pendingRequests[id]) === null || _pendingRequests$id === void 0 ? void 0 : _pendingRequests$id.callbacks;
       delete pendingRequests[id];
       outgoing = outgoing.filter(function (msg) {
         return msg.id !== id;
       });
-      callbacks === null || callbacks === void 0 ? void 0 : (_callbacks$complete = callbacks.complete) === null || _callbacks$complete === void 0 ? void 0 : _callbacks$complete.call(callbacks);
+      callbacks === null || callbacks === void 0 ? void 0 : (_callbacks$onDone = callbacks.onDone) === null || _callbacks$onDone === void 0 ? void 0 : _callbacks$onDone.call(callbacks);
 
       if (op.type === 'subscription') {
         outgoing.push({
@@ -289,7 +295,7 @@ var TRPCWebSocketClosedError = /*#__PURE__*/function (_Error) {
     return _this;
   }
 
-  return TRPCWebSocketClosedError;
+  return _createClass(TRPCWebSocketClosedError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
 
 var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
@@ -308,55 +314,74 @@ var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
     return _this2;
   }
 
-  return TRPCSubscriptionEndedError;
+  return _createClass(TRPCSubscriptionEndedError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
 
 function wsLink(opts) {
-  return function () {
+  // initialized config
+  return function (rt) {
     var client = opts.client;
     return function (_ref2) {
-      var op = _ref2.op;
-      return observable(function (observer) {
-        var type = op.type,
-            input = op.input,
-            path = op.path,
-            id = op.id,
-            context = op.context;
-        var isDone = false;
-        var unsub = client.request({
-          type: type,
-          path: path,
-          input: input,
-          id: id,
-          context: context
-        }, {
-          error: function error(err) {
+      var op = _ref2.op,
+          prev = _ref2.prev,
+          onDestroy = _ref2.onDestroy;
+      var type = op.type,
+          rawInput = op.input,
+          path = op.path,
+          id = op.id;
+      var input = rt.transformer.serialize(rawInput);
+      var isDone = false;
+      var unsub = client.request({
+        type: type,
+        path: path,
+        input: input,
+        id: id
+      }, {
+        onNext: function onNext(result) {
+          if (isDone) {
+            return;
+          }
+
+          if ('data' in result) {
+            var data = rt.transformer.deserialize(result.data);
+            prev({
+              type: 'data',
+              data: data
+            });
+          } else {
+            prev(result);
+          }
+
+          if (op.type !== 'subscription') {
+            // if it isn't a subscription we don't care about next response
             isDone = true;
-            observer.error(err);
             unsub();
-          },
-          complete: function complete() {
-            if (!isDone) {
-              isDone = true;
-              observer.error(TRPCClientError.from(new TRPCSubscriptionEndedError('Operation ended prematurely')));
-            } else {
-              observer.complete();
-            }
-          },
-          next: function next(result) {
-            observer.next(result);
-
-            if (op.type !== 'subscription') {
-              // if it isn't a subscription we don't care about next response
-              isDone = true;
-              unsub();
-              observer.complete();
-            }
           }
-        });
-        return function () {
-          unsub();
-        };
+        },
+        onError: function onError(err) {
+          if (isDone) {
+            return;
+          }
+
+          prev(err instanceof Error ? err : TRPCClientError.from(_objectSpread(_objectSpread({}, err), {}, {
+            error: rt.transformer.deserialize(err.error)
+          })));
+        },
+        onDone: function onDone() {
+          if (isDone) {
+            return;
+          }
+
+          var result = new TRPCSubscriptionEndedError('Operation ended prematurely');
+          prev(TRPCClientError.from(result, {
+            isDone: true
+          }));
+          isDone = true;
+        }
+      });
+      onDestroy(function () {
+        isDone = true;
+        unsub();
       });
     };
   };

package/links/wsLink/index.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/links/wsLink';

package/links/wsLink/index.js

@@ -0,0 +1 @@
+module.exports = require('../../dist/links/wsLink');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "10.0.0-alpha.0",
+  "version": "10.0.0-alpha.11",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -10,41 +10,72 @@
     "url": "git+https://github.com/trpc/trpc.git",
     "directory": "packages/client"
   },
-  "preconstruct": {
-    "entrypoints": [
-      "index.ts",
-      "links/httpBatchLink.ts",
-      "links/httpLink.ts",
-      "links/loggerLink.ts",
-      "links/splitLink.ts",
-      "links/transformerLink.ts",
-      "links/wsLink.ts",
-      "rx/index.ts",
-      "rx/operators/index.ts"
-    ]
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./rx": {
+      "import": "./dist/rx.mjs",
+      "require": "./dist/rx.js",
+      "default": "./dist/rx.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/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/wsLink": {
+      "import": "./dist/links/wsLink.mjs",
+      "require": "./dist/links/wsLink.js",
+      "default": "./dist/links/wsLink.js"
+    }
   },
-  "scripts": {},
-  "main": "dist/trpc-client.cjs.js",
-  "module": "dist/trpc-client.esm.js",
-  "typings": "dist/trpc-client.cjs.d.ts",
   "files": [
     "README.md",
     "dist",
     "links",
-    "src",
-    "rx"
+    "src"
   ],
+  "scripts": {
+    "build": "rollup -c"
+  },
   "dependencies": {
-    "@babel/runtime": "^7.9.0"
+    "@babel/runtime": "^7.9.0",
+    "rxjs": "^7.5.4"
   },
   "peerDependencies": {
-    "@trpc/server": "10.0.0-alpha.0"
+    "@trpc/server": "10.0.0-alpha.11"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.0"
+    "@trpc/server": "10.0.0-alpha.11"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ec10cf19bd153946e9211a32e3e2b511e37e6325"
+  "gitHead": "a330502ab8d9aeb1f8f01d9a0711aab849d3a938"
 }

package/src/internals/TRPCClient.ts

@@ -18,11 +18,8 @@ import {
   OperationLink,
   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 { inferObservableValue, observableToPromise, share } from '../rx';
+import { Observer, Subscription } from 'rxjs';
 import { TRPCClientError } from '../TRPCClientError';
 import { getAbortController } from './fetchHelpers';
 
@@ -216,16 +213,15 @@ export class TRPCClient<TRouter extends AnyRouter> {
   >(
     path: TPath,
     input: TInput,
-    opts: TRPCRequestOptions &
-      Partial<Observer<TRPCResult<TOutput>, TRPCClientError<TRouter>>>,
-  ): UnsubscribeFn {
+    opts: TRPCRequestOptions & Partial<Observer<TRPCResult<TOutput>>>,
+  ): Subscription {
     const observable$ = this.$request<TInput, TOutput>({
       type: 'subscription',
       path,
       input,
       context: opts.context,
     });
-    const observer = observable$.subscribe({
+    return observable$.subscribe({
       next(result) {
         if ('error' in result.data) {
           const err = TRPCClientError.from(result.data, {
@@ -244,8 +240,5 @@ export class TRPCClient<TRouter extends AnyRouter> {
         opts.complete?.();
       },
     });
-    return () => {
-      observer.unsubscribe();
-    };
   }
 }

package/src/internals/dataLoader.ts

@@ -20,7 +20,10 @@ type BatchLoadFn<TKey, TValue> = (keys: TKey[]) => {
  * Less configuration, no caching, and allows you to cancel requests
  * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
  */
-export function dataLoader<TKey, TValue>(fetchMany: BatchLoadFn<TKey, TValue>) {
+export function dataLoader<TKey, TValue>(
+  fetchMany: BatchLoadFn<TKey, TValue>,
+  opts?: { maxBatchSize?: number },
+) {
   let batch: Batch<TKey, TValue> | null = null;
   let dispatchTimer: NodeJS.Timer | number | null = null;
 
@@ -69,7 +72,16 @@ export function dataLoader<TKey, TValue>(fetchMany: BatchLoadFn<TKey, TValue>) {
       item.reject = reject;
       item.resolve = resolve;
       thisBatch.items.push(item);
+
+      if (
+        typeof opts?.maxBatchSize !== 'undefined' &&
+        thisBatch.items.length >= opts.maxBatchSize
+      ) {
+        dispatch();
+        return;
+      }
     });
+
     if (!dispatchTimer) {
       dispatchTimer = setTimeout(dispatch);
     }

package/src/links/dedupeLink.test.ts

@@ -1,7 +1,7 @@
 import { waitFor } from '@testing-library/dom';
 import { AnyRouter } from '@trpc/server';
 import { OperationLink } from '..';
-import { observable } from '../rx/observable';
+import { Observable } from 'rxjs';
 import { dedupeLink } from './dedupeLink';
 import { createChain } from './internals/createChain';
 
@@ -12,7 +12,7 @@ test('dedupeLink', async () => {
     // "dedupe link"
     dedupeLink()(null as any),
     ({ op }) => {
-      return observable((subscribe) => {
+      return new Observable((subscribe) => {
         endingLinkTriggered();
         const timer = setTimeout(() => {
           timerTriggered();
@@ -75,7 +75,7 @@ test('dedupe - cancel one does not cancel the other', async () => {
     // "dedupe link"
     dedupeLink()(null as any),
     ({ op }) => {
-      return observable((subscribe) => {
+      return new Observable((subscribe) => {
         endingLinkTriggered();
         const timer = setTimeout(() => {
           timerTriggered();

package/src/links/dedupeLink.ts

@@ -1,8 +1,7 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../rx/observable';
-import { share } from '../rx/operators';
-import { Observable } from '../rx/types';
-import { TRPCLink } from './types';
+import { Observable } from 'rxjs';
+import { share } from '../rx';
+import { OperationResult, TRPCLink } from './types';
 
 export function dedupeLink<
   TRouter extends AnyRouter = AnyRouter,
@@ -10,7 +9,7 @@ export function dedupeLink<
   // initialized config
   return () => {
     // initialized in app
-    const pending: Record<string, Observable<any, any>> = {};
+    const pending: Record<string, Observable<any>> = {};
     return ({ op, next }) => {
       // initialized for request
 
@@ -21,31 +20,31 @@ export function dedupeLink<
       const key = JSON.stringify([op.path, op.input]);
       if (pending[key]) {
         // console.log('hooking into pending', { op });
-        return observable((observer) => pending[key].subscribe(observer));
+        return new Observable((observer) => pending[key].subscribe(observer));
       }
 
-      const shared$ = observable((observer) => {
-        function reset() {
-          delete pending[key];
-        }
-        const next$ = next(op).subscribe({
-          next(v) {
-            observer.next(v);
-          },
-          error(e) {
+      const shared$ = new Observable<OperationResult<TRouter, unknown>>(
+        (observer) => {
+          function reset() {
+            delete pending[key];
+          }
+          const next$ = next(op).subscribe({
+            next(v) {
+              observer.next(v);
+            },
+            error(e) {
+              observer.error(e);
+            },
+            complete() {
+              observer.complete();
+            },
+          });
+          return () => {
             reset();
-            observer.error(e);
-          },
-          complete() {
-            reset();
-            observer.complete();
-          },
-        });
-        return () => {
-          reset();
-          next$.unsubscribe();
-        };
-      }).pipe(share());
+            next$.unsubscribe();
+          };
+        },
+      ).pipe(share());
       pending[key] = shared$;
       return shared$;
     };

package/src/links/httpBatchLink.ts

@@ -1,15 +1,20 @@
 import { AnyRouter, ProcedureType } from '@trpc/server';
 import { dataLoader } from '../internals/dataLoader';
-import { observable } from '../rx/observable';
+import { Observable } from 'rxjs';
 import { TRPCLink } from './types';
 import { HTTPLinkOptions, httpRequest, ResponseShape } from './httpUtils';
 
+export interface HttpBatchLinkOptions extends HTTPLinkOptions {
+  maxBatchSize?: number;
+}
 export function httpBatchLink<TRouter extends AnyRouter>(
-  opts: HTTPLinkOptions,
+  opts: HttpBatchLinkOptions,
 ): TRPCLink<TRouter> {
   const { url } = opts;
+  // initialized config
   return (runtime) => {
     type Key = { id: number; path: string; input: unknown };
+
     const fetcher = (type: ProcedureType) => (keyInputPairs: Key[]) => {
       const path = keyInputPairs.map((op) => op.path).join(',');
       const inputs = keyInputPairs.map((op) => op.input);
@@ -38,15 +43,16 @@ export function httpBatchLink<TRouter extends AnyRouter>(
         cancel,
       };
     };
-    const query = dataLoader<Key, ResponseShape>(fetcher('query'));
-    const mutation = dataLoader<Key, ResponseShape>(fetcher('mutation'));
+    const query = dataLoader<Key, ResponseShape>(fetcher('query'), opts);
+    const mutation = dataLoader<Key, ResponseShape>(fetcher('mutation'), opts);
     const subscription = dataLoader<Key, ResponseShape>(
       fetcher('subscription'),
+      opts,
     );
 
     const loaders = { query, subscription, mutation };
     return ({ op }) => {
-      return observable((observer) => {
+      return new Observable((observer) => {
         const loader = loaders[op.type];
         const { promise, cancel } = loader.load(op);
 

package/src/links/httpLink.ts

@@ -1,5 +1,5 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../rx/observable';
+import { Observable } from 'rxjs';
 import { TRPCLink } from './types';
 import { HTTPLinkOptions, httpRequest } from './httpUtils';
 
@@ -9,7 +9,7 @@ export function httpLink<TRouter extends AnyRouter>(
   const { url } = opts;
   return (runtime) =>
     ({ op }) =>
-      observable((observer) => {
+      new Observable((observer) => {
         const { path, input, type } = op;
         const { promise, cancel } = httpRequest({
           runtime,

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

@@ -1,21 +1,21 @@
 import { AnyRouter } from '@trpc/server/src';
 import { createChain } from './createChain';
-import { observable } from '../../rx/observable';
+import { Observable } from 'rxjs';
 
 describe('chain', () => {
   test('trivial', () => {
     const result$ = createChain<AnyRouter, unknown, unknown>({
       links: [
         ({ next, op }) => {
-          return observable((observer) => {
-            const next$ = next(op).subscribe(observer);
+          return new Observable((observer) => {
+            const subscription = next(op).subscribe(observer);
             return () => {
-              next$.unsubscribe();
+              subscription.unsubscribe();
             };
           });
         },
         ({ op }) => {
-          return observable((observer) => {
+          return new Observable((observer) => {
             observer.next({
               context: {},
               data: {
@@ -51,7 +51,7 @@ describe('chain', () => {
     const result$ = createChain<AnyRouter, unknown, unknown>({
       links: [
         ({ next, op }) => {
-          return observable((observer) => {
+          return new Observable((observer) => {
             observer.next({
               context: {},
               data: {
@@ -69,7 +69,7 @@ describe('chain', () => {
           });
         },
         ({ op }) => {
-          return observable((observer) => {
+          return new Observable((observer) => {
             observer.next({
               data: {
                 id: null,

package/src/links/internals/createChain.ts

@@ -1,5 +1,5 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../../rx/observable';
+import { Observable } from 'rxjs';
 import { Operation, OperationLink, OperationResultObservable } from '../types';
 
 /** @internal */
@@ -11,7 +11,7 @@ export function createChain<
   links: OperationLink<TRouter, TInput, TOutput>[];
   op: Operation<TInput>;
 }): OperationResultObservable<TRouter, TOutput> {
-  return observable((observer) => {
+  return new Observable((observer) => {
     function execute(index = 0, op = opts.op) {
       const next = opts.links[index];
       const next$ = next({

package/src/links/loggerLink.ts

@@ -1,7 +1,6 @@
 import { AnyRouter } from '@trpc/server';
 import { TRPCClientError } from '..';
-import { observable } from '../rx/observable';
-import { tap } from '../rx/operators';
+import { Observable, tap } from 'rxjs';
 import { Operation, OperationResult, TRPCLink } from './types';
 
 type ConsoleEsque = {
@@ -108,7 +107,7 @@ export function loggerLink<TRouter extends AnyRouter = AnyRouter>(
 
   return () => {
     return ({ op, next }) => {
-      return observable((observer) => {
+      return new Observable((observer) => {
         // ->
         enabled({ ...op, direction: 'up' }) &&
           logger({