@trpc/client 10.0.0-alpha.16 → 10.0.0-alpha.19

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

@@ -0,0 +1,390 @@
+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 { T as TRPCClientError } from '../../../dist/TRPCClientError-09b8a26b.esm.js';
+
+/* istanbul ignore next */
+var retryDelay = function retryDelay(attemptIndex) {
+  return attemptIndex === 0 ? 0 : Math.min(1000 * Math.pow(2, attemptIndex), 30000);
+};
+
+function createWSClient(opts) {
+  var url = opts.url,
+      _opts$WebSocket = opts.WebSocket,
+      WebSocketImpl = _opts$WebSocket === void 0 ? WebSocket : _opts$WebSocket,
+      _opts$retryDelayMs = opts.retryDelayMs,
+      retryDelayFn = _opts$retryDelayMs === void 0 ? retryDelay : _opts$retryDelayMs;
+  /* istanbul ignore next */
+
+  if (!WebSocketImpl) {
+    throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+  }
+  /**
+   * outgoing messages buffer whilst not open
+   */
+
+
+  var outgoing = [];
+  /**
+   * pending outgoing requests that are awaiting callback
+   */
+
+  var pendingRequests = Object.create(null);
+  var connectAttempt = 0;
+  var dispatchTimer = null;
+  var connectTimer = null;
+  var activeConnection = createWS();
+  var state = 'connecting';
+  /**
+   * tries to send the list of messages
+   */
+
+  function dispatch() {
+    if (state !== 'open' || dispatchTimer) {
+      return;
+    }
+
+    dispatchTimer = setTimeout(function () {
+      dispatchTimer = null;
+
+      if (outgoing.length === 1) {
+        // single send
+        activeConnection.send(JSON.stringify(outgoing.pop()));
+      } else {
+        // batch send
+        activeConnection.send(JSON.stringify(outgoing));
+      } // clear
+
+
+      outgoing = [];
+    });
+  }
+
+  function tryReconnect() {
+    if (connectTimer || state === 'closed') {
+      return;
+    }
+
+    var timeout = retryDelayFn(connectAttempt++);
+    reconnectInMs(timeout);
+  }
+
+  function reconnect() {
+    state = 'connecting';
+    var oldConnection = activeConnection;
+    activeConnection = createWS();
+    closeIfNoPending(oldConnection);
+  }
+
+  function reconnectInMs(ms) {
+    if (connectTimer) {
+      return;
+    }
+
+    state = 'connecting';
+    connectTimer = setTimeout(reconnect, ms);
+  }
+
+  function closeIfNoPending(conn) {
+    // disconnect as soon as there are are no pending result
+    var hasPendingRequests = Object.values(pendingRequests).some(function (p) {
+      return p.ws === conn;
+    });
+
+    if (!hasPendingRequests) {
+      conn.close();
+    }
+  }
+
+  function resumeSubscriptionOnReconnect(req) {
+    if (outgoing.some(function (r) {
+      return r.id === req.op.id;
+    })) {
+      return;
+    }
+
+    request(req.op, req.callbacks);
+  }
+
+  function createWS() {
+    var conn = new WebSocket(url);
+    clearTimeout(connectTimer);
+    connectTimer = null;
+    conn.addEventListener('open', function () {
+      /* istanbul ignore next */
+      if (conn !== activeConnection) {
+        return;
+      }
+
+      connectAttempt = 0;
+      state = 'open';
+      dispatch();
+    });
+    conn.addEventListener('error', function () {
+      if (conn === activeConnection) {
+        tryReconnect();
+      }
+    });
+
+    var handleIncomingRequest = function handleIncomingRequest(req) {
+      if (req.method === 'reconnect' && conn === activeConnection) {
+        reconnect(); // notify subscribers
+
+        for (var _i = 0, _Object$values = Object.values(pendingRequests); _i < _Object$values.length; _i++) {
+          var pendingReq = _Object$values[_i];
+
+          if (pendingReq.type === 'subscription') {
+            resumeSubscriptionOnReconnect(pendingReq);
+          }
+        }
+      }
+    };
+
+    var handleIncomingResponse = function handleIncomingResponse(res) {
+      var _req$callbacks$onNext, _req$callbacks2;
+
+      var req = res.id !== null && pendingRequests[res.id];
+
+      if (!req) {
+        // do something?
+        return;
+      }
+
+      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
+
+        req.ws = activeConnection;
+        closeIfNoPending(oldWs);
+      }
+
+      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);
+      }
+    };
+
+    conn.addEventListener('message', function (_ref) {
+      var data = _ref.data;
+      var msg = JSON.parse(data);
+
+      if ('method' in msg) {
+        handleIncomingRequest(msg);
+      } else {
+        handleIncomingResponse(msg);
+      }
+
+      if (conn !== activeConnection || state === 'closed') {
+        // when receiving a message, we close old connection that has no pending requests
+        closeIfNoPending(conn);
+      }
+    });
+    conn.addEventListener('close', function () {
+      if (activeConnection === conn) {
+        // connection might have been replaced already
+        tryReconnect();
+      }
+
+      for (var key in pendingRequests) {
+        var _req$callbacks$onErro2, _req$callbacks4;
+
+        var req = pendingRequests[key];
+
+        if (req.ws !== conn) {
+          continue;
+        }
+
+        (_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$onDone2, _req$callbacks5;
+
+          delete pendingRequests[key];
+          (_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);
+        }
+      }
+    });
+    return conn;
+  }
+
+  function request(op, callbacks) {
+    var type = op.type,
+        input = op.input,
+        path = op.path,
+        id = op.id;
+    var envelope = {
+      id: id,
+      jsonrpc: '2.0',
+      method: type,
+      params: {
+        input: input,
+        path: path
+      }
+    };
+    pendingRequests[id] = {
+      ws: activeConnection,
+      type: type,
+      callbacks: callbacks,
+      op: op
+    }; // enqueue message
+
+    outgoing.push(envelope);
+    dispatch();
+    return function () {
+      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$onDone = callbacks.onDone) === null || _callbacks$onDone === void 0 ? void 0 : _callbacks$onDone.call(callbacks);
+
+      if (op.type === 'subscription') {
+        outgoing.push({
+          id: id,
+          method: 'subscription.stop',
+          params: undefined
+        });
+        dispatch();
+      }
+    };
+  }
+
+  return {
+    close: function close() {
+      state = 'closed';
+      closeIfNoPending(activeConnection);
+    },
+    request: request,
+    getConnection: function getConnection() {
+      return activeConnection;
+    }
+  };
+}
+
+var TRPCWebSocketClosedError = /*#__PURE__*/function (_Error) {
+  _inherits(TRPCWebSocketClosedError, _Error);
+
+  var _super = /*#__PURE__*/_createSuper(TRPCWebSocketClosedError);
+
+  function TRPCWebSocketClosedError(message) {
+    var _this;
+
+    _classCallCheck(this, TRPCWebSocketClosedError);
+
+    _this = _super.call(this, message);
+    _this.name = 'TRPCWebSocketClosedError';
+    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCWebSocketClosedError.prototype);
+    return _this;
+  }
+
+  return _createClass(TRPCWebSocketClosedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
+  _inherits(TRPCSubscriptionEndedError, _Error2);
+
+  var _super2 = /*#__PURE__*/_createSuper(TRPCSubscriptionEndedError);
+
+  function TRPCSubscriptionEndedError(message) {
+    var _this2;
+
+    _classCallCheck(this, TRPCSubscriptionEndedError);
+
+    _this2 = _super2.call(this, message);
+    _this2.name = 'TRPCSubscriptionEndedError';
+    Object.setPrototypeOf(_assertThisInitialized(_this2), TRPCSubscriptionEndedError.prototype);
+    return _this2;
+  }
+
+  return _createClass(TRPCSubscriptionEndedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+function wsLink(opts) {
+  // initialized config
+  return function (rt) {
+    var client = opts.client;
+    return function (_ref2) {
+      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;
+            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();
+      });
+    };
+  };
+}
+
+export { createWSClient, wsLink };

