@trpc/client 10.0.0-alpha.28 → 10.0.0-alpha.30

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

@@ -0,0 +1,280 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+var _regeneratorRuntime = require('@babel/runtime/regenerator');
+require('@babel/runtime/helpers/classCallCheck');
+require('@babel/runtime/helpers/createClass');
+var TRPCClientError = require('../../../dist/TRPCClientError-e9bf96e9.cjs.prod.js');
+var transformRPCResponse = require('../../../dist/transformRPCResponse-2b5b4bba.cjs.prod.js');
+var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
+require('@babel/runtime/helpers/assertThisInitialized');
+require('@babel/runtime/helpers/inherits');
+require('@babel/runtime/helpers/createSuper');
+require('@babel/runtime/helpers/wrapNativeSuper');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _regeneratorRuntime__default = /*#__PURE__*/_interopDefault(_regeneratorRuntime);
+
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * 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
+ */
+function dataLoader(fetchMany, opts) {
+  var batch = null;
+  var dispatchTimer = null;
+
+  var destroyTimerAndBatch = function destroyTimerAndBatch() {
+    clearTimeout(dispatchTimer);
+    dispatchTimer = null;
+    batch = null;
+  };
+
+  function dispatch() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var batchCopy = batch;
+    destroyTimerAndBatch();
+
+    var _fetchMany = fetchMany(batchCopy.items.map(function (v) {
+      return v.key;
+    })),
+        promise = _fetchMany.promise,
+        cancel = _fetchMany.cancel;
+
+    batchCopy.cancel = cancel;
+    promise.then(function (result) {
+      for (var i = 0; i < result.length; i++) {
+        var _value = result[i];
+        batchCopy.items[i].resolve(_value);
+      }
+    }).catch(function (cause) {
+      var _iterator = _createForOfIteratorHelper(batchCopy.items),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          item.reject(cause);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    });
+  }
+
+  function load(key) {
+    var batchItem = {
+      cancelled: false,
+      key: key
+    };
+
+    if (!batch) {
+      batch = {
+        items: [],
+        cancel: function cancel() {
+          destroyTimerAndBatch();
+        }
+      };
+    }
+
+    var thisBatch = batch;
+    var promise = new Promise(function (resolve, reject) {
+      var item = batchItem;
+      item.reject = reject;
+      item.resolve = resolve;
+      thisBatch.items.push(item);
+
+      if (typeof (opts === null || opts === void 0 ? void 0 : opts.maxBatchSize) !== 'undefined' && thisBatch.items.length >= opts.maxBatchSize) {
+        dispatch();
+        return;
+      }
+    });
+
+    if (!dispatchTimer) {
+      dispatchTimer = setTimeout(dispatch);
+    }
+
+    var cancel = function cancel() {
+      batchItem.cancelled = true;
+
+      if (thisBatch.items.some(function (item) {
+        return !item.cancelled;
+      })) {
+        // there are still things that can be resolved
+        return;
+      }
+
+      thisBatch.cancel();
+    };
+
+    return {
+      promise: promise,
+      cancel: cancel
+    };
+  }
+
+  return {
+    load: load
+  };
+}
+
+function httpBatchLink(opts) {
+  var url = opts.url,
+      maxBatchSize = opts.maxBatchSize; // initialized config
+
+  return function (runtime) {
+    // initialized in app
+    var getHeaders = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(arg1) {
+        var val;
+        return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                val = opts.headers;
+                _context.t0 = _objectSpread;
+                _context.t1 = _objectSpread;
+                _context.t2 = {};
+                _context.next = 6;
+                return runtime.headers();
+
+              case 6:
+                _context.t3 = _context.sent;
+                _context.t4 = (0, _context.t1)(_context.t2, _context.t3);
+
+                if (!(typeof val === 'function')) {
+                  _context.next = 14;
+                  break;
+                }
+
+                _context.next = 11;
+                return val(arg1);
+
+              case 11:
+                _context.t5 = _context.sent;
+                _context.next = 15;
+                break;
+
+              case 14:
+                _context.t5 = val;
+
+              case 15:
+                _context.t6 = _context.t5;
+                return _context.abrupt("return", (0, _context.t0)(_context.t4, _context.t6));
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function getHeaders(_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    var fetcher = function fetcher(type) {
+      return function (pairs) {
+        var _opts$fetch, _opts$AbortController;
+
+        var path = pairs.map(function (op) {
+          return op.path;
+        }).join(',');
+        var inputs = pairs.map(function (op) {
+          return op.input;
+        });
+
+        var _httpRequest = transformRPCResponse.httpRequest({
+          url: url,
+          inputs: inputs,
+          path: path,
+          type: type,
+          fetch: transformRPCResponse.getFetch((_opts$fetch = opts.fetch) !== null && _opts$fetch !== void 0 ? _opts$fetch : runtime.fetch),
+          AbortController: transformRPCResponse.getAbortController((_opts$AbortController = opts.AbortController) !== null && _opts$AbortController !== void 0 ? _opts$AbortController : runtime.AbortController),
+          headers: function headers() {
+            return getHeaders({
+              operations: pairs
+            });
+          },
+          transformer: runtime.transformer
+        }),
+            promise = _httpRequest.promise,
+            cancel = _httpRequest.cancel;
+
+        return {
+          promise: promise.then(function (res) {
+            if (!Array.isArray(res)) {
+              return pairs.map(function () {
+                return res;
+              });
+            }
+
+            return res;
+          }),
+          cancel: cancel
+        };
+      };
+    };
+
+    var query = dataLoader(fetcher('query'), {
+      maxBatchSize: maxBatchSize
+    });
+    var mutation = dataLoader(fetcher('mutation'), {
+      maxBatchSize: maxBatchSize
+    });
+    var subscription = dataLoader(fetcher('subscription'), {
+      maxBatchSize: maxBatchSize
+    });
+    var loaders = {
+      query: query,
+      subscription: subscription,
+      mutation: mutation
+    };
+    return function (_ref2) {
+      var op = _ref2.op,
+          prev = _ref2.prev,
+          onDestroy = _ref2.onDestroy;
+      var loader = loaders[op.type];
+
+      var _loader$load = loader.load(op),
+          promise = _loader$load.promise,
+          cancel = _loader$load.cancel;
+
+      var isDone = false;
+
+      var prevOnce = function prevOnce(result) {
+        if (isDone) {
+          return;
+        }
+
+        isDone = true;
+        prev(result);
+      };
+
+      onDestroy(function () {
+        prevOnce(TRPCClientError.TRPCClientError.from(new transformRPCResponse.TRPCAbortError(), {
+          isDone: true
+        }));
+        cancel();
+      });
+      promise.then(function (envelope) {
+        prevOnce(transformRPCResponse.transformRPCResponse({
+          envelope: envelope,
+          runtime: runtime
+        }));
+      }).catch(function (cause) {
+        prevOnce(TRPCClientError.TRPCClientError.from(cause));
+      });
+    };
+  };
+}
+
+exports.httpBatchLink = httpBatchLink;

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

@@ -0,0 +1,272 @@
+import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
+import _asyncToGenerator from '@babel/runtime/helpers/esm/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import '@babel/runtime/helpers/classCallCheck';
+import '@babel/runtime/helpers/createClass';
+import { T as TRPCClientError } from '../../../dist/TRPCClientError-09b8a26b.esm.js';
+import { T as TRPCAbortError, t as transformRPCResponse, h as httpRequest, g as getFetch, a as getAbortController } from '../../../dist/transformRPCResponse-648d57f1.esm.js';
+import _createForOfIteratorHelper from '@babel/runtime/helpers/esm/createForOfIteratorHelper';
+import '@babel/runtime/helpers/assertThisInitialized';
+import '@babel/runtime/helpers/inherits';
+import '@babel/runtime/helpers/createSuper';
+import '@babel/runtime/helpers/wrapNativeSuper';
+
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * 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
+ */
+function dataLoader(fetchMany, opts) {
+  var batch = null;
+  var dispatchTimer = null;
+
+  var destroyTimerAndBatch = function destroyTimerAndBatch() {
+    clearTimeout(dispatchTimer);
+    dispatchTimer = null;
+    batch = null;
+  };
+
+  function dispatch() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    var batchCopy = batch;
+    destroyTimerAndBatch();
+
+    var _fetchMany = fetchMany(batchCopy.items.map(function (v) {
+      return v.key;
+    })),
+        promise = _fetchMany.promise,
+        cancel = _fetchMany.cancel;
+
+    batchCopy.cancel = cancel;
+    promise.then(function (result) {
+      for (var i = 0; i < result.length; i++) {
+        var _value = result[i];
+        batchCopy.items[i].resolve(_value);
+      }
+    }).catch(function (cause) {
+      var _iterator = _createForOfIteratorHelper(batchCopy.items),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          item.reject(cause);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    });
+  }
+
+  function load(key) {
+    var batchItem = {
+      cancelled: false,
+      key: key
+    };
+
+    if (!batch) {
+      batch = {
+        items: [],
+        cancel: function cancel() {
+          destroyTimerAndBatch();
+        }
+      };
+    }
+
+    var thisBatch = batch;
+    var promise = new Promise(function (resolve, reject) {
+      var item = batchItem;
+      item.reject = reject;
+      item.resolve = resolve;
+      thisBatch.items.push(item);
+
+      if (typeof (opts === null || opts === void 0 ? void 0 : opts.maxBatchSize) !== 'undefined' && thisBatch.items.length >= opts.maxBatchSize) {
+        dispatch();
+        return;
+      }
+    });
+
+    if (!dispatchTimer) {
+      dispatchTimer = setTimeout(dispatch);
+    }
+
+    var cancel = function cancel() {
+      batchItem.cancelled = true;
+
+      if (thisBatch.items.some(function (item) {
+        return !item.cancelled;
+      })) {
+        // there are still things that can be resolved
+        return;
+      }
+
+      thisBatch.cancel();
+    };
+
+    return {
+      promise: promise,
+      cancel: cancel
+    };
+  }
+
+  return {
+    load: load
+  };
+}
+
+function httpBatchLink(opts) {
+  var url = opts.url,
+      maxBatchSize = opts.maxBatchSize; // initialized config
+
+  return function (runtime) {
+    // initialized in app
+    var getHeaders = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(arg1) {
+        var val;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                val = opts.headers;
+                _context.t0 = _objectSpread;
+                _context.t1 = _objectSpread;
+                _context.t2 = {};
+                _context.next = 6;
+                return runtime.headers();
+
+              case 6:
+                _context.t3 = _context.sent;
+                _context.t4 = (0, _context.t1)(_context.t2, _context.t3);
+
+                if (!(typeof val === 'function')) {
+                  _context.next = 14;
+                  break;
+                }
+
+                _context.next = 11;
+                return val(arg1);
+
+              case 11:
+                _context.t5 = _context.sent;
+                _context.next = 15;
+                break;
+
+              case 14:
+                _context.t5 = val;
+
+              case 15:
+                _context.t6 = _context.t5;
+                return _context.abrupt("return", (0, _context.t0)(_context.t4, _context.t6));
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function getHeaders(_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    var fetcher = function fetcher(type) {
+      return function (pairs) {
+        var _opts$fetch, _opts$AbortController;
+
+        var path = pairs.map(function (op) {
+          return op.path;
+        }).join(',');
+        var inputs = pairs.map(function (op) {
+          return op.input;
+        });
+
+        var _httpRequest = httpRequest({
+          url: url,
+          inputs: inputs,
+          path: path,
+          type: type,
+          fetch: getFetch((_opts$fetch = opts.fetch) !== null && _opts$fetch !== void 0 ? _opts$fetch : runtime.fetch),
+          AbortController: getAbortController((_opts$AbortController = opts.AbortController) !== null && _opts$AbortController !== void 0 ? _opts$AbortController : runtime.AbortController),
+          headers: function headers() {
+            return getHeaders({
+              operations: pairs
+            });
+          },
+          transformer: runtime.transformer
+        }),
+            promise = _httpRequest.promise,
+            cancel = _httpRequest.cancel;
+
+        return {
+          promise: promise.then(function (res) {
+            if (!Array.isArray(res)) {
+              return pairs.map(function () {
+                return res;
+              });
+            }
+
+            return res;
+          }),
+          cancel: cancel
+        };
+      };
+    };
+
+    var query = dataLoader(fetcher('query'), {
+      maxBatchSize: maxBatchSize
+    });
+    var mutation = dataLoader(fetcher('mutation'), {
+      maxBatchSize: maxBatchSize
+    });
+    var subscription = dataLoader(fetcher('subscription'), {
+      maxBatchSize: maxBatchSize
+    });
+    var loaders = {
+      query: query,
+      subscription: subscription,
+      mutation: mutation
+    };
+    return function (_ref2) {
+      var op = _ref2.op,
+          prev = _ref2.prev,
+          onDestroy = _ref2.onDestroy;
+      var loader = loaders[op.type];
+
+      var _loader$load = loader.load(op),
+          promise = _loader$load.promise,
+          cancel = _loader$load.cancel;
+
+      var isDone = false;
+
+      var prevOnce = function prevOnce(result) {
+        if (isDone) {
+          return;
+        }
+
+        isDone = true;
+        prev(result);
+      };
+
+      onDestroy(function () {
+        prevOnce(TRPCClientError.from(new TRPCAbortError(), {
+          isDone: true
+        }));
+        cancel();
+      });
+      promise.then(function (envelope) {
+        prevOnce(transformRPCResponse({
+          envelope: envelope,
+          runtime: runtime
+        }));
+      }).catch(function (cause) {
+        prevOnce(TRPCClientError.from(cause));
+      });
+    };
+  };
+}
+
+export { httpBatchLink };

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

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

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

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+var _regeneratorRuntime = require('@babel/runtime/regenerator');
+require('@babel/runtime/helpers/classCallCheck');
+require('@babel/runtime/helpers/createClass');
+var TRPCClientError = require('../../../dist/TRPCClientError-bfee2bf5.cjs.dev.js');
+var transformRPCResponse = require('../../../dist/transformRPCResponse-c6cc4677.cjs.dev.js');
+require('@babel/runtime/helpers/createForOfIteratorHelper');
+require('@babel/runtime/helpers/assertThisInitialized');
+require('@babel/runtime/helpers/inherits');
+require('@babel/runtime/helpers/createSuper');
+require('@babel/runtime/helpers/wrapNativeSuper');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _regeneratorRuntime__default = /*#__PURE__*/_interopDefault(_regeneratorRuntime);
+
+function httpLink(opts) {
+  var url = opts.url; // initialized config
+
+  return function (runtime) {
+    // initialized in app
+    var getHeaders = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime__default['default'].mark(function _callee(arg1) {
+        var val;
+        return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                val = opts.headers;
+                _context.t0 = _objectSpread;
+                _context.t1 = _objectSpread;
+                _context.t2 = {};
+                _context.next = 6;
+                return runtime.headers();
+
+              case 6:
+                _context.t3 = _context.sent;
+                _context.t4 = (0, _context.t1)(_context.t2, _context.t3);
+
+                if (!(typeof val === 'function')) {
+                  _context.next = 14;
+                  break;
+                }
+
+                _context.next = 11;
+                return val(arg1);
+
+              case 11:
+                _context.t5 = _context.sent;
+                _context.next = 15;
+                break;
+
+              case 14:
+                _context.t5 = val;
+
+              case 15:
+                _context.t6 = _context.t5;
+                return _context.abrupt("return", (0, _context.t0)(_context.t4, _context.t6));
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function getHeaders(_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    return function (_ref2) {
+      var _opts$fetch, _opts$AbortController;
+
+      var op = _ref2.op,
+          prev = _ref2.prev,
+          onDestroy = _ref2.onDestroy;
+      var path = op.path,
+          input = op.input,
+          type = op.type;
+
+      var _httpRequest = transformRPCResponse.httpRequest({
+        type: type,
+        input: input,
+        url: url,
+        path: path,
+        transformer: runtime.transformer,
+        fetch: transformRPCResponse.getFetch((_opts$fetch = opts.fetch) !== null && _opts$fetch !== void 0 ? _opts$fetch : runtime.fetch),
+        AbortController: transformRPCResponse.getAbortController((_opts$AbortController = opts.AbortController) !== null && _opts$AbortController !== void 0 ? _opts$AbortController : runtime.AbortController),
+        headers: function headers() {
+          return getHeaders({
+            op: op
+          });
+        }
+      }),
+          promise = _httpRequest.promise,
+          cancel = _httpRequest.cancel;
+
+      var isDone = false;
+
+      var prevOnce = function prevOnce(result) {
+        if (isDone) {
+          return;
+        }
+
+        isDone = true;
+        prev(result);
+      };
+
+      onDestroy(function () {
+        prevOnce(TRPCClientError.TRPCClientError.from(new transformRPCResponse.TRPCAbortError(), {
+          isDone: true
+        }));
+        cancel();
+      });
+      promise.then(function (envelope) {
+        prevOnce(transformRPCResponse.transformRPCResponse({
+          envelope: envelope,
+          runtime: runtime
+        }));
+      }).catch(function (cause) {
+        prevOnce(TRPCClientError.TRPCClientError.from(cause));
+      });
+    };
+  };
+}
+
+exports.httpLink = httpLink;

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

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