@trpc/client 10.0.0-alpha.5 → 10.0.0-alpha.52

package/dist/links/wsLink.js

@@ -2,382 +2,275 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-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');
-var observable = require('../observable-85669100.js');
-var TRPCClientError = require('../TRPCClientError-ec6bd2ca.js');
-require('@babel/runtime/helpers/defineProperty');
-require('@babel/runtime/helpers/createClass');
+var observable = require('@trpc/server/observable');
+var transformResult = require('../transformResult-e15ccdf6.js');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+/* istanbul ignore next */ const retryDelay = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
 
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-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);
-
-/* 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__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; } }
 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");
-  }
-  /**
+    const { url , WebSocket: WebSocketImpl = WebSocket , retryDelayMs: retryDelayFn = retryDelay , onOpen , onClose ,  } = opts;
+    /* 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';
-  /**
+   */ let outgoing = [];
+    const pendingRequests = Object.create(null);
+    let connectAttempt = 0;
+    let dispatchTimer = null;
+    let connectTimer = null;
+    let activeConnection = createWS();
+    let 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;
+   */ function dispatch() {
+        if (state !== 'open' || dispatchTimer) {
+            return;
+        }
+        dispatchTimer = setTimeout(()=>{
+            dispatchTimer = null;
+            if (outgoing.length === 1) {
+                // single send
+                activeConnection.send(JSON.stringify(outgoing.pop()));
+            } else {
+                // batch send
+                activeConnection.send(JSON.stringify(outgoing));
+            }
+            // clear
+            outgoing = [];
+        });
     }
-
-    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 tryReconnect() {
+        if (connectTimer || state === 'closed') {
+            return;
+        }
+        const timeout = retryDelayFn(connectAttempt++);
+        reconnectInMs(timeout);
     }
-  }
-
-  function resumeSubscriptionOnReconnect(req) {
-    if (outgoing.some(function (r) {
-      return r.id === req.op.id;
-    })) {
-      return;
+    function reconnect() {
+        state = 'connecting';
+        const oldConnection = activeConnection;
+        activeConnection = createWS();
+        closeIfNoPending(oldConnection);
     }
-
-    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);
-          }
+    function reconnectInMs(ms) {
+        if (connectTimer) {
+            return;
         }
-      }
-    };
-
-    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;
+        state = 'connecting';
+        connectTimer = setTimeout(reconnect, ms);
+    }
+    function closeIfNoPending(conn) {
+        // disconnect as soon as there are are no pending result
+        const hasPendingRequests = Object.values(pendingRequests).some((p)=>p.ws === conn);
+        if (!hasPendingRequests) {
+            conn.close();
         }
-
-        (_req$callbacks$error = (_req$callbacks2 = req.callbacks).error) === null || _req$callbacks$error === void 0 ? void 0 : _req$callbacks$error.call(_req$callbacks2, TRPCClientError.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);
+    }
+    function resumeSubscriptionOnReconnect(req) {
+        if (outgoing.some((r)=>r.id === req.op.id)) {
+            return;
         }
-      }
-    });
-    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$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',
-          params: undefined
+        request(req.op, req.callbacks);
+    }
+    function createWS() {
+        const conn = new WebSocketImpl(url);
+        clearTimeout(connectTimer);
+        connectTimer = null;
+        conn.addEventListener('open', ()=>{
+            /* istanbul ignore next */ if (conn !== activeConnection) {
+                return;
+            }
+            connectAttempt = 0;
+            state = 'open';
+            onOpen?.();
+            dispatch();
         });
+        conn.addEventListener('error', ()=>{
+            if (conn === activeConnection) {
+                tryReconnect();
+            }
+        });
+        const handleIncomingRequest = (req)=>{
+            if (req.method === 'reconnect' && conn === activeConnection) {
+                if (state === 'open') {
+                    onClose?.();
+                }
+                reconnect();
+                // notify subscribers
+                for (const pendingReq of Object.values(pendingRequests)){
+                    if (pendingReq.type === 'subscription') {
+                        resumeSubscriptionOnReconnect(pendingReq);
+                    }
+                }
+            }
+        };
+        const handleIncomingResponse = (data)=>{
+            const req = data.id !== null && pendingRequests[data.id];
+            if (!req) {
+                // do something?
+                return;
+            }
+            req.callbacks.next?.(data);
+            if (req.ws !== activeConnection && conn === activeConnection) {
+                const 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', ({ data  })=>{
+            const 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', ()=>{
+            if (state === 'open') {
+                onClose?.();
+            }
+            if (activeConnection === conn) {
+                // connection might have been replaced already
+                tryReconnect();
+            }
+            for (const [key, req] of Object.entries(pendingRequests)){
+                if (req.ws !== conn) {
+                    continue;
+                }
+                req.callbacks.error?.(transformResult.TRPCClientError.from(new TRPCWebSocketClosedError('WebSocket closed prematurely')));
+                if (req.type !== 'subscription') {
+                    delete pendingRequests[key];
+                    req.callbacks.complete?.();
+                } else if (state !== 'closed') {
+                    // request restart of sub with next connection
+                    resumeSubscriptionOnReconnect(req);
+                }
+            }
+        });
+        return conn;
+    }
+    function request(op, callbacks) {
+        const { type , input , path , id  } = op;
+        const envelope = {
+            id,
+            method: type,
+            params: {
+                input,
+                path
+            }
+        };
+        pendingRequests[id] = {
+            ws: activeConnection,
+            type,
+            callbacks,
+            op
+        };
+        // enqueue message
+        outgoing.push(envelope);
         dispatch();
-      }
+        return ()=>{
+            const callbacks = pendingRequests[id]?.callbacks;
+            delete pendingRequests[id];
+            outgoing = outgoing.filter((msg)=>msg.id !== id);
+            callbacks?.complete?.();
+            if (op.type === 'subscription') {
+                outgoing.push({
+                    id,
+                    method: 'subscription.stop'
+                });
+                dispatch();
+            }
+        };
+    }
+    return {
+        close: ()=>{
+            state = 'closed';
+            onClose?.();
+            closeIfNoPending(activeConnection);
+            clearTimeout(connectTimer);
+            connectTimer = null;
+        },
+        request,
+        getConnection () {
+            return activeConnection;
+        }
     };