package/observable/dist/trpc-client-rx.cjs.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/declarations/src/rx/index";

package/observable/dist/trpc-client-rx.cjs.dev.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var observable = require('../../dist/observable-9aad8c3e.cjs.dev.js');
+
+
+
+exports.observable = observable.observable;

package/observable/dist/trpc-client-rx.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./trpc-client-rx.cjs.prod.js");
+} else {
+  module.exports = require("./trpc-client-rx.cjs.dev.js");
+}

package/observable/dist/trpc-client-rx.cjs.prod.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var observable = require('../../dist/observable-ccb54234.cjs.prod.js');
+
+
+
+exports.observable = observable.observable;

package/observable/dist/trpc-client-rx.esm.js

@@ -0,0 +1 @@
+export { o as observable } from '../../dist/observable-01534ea8.esm.js';

package/observable/index.d.ts

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

package/observable/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "10.0.0-alpha.16",
+  "version": "10.0.0-alpha.19",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -19,45 +19,10 @@
       "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/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"
-    },
-    "./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"
+    "./observable": {
+      "import": "./dist/observable/index.mjs",
+      "require": "./dist/observable/index.js",
+      "default": "./dist/observable/index.js"
     }
   },
   "files": [
@@ -65,7 +30,7 @@
     "dist",
     "links",
     "src",
-    "rx"
+    "observable"
   ],
   "scripts": {
     "build": "rollup -c"
@@ -74,13 +39,13 @@
     "@babel/runtime": "^7.9.0"
   },
   "peerDependencies": {
-    "@trpc/server": "10.0.0-alpha.16"
+    "@trpc/server": "10.0.0-alpha.19"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.16"
+    "@trpc/server": "10.0.0-alpha.19"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "08a4af55145d079964f6698130223ebe9b9bed6b"
+  "gitHead": "cfb85708a9f7de78abd78453fe459718dbb18d0a"
 }

