@trpc/client 10.0.0-alpha.8 → 10.0.0-proxy-alpha.53

package/dist/index.js

@@ -2,313 +2,293 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
+var observable = require('@trpc/server/observable');
+var transformResult = require('./transformResult-e15ccdf6.js');
 var links_httpBatchLink = require('./links/httpBatchLink.js');
-var createChain = require('./createChain-864dbb30.js');
-var TRPCClientError = require('./TRPCClientError-ec6bd2ca.js');
-var share = require('./share-4d79dc49.js');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
-var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
-require('./observable-85669100.js');
-require('./httpUtils-1f9e4e3c.js');
-require('@babel/runtime/helpers/defineProperty');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
-var _wrapNativeSuper__default = /*#__PURE__*/_interopDefaultLegacy(_wrapNativeSuper);
+var links_splitLink = require('./splitLink-695ae288.js');
+var shared = require('@trpc/server/shared');
+var links_httpLink = require('./links/httpLink.js');
+var links_loggerLink = require('./links/loggerLink.js');
+var links_wsLink = require('./links/wsLink.js');
+require('./httpUtils-801112a6.js');
 
 function getWindow() {
-  if (typeof window !== 'undefined') {
-    return window;
-  }
-
-  return global;
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    return global;
 }
 function getAbortController(ac) {
-  var win = getWindow();
-  return ac || win.AbortController || null;
+    const win = getWindow();
+    return (ac ?? win.AbortController) ?? undefined;
 }
 
 function getFetch(f) {
-  if (f) {
-    return f;
-  }
-
-  var win = getWindow();
-
-  if (win.fetch) {
-    return typeof win.fetch.bind === 'function' ? win.fetch.bind(win) : win.fetch;
-  }
-
-  throw new Error('No fetch implementation found');
-}
-
-/** @internal */
-function transformOperationResult(result) {
-  var context = result.context;
-
-  if ('error' in result.data) {
-    var error = TRPCClientError.TRPCClientError.from(result.data);
-    return {
-      ok: false,
-      error: error,
-      context: context
-    };
-  }
-
-  var data = result.data.result.data;
-  return {
-    ok: true,
-    data: data,
-    context: context
-  };
-}
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](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; } }
-
-var ObservableAbortError = /*#__PURE__*/function (_Error) {
-  _inherits__default["default"](ObservableAbortError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(ObservableAbortError);
-
-  function ObservableAbortError(message) {
-    var _this;
-
-    _classCallCheck__default["default"](this, ObservableAbortError);
-
-    _this = _super.call(this, message);
-    _this.name = 'ObservableAbortError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), ObservableAbortError.prototype);
-    return _this;
-  }
-
-  return _createClass__default["default"](ObservableAbortError);
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
-/** @internal */
-
-function observableToPromise(observable) {
-  var abort;
-  var promise = new Promise(function (resolve, reject) {
-    var isDone = false;
-
-    function onDone() {
-      if (isDone) {
-        return;
-      }
-
-      isDone = true;
-      reject(new ObservableAbortError('This operation was cancelled.'));
-      obs$.unsubscribe();
+    if (f) {
+        return f;
     }
-
-    var obs$ = observable.subscribe({
-      next: function next(data) {
-        isDone = true;
-        resolve(data);
-        onDone();
-      },
-      error: function error(data) {
-        isDone = true;
-        reject(data);
-        onDone();
-      },
-      complete: function complete() {
-        isDone = true;
-        onDone();
-      }
-    });
-    abort = onDone;
-  });
-  return {
-    promise: promise,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    abort: abort
-  };
+    const win = getWindow();
+    if (win.fetch) {
+        return typeof win.fetch.bind === 'function' ? win.fetch.bind(win) : win.fetch;
+    }
+    throw new Error('No fetch implementation found');
 }
 
-var idCounter = 0;
-
-function getRequestId() {
-  return ++idCounter;
+function dedupeLink() {
+    // initialized config
+    return ()=>{
+        // initialized in app
+        const pending = {};
+        return ({ op , next  })=>{
+            // initialized for request
+            if (op.type !== 'query') {
+                // pass through
+                return next(op);
+            }
+            const key = JSON.stringify([
+                op.path,
+                op.input
+            ]);
+            const obs$ = pending[key];
+            if (obs$) {
+                // console.log('hooking into pending', { op });
+                return observable.observable((observer)=>obs$.subscribe(observer));
+            }
+            const shared$ = observable.observable((observer)=>{
+                function reset() {
+                    delete pending[key];
+                }
+                const subscription = next(op).subscribe({
+                    next (v) {
+                        observer.next(v);
+                    },
+                    error (e) {
+                        reset();
+                        observer.error(e);
+                    },
+                    complete () {
+                        reset();
+                        observer.complete();
+                    }
+                });
+                return ()=>{
+                    reset();
+                    subscription.unsubscribe();
+                };
+            }).pipe(observable.share());
+            pending[key] = shared$;
+            return shared$;
+        };
+    };
 }
 
-var TRPCClient = /*#__PURE__*/function () {
-  function TRPCClient(opts) {
-    var _this = this;
-
-    _classCallCheck__default["default"](this, TRPCClient);
-
-    this.links = void 0;
-    this.runtime = void 0;
-
-    var _fetch = getFetch(opts === null || opts === void 0 ? void 0 : opts.fetch);
-
-    var AC = getAbortController(opts === null || opts === void 0 ? void 0 : opts.AbortController);
-
-    function getHeadersFn() {
-      if (opts.headers) {
-        var headers = opts.headers;
-        return typeof headers === 'function' ? headers : function () {
-          return headers;
+function retryLink(opts) {
+    // initialized config
+    return ()=>{
+        // initialized in app
+        return ({ op , next  })=>{
+            // initialized for request
+            return observable.observable((observer)=>{
+                let next$ = null;
+                let attempts = 0;
+                let isDone = false;
+                function attempt() {
+                    attempts++;
+                    next$?.unsubscribe();
+                    next$ = next(op).subscribe({
+                        error (error) {
+                            if (attempts >= opts.attempts) {
+                                observer.error(error);
+                                return;
+                            }
+                            attempt();
+                        },
+                        next (result) {
+                            if ('result' in result.result) {
+                                isDone = true;
+                                observer.next(result);
+                                return;
+                            }
+                            if (attempts >= opts.attempts) {
+                                isDone = true;
+                                observer.next(result);
+                                return;
+                            }
+                            attempt();
+                        },
+                        complete () {
+                            if (isDone) {
+                                observer.complete();
+                            }
+                        }
+                    });
+                }
+                attempt();
+                return ()=>{
+                    isDone = true;
+                    next$?.unsubscribe();
+                };
+            });
         };
-      }
-
-      return function () {
-        return {};
-      };
-    }
-
-    this.runtime = {
-      AbortController: AC,
-      fetch: _fetch,
-      headers: getHeadersFn()
     };
+}
 
-    if ('links' in opts) {
-      this.links = opts.links.map(function (link) {
-        return link(_this.runtime);
-      });
-    } else {
-      this.links = [links_httpBatchLink.httpBatchLink({
-        url: opts.url
-      })(this.runtime)];
+class TRPCClient {
+    getRequestId() {
+        return ++this.requestId;
     }
-  }
-
-  _createClass__default["default"](TRPCClient, [{
-    key: "$request",
-    value: function $request(_ref) {
-      var type = _ref.type,
-          input = _ref.input,
-          path = _ref.path,
-          _ref$context = _ref.context,
-          context = _ref$context === void 0 ? {} : _ref$context;
-      var chain$ = createChain.createChain({
-        links: this.links,
-        op: {
-          id: getRequestId(),
-          type: type,
-          path: path,
-          input: input,
-          context: context
-        }
-      });
-      return chain$.pipe(share.share());
+    $request({ type , input , path , context ={}  }) {
+        const chain$ = links_splitLink.createChain({
+            links: this.links,
+            op: {
+                id: this.getRequestId(),
+                type,
+                path,
+                input,
+                context
+            }
+        });
+        return chain$.pipe(observable.share());
     }
-  }, {
-    key: "requestAsPromise",
-    value: function requestAsPromise(opts) {
-      var req$ = this.$request(opts);
-
-      var _observableToPromise = observableToPromise(req$),
-          promise = _observableToPromise.promise,
-          abort = _observableToPromise.abort;
-
-      var cancellablePromise = new Promise(function (resolve, reject) {
-        promise.then(function (result) {
-          var transformed = transformOperationResult(result);
-
-          if (transformed.ok) {
-            resolve(transformed.data);
-            return;
-          }
-
-          reject(transformed.error);
-        }).catch(function (err) {
-          reject(TRPCClientError.TRPCClientError.from(err));
+    requestAsPromise(opts) {
+        const req$ = this.$request(opts);
+        const { promise , abort  } = observable.observableToPromise(req$);
+        const abortablePromise = new Promise((resolve, reject)=>{
+            opts.signal?.addEventListener('abort', abort);
+            promise.then((envelope)=>{
+                resolve(envelope.result.data);
+            }).catch((err)=>{
+                reject(transformResult.TRPCClientError.from(err));
+            });
         });
-      });
-      cancellablePromise.cancel = abort;
-      return cancellablePromise;
+        return abortablePromise;
     }
-  }, {
-    key: "query",
-    value: function query(path) {
-      var _ref2;
-
-      var context = (_ref2 = arguments.length <= 2 ? undefined : arguments[2]) === null || _ref2 === void 0 ? void 0 : _ref2.context;
-      return this.requestAsPromise({
-        type: 'query',
-        path: path,
-        input: arguments.length <= 1 ? undefined : arguments[1],
-        context: context
-      });
+    query(path, ...args) {
+        // FIXME: Should be inferred from `args`
+        const context = args[1]?.context;
+        const signal = args[1]?.signal;
+        return this.requestAsPromise({
+            type: 'query',
+            path,
+            input: args[0],
+            context,
+            signal
+        });
     }
-  }, {
-    key: "mutation",
-    value: function mutation(path) {
-      var _ref3;
-
-      var context = (_ref3 = arguments.length <= 2 ? undefined : arguments[2]) === null || _ref3 === void 0 ? void 0 : _ref3.context;
-      return this.requestAsPromise({
-        type: 'mutation',
-        path: path,
-        input: arguments.length <= 1 ? undefined : arguments[1],
-        context: context
-      });
+    mutation(path, ...args) {
+        // FIXME: Should be inferred from `args`
+        const context = args[1]?.context;
+        const signal = args[1]?.signal;
+        return this.requestAsPromise({
+            type: 'mutation',
+            path,
+            input: args[0],
+            context,
+            signal
+        });
     }
-  }, {
-    key: "subscription",
-    value: function subscription(path, input, opts) {
-      var observable$ = this.$request({
-        type: 'subscription',
-        path: path,
-        input: input,
-        context: opts.context
-      });
-      var observer = observable$.subscribe({
-        next: function next(result) {
-          var _opts$next;
-
-          if ('error' in result.data) {
-            var _opts$error;
-
-            var err = TRPCClientError.TRPCClientError.from(result.data, {
-              meta: result.context
-            });
-            (_opts$error = opts.error) === null || _opts$error === void 0 ? void 0 : _opts$error.call(opts, err);
-            return;
-          }
-
-          (_opts$next = opts.next) === null || _opts$next === void 0 ? void 0 : _opts$next.call(opts, result.data.result);
-        },
-        error: function error(err) {
-          var _opts$error2;
-
-          (_opts$error2 = opts.error) === null || _opts$error2 === void 0 ? void 0 : _opts$error2.call(opts, err);
-        },
-        complete: function complete() {
-          var _opts$complete;
-
-          (_opts$complete = opts.complete) === null || _opts$complete === void 0 ? void 0 : _opts$complete.call(opts);
+    subscription(path, input, opts) {
+        const observable$ = this.$request({
+            type: 'subscription',
+            path,
+            input,
+            context: opts?.context
+        });
+        return observable$.subscribe({
+            next (envelope) {
+                if (envelope.result.type === 'started') {
+                    opts.onStarted?.();
+                } else if (envelope.result.type === 'stopped') {
+                    opts.onStopped?.();
+                } else {
+                    opts.onData?.(envelope.result.data);
+                }
+            },
+            error (err) {
+                opts.onError?.(err);
+            },
+            complete () {
+                opts.onComplete?.();
+            }
+        });
+    }
+    constructor(opts){
+        const _fetch = getFetch(opts?.fetch);
+        const AC = getAbortController(opts?.AbortController);
+        this.requestId = 0;
+        function getHeadersFn() {
+            if (opts.headers) {
+                const headers = opts.headers;
+                return typeof headers === 'function' ? headers : ()=>headers;
+            }
+            return ()=>({});
+        }
+        const transformer = opts.transformer ? 'input' in opts.transformer ? {
+            serialize: opts.transformer.input.serialize,
+            deserialize: opts.transformer.output.deserialize
+        } : opts.transformer : {
+            serialize: (data)=>data,
+            deserialize: (data)=>data
+        };
+        this.runtime = {
+            AbortController: AC,
+            fetch: _fetch,
+            headers: getHeadersFn(),
+            transformer
+        };
+        if ('links' in opts) {
+            this.links = opts.links.map((link)=>link(this.runtime));
+        } else {
+            this.links = [
+                links_httpBatchLink.httpBatchLink({
+                    url: opts.url
+                })(this.runtime), 
+            ];
         }
-      });
-      return function () {
-        observer.unsubscribe();
-      };
     }
-  }]);
-
-  return TRPCClient;
-}();
+}
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
 function createTRPCClient(opts) {
-  return new TRPCClient(opts);
+    const client = new TRPCClient(opts);
+    return client;
+}
+
+const clientCallTypeMap = {
+    query: 'query',
+    mutate: 'mutation',
+    subscribe: 'subscription'
+};
+/**
+ * @deprecated use createTRPCProxyClient instead
+ * @internal
+ */ function createTRPCClientProxy(client) {
+    const proxy = shared.createProxy(({ path , args  })=>{
+        const pathCopy = [
+            ...path
+        ];
+        const clientCallType = pathCopy.pop();
+        const procedureType = clientCallTypeMap[clientCallType];
+        const fullPath = pathCopy.join('.');
+        return client[procedureType](fullPath, ...args);
+    });
+    return proxy;
+}
+function createTRPCProxyClient(opts) {
+    const client = createTRPCClient(opts);
+    const proxy = createTRPCClientProxy(client);
+    return proxy;
 }
 
-exports.TRPCClientError = TRPCClientError.TRPCClientError;
+exports.TRPCClientError = transformResult.TRPCClientError;
+exports.httpBatchLink = links_httpBatchLink.httpBatchLink;
+exports.splitLink = links_splitLink.splitLink;
+exports.httpLink = links_httpLink.httpLink;
+exports.loggerLink = links_loggerLink.loggerLink;
+exports.createWSClient = links_wsLink.createWSClient;
+exports.wsLink = links_wsLink.wsLink;
 exports.createTRPCClient = createTRPCClient;
+exports.createTRPCClientProxy = createTRPCClientProxy;
+exports.createTRPCProxyClient = createTRPCProxyClient;
+exports.dedupeLink = dedupeLink;
 exports.getFetch = getFetch;
+exports.retryLink = retryLink;