-  }
-
-  return {
-    close: function close() {
-      state = 'closed';
-      closeIfNoPending(activeConnection);
-    },
-    request: request,
-    getConnection: function getConnection() {
-      return activeConnection;
+}
+class TRPCWebSocketClosedError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'TRPCWebSocketClosedError';
+        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
+    }
+}
+class TRPCSubscriptionEndedError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'TRPCSubscriptionEndedError';
+        Object.setPrototypeOf(this, TRPCSubscriptionEndedError.prototype);
     }
-  };
 }
-
-var TRPCWebSocketClosedError = /*#__PURE__*/function (_Error) {
-  _inherits__default["default"](TRPCWebSocketClosedError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(TRPCWebSocketClosedError);
-
-  function TRPCWebSocketClosedError(message) {
-    var _this;
-
-    _classCallCheck__default["default"](this, TRPCWebSocketClosedError);
-
-    _this = _super.call(this, message);
-    _this.name = 'TRPCWebSocketClosedError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), TRPCWebSocketClosedError.prototype);
-    return _this;
-  }
-
-  return TRPCWebSocketClosedError;
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
-
-var TRPCSubscriptionEndedError = /*#__PURE__*/function (_Error2) {
-  _inherits__default["default"](TRPCSubscriptionEndedError, _Error2);
-
-  var _super2 = /*#__PURE__*/_createSuper(TRPCSubscriptionEndedError);
-
-  function TRPCSubscriptionEndedError(message) {
-    var _this2;
-
-    _classCallCheck__default["default"](this, TRPCSubscriptionEndedError);
-
-    _this2 = _super2.call(this, message);
-    _this2.name = 'TRPCSubscriptionEndedError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this2), TRPCSubscriptionEndedError.prototype);
-    return _this2;
-  }
-
-  return TRPCSubscriptionEndedError;
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
-
 function wsLink(opts) {
-  return function () {
-    var client = opts.client;
-    return function (_ref2) {
-      var op = _ref2.op;
-      return observable.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) {
-            isDone = true;
-            observer.error(err);
-            unsub();
-          },
-          complete: function complete() {
-            if (!isDone) {
-              isDone = true;
-              observer.error(TRPCClientError.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();
+    return (runtime)=>{
+        const { client  } = opts;
+        return ({ op  })=>{
+            return observable.observable((observer)=>{
+                const { type , path , id , context  } = op;
+                const input = runtime.transformer.serialize(op.input);
+                let isDone = false;
+                const unsub = client.request({
+                    type,
+                    path,
+                    input,
+                    id,
+                    context
+                }, {
+                    error (err) {
+                        isDone = true;
+                        observer.error(err);
+                        unsub();
+                    },
+                    complete () {
+                        if (!isDone) {
+                            isDone = true;
+                            observer.error(transformResult.TRPCClientError.from(new TRPCSubscriptionEndedError('Operation ended prematurely')));
+                        } else {
+                            observer.complete();
+                        }
+                    },
+                    next (message) {
+                        const transformed = transformResult.transformResult(message, runtime);
+                        if (!transformed.ok) {
+                            observer.error(transformResult.TRPCClientError.from(transformed.error));
+                            return;
+                        }
+                        observer.next({
+                            result: transformed.result
+                        });
+                        if (op.type !== 'subscription') {
+                            // if it isn't a subscription we don't care about next response
+                            isDone = true;
+                            unsub();
+                            observer.complete();
+                        }
+                    }
+                });
+                return ()=>{
+                    isDone = true;
+                    unsub();
+                };
+            });
         };
-      });
     };
-  };
 }
 
 exports.createWSClient = createWSClient;