@trpc/client 10.0.0-alpha.25 → 10.0.0-alpha.26

package/dist/wsLink-9468a563.mjs

@@ -0,0 +1,436 @@
+import _createClass from '@babel/runtime/helpers/createClass';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
+import { observable } from '@trpc/server/observable';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var TRPCClientError = /*#__PURE__*/function (_Error) {
+  _inherits(TRPCClientError, _Error);
+
+  var _super = /*#__PURE__*/_createSuper$1(TRPCClientError);
+
+  function TRPCClientError(message, opts) {
+    var _opts$result, _opts$result2;
+
+    var _this;
+
+    _classCallCheck(this, TRPCClientError);
+
+    var cause = opts === null || opts === void 0 ? void 0 : opts.cause; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore https://github.com/tc39/proposal-error-cause
+
+    _this = _super.call(this, message, {
+      cause: cause
+    });
+    _this.cause = void 0;
+    _this.shape = void 0;
+    _this.data = void 0;
+    _this.meta = void 0;
+    _this.meta = opts === null || opts === void 0 ? void 0 : opts.meta;
+    _this.cause = cause;
+    _this.shape = opts === null || opts === void 0 ? void 0 : (_opts$result = opts.result) === null || _opts$result === void 0 ? void 0 : _opts$result.error;
+    _this.data = opts === null || opts === void 0 ? void 0 : (_opts$result2 = opts.result) === null || _opts$result2 === void 0 ? void 0 : _opts$result2.error.data;
+    _this.name = 'TRPCClientError';
+    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCClientError.prototype);
+    return _this;
+  }
+
+  _createClass(TRPCClientError, null, [{
+    key: "from",
+    value: function from(cause) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (!(cause instanceof Error)) {
+        var _message;
+
+        return new TRPCClientError((_message = cause.error.message) !== null && _message !== void 0 ? _message : '', _objectSpread(_objectSpread({}, opts), {}, {
+          cause: undefined,
+          result: cause
+        }));
+      }
+
+      if (cause.name === 'TRPCClientError') {
+        return cause;
+      }
+
+      return new TRPCClientError(cause.message, _objectSpread(_objectSpread({}, opts), {}, {
+        cause: cause,
+        result: null
+      }));
+    }
+  }]);
+
+  return TRPCClientError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+/* istanbul ignore next */
+var retryDelay = function retryDelay(attemptIndex) {
+  return attemptIndex === 0 ? 0 : Math.min(1000 * Math.pow(2, attemptIndex), 30000);
+};
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+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 WebSocketImpl(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(data) {
+      var _req$callbacks$next, _req$callbacks;
+
+      var req = data.id !== null && pendingRequests[data.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 (req.ws !== activeConnection && conn === activeConnection) {
+        var oldWs = req.ws; // gracefully replace old connection with this
+
+        req.ws = activeConnection;
+        closeIfNoPending(oldWs);
+      }
+
+      if ('result' in data && data.result.type === 'stopped' && conn === activeConnection) {
+        req.callbacks.complete();
+      }
+    };
+
+    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$error, _req$callbacks2;
+
+        var req = pendingRequests[key];
+
+        if (req.ws !== conn) {
+          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')));
+
+        if (req.type !== 'subscription') {
+          var _req$callbacks$comple, _req$callbacks3;
+
+          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);
+        } 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,
+      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$complete;
+
+      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);
+
+      if (op.type === 'subscription') {
+        outgoing.push({
+          id: id,
+          method: 'subscription.stop'
+        });
+        dispatch();
+      }
+    };
+  }
+
+  return {
+    close: function close() {
+      state = 'closed';
+      closeIfNoPending(activeConnection);
+      clearTimeout(connectTimer);
+      connectTimer = null;
+    },
+    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) {
+  return function (runtime) {
+    var client = opts.client;
+    return function (_ref2) {
+      var op = _ref2.op;
+      return observable(function (observer) {
+        var type = op.type,
+            path = op.path,
+            id = op.id,
+            context = op.context;
+        var input = runtime.transformer.serialize(op.input);
+        var isDone = false;
+        var unsub = client.request({
+          type: type,
+          path: path,
+          input: input,
+          id: id,
+          context: context
+        }, {
+          error: function error(err) {
+            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 () {
+          isDone = true;
+          unsub();
+        };
+      });
+    };
+  };
+}
+
+export { TRPCClientError as T, createWSClient as c, wsLink as w };

package/links/httpBatchLink/index.d.ts

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

package/links/httpBatchLink/index.js

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

package/links/httpLink/index.d.ts

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

package/links/httpLink/index.js

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

package/links/loggerLink/index.d.ts

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

package/links/loggerLink/index.js

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

package/links/splitLink/index.d.ts

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

package/links/splitLink/index.js

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

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.25",
+  "version": "10.0.0-alpha.26",
   "description": "tRPC Client lib",
   "author": "KATT",
   "license": "MIT",
@@ -26,6 +26,31 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./links/httpLink": {
+      "import": "./dist/links/httpLink.mjs",
+      "require": "./dist/links/httpLink.js",
+      "default": "./dist/links/httpLink.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/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"
     }
   },
   "files": [
@@ -35,19 +60,20 @@
     "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.25"
+    "@trpc/server": "10.0.0-alpha.26"
   },
   "devDependencies": {
-    "@trpc/server": "10.0.0-alpha.25"
+    "@trpc/server": "10.0.0-alpha.26"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7f35cc8aaf813e5f83fe3d7b8f4bfd851779aa99"
+  "gitHead": "412d2ba0d5f857e7f7d2e0fd3af6f1334e4f108a"
 }

package/src/TRPCClientError.ts

@@ -20,7 +20,7 @@ export class TRPCClientError<TRouter extends AnyRouter>
     message: string,
     opts?: {
       result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
-      cause?: Maybe<Error>;
+      cause?: Error;
       meta?: Record<string, unknown>;
     },
   ) {
@@ -47,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/internals/TRPCClient.ts

@@ -61,6 +61,14 @@ interface CreateTRPCClientBaseOptions {
   transformer?: ClientDataTransformerOptions;
 }
 
+function createRouterProxy(callback: (...args: [string, ...unknown[]]) => any) {
+  return new Proxy({} as any, {
+    get(_, path: string) {
+      return (...args: unknown[]) => callback(path, ...args);
+    },
+  });
+}
+
 /** @internal */
 export interface CreateTRPCClientWithURLOptions
   extends CreateTRPCClientBaseOptions {
@@ -94,6 +102,8 @@ export type CreateTRPCClientOptions<TRouter extends AnyRouter> =
 export class TRPCClient<TRouter extends AnyRouter> {
   private readonly links: OperationLink<TRouter>[];
   public readonly runtime: TRPCClientRuntime;
+  public readonly queries: TRouter['queries'];
+  public readonly mutations: TRouter['mutations'];
 
   constructor(opts: CreateTRPCClientOptions<TRouter>) {
     const _fetch = getFetch(opts?.fetch);
@@ -135,6 +145,13 @@ export class TRPCClient<TRouter extends AnyRouter> {
         })(this.runtime),
       ];
     }
+
+    this.queries = createRouterProxy((path, ...args) =>
+      this.query(path, ...(args as any)),
+    );
+    this.mutations = createRouterProxy((path, ...args) =>
+      this.mutation(path, ...(args as any)),
+    );
   }
 
   private $request<TInput = unknown, TOutput = unknown>({

package/src/links/types.ts

@@ -16,7 +16,7 @@ export type Operation<TInput = unknown> = {
   type: 'query' | 'mutation' | 'subscription';
   input: TInput;
   path: string;
-  context?: OperationContext;
+  context: OperationContext;
 };
 
 export type HTTPHeaders = Record<string, string | string[]>;

package/src/links/wsLink.ts

@@ -13,7 +13,7 @@ import { Operation, OperationResultObserver, TRPCLink } from './types';
 
 export interface WebSocketClientOptions {
   url: string;
-  WebSocket?: WebSocket;
+  WebSocket?: typeof WebSocket;
   retryDelayMs?: typeof retryDelay;
 }
 export function createWSClient(opts: WebSocketClientOptions) {
@@ -112,7 +112,7 @@ export function createWSClient(opts: WebSocketClientOptions) {
   }
 
   function createWS() {
-    const conn = new WebSocket(url);
+    const conn = new WebSocketImpl(url);
     clearTimeout(connectTimer as any);
     connectTimer = null;
 

package/links/httpBatchLink/dist/trpc-client-links-httpBatchLink.cjs.d.ts

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