package/src/TRPCClientError.ts

@@ -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>;
       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';

package/src/internals/TRPCClient.ts

@@ -8,7 +8,7 @@ import {
 import { TRPCResult } from '@trpc/server/rpc';
 import { CancelFn } from '..';
 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 {
@@ -18,10 +18,12 @@ import {
   OperationLink,
   TRPCLink,
 } from '../links/types';
-import { Unsubscribable } from '../observable';
-import { inferObservableValue } from '../observable/observable';
-import { share } from '../observable/operators';
-import { Observer } from '../observable/types';
+import {
+  inferObservableValue,
+  Observer,
+  share,
+  Unsubscribable,
+} from '../observable';
 import { observableToPromise } from '../observable/internals/observableToPromise';
 import { TRPCClientError } from '../TRPCClientError';
 import { getAbortController } from './fetchHelpers';
@@ -30,13 +32,6 @@ 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;

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 '../observable/observable';
+import { observable } from '../observable';
 import { dedupeLink } from './dedupeLink';
 import { createChain } from './internals/createChain';
 

package/src/links/dedupeLink.ts

@@ -1,6 +1,5 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../observable/observable';
-import { share } from '../observable/operators';
+import { observable, share } from '../observable';
 import { Observable } from '../observable/types';
 import { TRPCLink } from './types';
 

package/src/links/httpBatchLink.ts

@@ -1,12 +1,12 @@
 import { AnyRouter, ProcedureType } from '@trpc/server';
 import { dataLoader } from '../internals/dataLoader';
-import { observable } from '../observable/observable';
-import { TRPCLink } from './types';
+import { observable } from '../observable';
 import {
   HTTPLinkOptions,
   httpRequest,
   ResponseShape,
 } from './internals/httpUtils';
+import { TRPCLink } from './types';
 
 export interface HttpBatchLinkOptions extends HTTPLinkOptions {
   maxBatchSize?: number;

package/src/links/httpLink.ts

@@ -1,7 +1,7 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../observable/observable';
-import { TRPCLink } from './types';
+import { observable } from '../observable';
 import { HTTPLinkOptions, httpRequest } from './internals/httpUtils';
+import { TRPCLink } from './types';
 
 export function httpLink<TRouter extends AnyRouter>(
   opts: HTTPLinkOptions,

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

@@ -1,6 +1,6 @@
 import { AnyRouter } from '@trpc/server/src';
+import { observable } from '../../observable';
 import { createChain } from './createChain';
-import { observable } from '../../observable/observable';
 
 describe('chain', () => {
   test('trivial', () => {

package/src/links/loggerLink.ts

@@ -1,7 +1,6 @@
 import { AnyRouter } from '@trpc/server';
 import { TRPCClientError } from '..';
-import { observable } from '../observable/observable';
-import { tap } from '../observable/operators';
+import { observable, tap } from '../observable';
 import { Operation, OperationResult, TRPCLink } from './types';
 
 type ConsoleEsque = {

package/src/links/splitLink.test.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
 import { AnyRouter } from '../../../server/src';
 import { createChain } from '../links/internals/createChain';
-import { splitLink } from '../links/splitLink';
-import { OperationLink, TRPCLink } from '../links/types';
+import { splitLink } from '../';
+import { OperationLink, TRPCLink } from '../';
 import { observable } from '../observable';
 
 test('splitLink', () => {

package/src/links/splitLink.ts

@@ -1,7 +1,7 @@
 import { AnyRouter } from '@trpc/server';
-import { observable } from '../observable/observable';
-import { TRPCLink, Operation } from './types';
+import { observable } from '../observable';
 import { createChain } from './internals/createChain';
+import { Operation, TRPCLink } from './types';
 
 function asArray<T>(value: T | T[]) {
   return Array.isArray(value) ? value : [value];