@webex/calling 3.12.0-mobius-socket.9 → 3.12.0-mobius-socket.11

package/dist/mobius-socket/socket/socket-base.js

@@ -0,0 +1,632 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys2 = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _weakMap = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/weak-map"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/reflect/define-property"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _from = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/array/from"));
+var _defineProperty3 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+var _has2 = _interopRequireDefault(require("lodash/has"));
+var _defaults2 = _interopRequireDefault(require("lodash/defaults"));
+var _events = require("events");
+var _common = require("@webex/common");
+var _commonTimers = require("@webex/common-timers");
+var _errors = require("../errors");
+var _constants = require("./constants");
+function ownKeys(e, r) { var t = _Object$keys2(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty3.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+var sockets = new _weakMap.default();
+
+/**
+ * Generalized socket abstraction
+ */
+var Socket = exports.default = /*#__PURE__*/function (_EventEmitter) {
+  /**
+   * constructor
+   * @returns {Socket}
+   */
+  function Socket() {
+    var _this;
+    (0, _classCallCheck2.default)(this, Socket);
+    _this = _callSuper(this, Socket);
+    _this._domain = 'unknown-domain';
+    _this._pendingResponses = new _map.default();
+    _this.onmessage = _this.onmessage.bind(_this);
+    _this.onclose = _this.onclose.bind(_this);
+    // Increase max listeners to avoid memory leak warning in tests
+    _this.setMaxListeners(10);
+    return _this;
+  }
+
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+   * @returns {string}
+   */
+  (0, _inherits2.default)(Socket, _EventEmitter);
+  return (0, _createClass2.default)(Socket, [{
+    key: "binaryType",
+    get: function get() {
+      return sockets.get(this).binaryType;
+    }
+
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @returns {number}
+     */
+  }, {
+    key: "bufferedAmount",
+    get: function get() {
+      return sockets.get(this).bufferedAmount;
+    }
+
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @returns {string}
+     */
+  }, {
+    key: "extensions",
+    get: function get() {
+      return sockets.get(this).extensions;
+    }
+
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @returns {string}
+     */
+  }, {
+    key: "protocol",
+    get: function get() {
+      return sockets.get(this).protocol;
+    }
+
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @returns {number}
+     */
+  }, {
+    key: "readyState",
+    get: function get() {
+      return sockets.get(this).readyState;
+    }
+
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @returns {string}
+     */
+  }, {
+    key: "url",
+    get: function get() {
+      return sockets.get(this).url;
+    }
+
+    /**
+     * Provides the environmentally appropriate constructor (ws in NodeJS,
+     * WebSocket in browsers)
+     * @returns {WebSocket}
+     */
+  }, {
+    key: "close",
+    value:
+    /**
+     * Closes the socket
+     * @param {Object} options
+     * @param {string} options.reason
+     * @param {number} options.code
+     * @returns {Promise}
+     */
+    function close(options) {
+      var _this2 = this;
+      return new _promise.default(function (resolve, reject) {
+        var socket = sockets.get(_this2);
+        if (!socket) {
+          // Open has not been called yet so there is no socket to close
+          resolve();
+          return;
+        }
+        // logger is defined once open is called
+        _this2.logger.info("socket,".concat(_this2._domain, ": closing"));
+        if (socket.readyState === _constants.SOCKET_READY_STATE.CLOSING || socket.readyState === _constants.SOCKET_READY_STATE.CLOSED) {
+          _this2.logger.info("socket,".concat(_this2._domain, ": already closed"));
+          resolve();
+          return;
+        }
+        options = options || {};
+        if (options.code && options.code !== 1000 && (options.code < 3000 || options.code > 4999)) {
+          reject(new Error('`options.code` must be 1000 or between 3000 and 4999 (inclusive)'));
+          return;
+        }
+        var originalCode = options.code;
+        var originalReason = options.reason;
+        options = (0, _defaults2.default)(options, {
+          code: 1000,
+          reason: 'Done'
+        });
+        var closeTimer = (0, _commonTimers.safeSetTimeout)(function () {
+          try {
+            _this2.logger.info("socket,".concat(_this2._domain, ": no close event received, forcing closure"));
+            resolve(_this2.onclose(originalCode ? {
+              code: originalCode,
+              reason: originalReason || 'Done (unknown)'
+            } : {
+              code: 1000,
+              reason: 'Done (forced)'
+            }));
+          } catch (error) {
+            _this2.logger.warn("socket,".concat(_this2._domain, ": force-close failed"), error);
+          }
+        }, _this2.forceCloseDelay);
+        socket.onclose = function (event) {
+          _this2.logger.info("socket,".concat(_this2._domain, ": close event fired"), event.code, event.reason);
+          clearTimeout(closeTimer);
+          _this2.onclose(event);
+          resolve(event);
+        };
+
+        // If socket is still connecting, manually trigger close handler with desired code
+        // because calling close() on a CONNECTING socket may not preserve custom codes
+        if (socket.readyState === _constants.SOCKET_READY_STATE.CONNECTING) {
+          _this2.logger.info("socket,".concat(_this2._domain, ": socket still connecting, triggering close manually"));
+          clearTimeout(closeTimer);
+          var closeEvent = {
+            code: options.code,
+            reason: options.reason
+          };
+          _this2.onclose(closeEvent);
+          resolve(closeEvent);
+          try {
+            socket.close(options.code, options.reason);
+          } catch (error) {
+            _this2.logger.info("socket,".concat(_this2._domain, ": error while closing CONNECTING socket, likely due to browser incompatibility with custom close codes"), error);
+          }
+        } else {
+          socket.close(options.code, options.reason);
+        }
+      });
+    }
+
+    /**
+     * Opens a WebSocket
+     * @param {string} url
+     * @param {options} options
+     * @param {number} options.forceCloseDelay (required)
+     * @param {string} options.token (required)
+     * @param {string} options.trackingId (required)
+     * @param {Logger} options.logger (required)
+     * @returns {Promise}
+     */
+  }, {
+    key: "open",
+    value: function open(url, options) {
+      var _this3 = this;
+      try {
+        this._domain = new URL(url).hostname;
+      } catch (_unused) {
+        this._domain = url;
+      }
+      return new _promise.default(function (resolve, reject) {
+        /* eslint complexity: [0] */
+        if (!url) {
+          reject(new Error('`url` is required'));
+          return;
+        }
+        if (sockets.get(_this3)) {
+          reject(new Error('Socket#open() can only be called once per instance'));
+          return;
+        }
+        options = options || {};
+        (0, _common.checkRequired)(['forceCloseDelay', 'token', 'trackingId', 'logger'], options);
+        (0, _keys.default)(options).forEach(function (key) {
+          (0, _defineProperty2.default)(_this3, key, {
+            enumerable: false,
+            value: options[key]
+          });
+        });
+        var WebSocket = Socket.getWebSocketConstructor();
+        _this3.logger.info("socket,".concat(_this3._domain, ": creating WebSocket"));
+        var socket = new WebSocket(url, [], options);
+        socket.binaryType = 'arraybuffer';
+        socket.onmessage = _this3.onmessage;
+        socket.onclose = function (event) {
+          event = _this3._fixCloseCode(event);
+          _this3.logger.info("socket,".concat(_this3._domain, ": closed before open"), event.code, event.reason);
+          switch (event.code) {
+            case 1005:
+              // IE 11 doesn't seem to allow 4XXX codes, so if we get a 1005, assume
+              // it's a bad websocket url. That'll trigger a device refresh; if it
+              // turns out we had a bad token, the device refresh should 401 and
+              // trigger a token refresh.
+              return reject(new _errors.UnknownResponse(event));
+            case 4400:
+              return reject(new _errors.BadRequest(event));
+            case 4401:
+              return reject(new _errors.NotAuthorized(event));
+            case 4403:
+              return reject(new _errors.Forbidden(event));
+            // case 4404:
+            //   return reject(new NotFound(event));
+            default:
+              return reject(new _errors.ConnectionError(event));
+          }
+        };
+        socket.onopen = function () {
+          _this3.logger.info("socket,".concat(_this3._domain, ": connected"));
+          _this3._authorize(_this3.token).then(function () {
+            _this3.logger.info("socket,".concat(_this3._domain, ": authorized"));
+            socket.onclose = _this3.onclose;
+            resolve();
+          }).catch(reject);
+        };
+        socket.onerror = function (event) {
+          _this3.logger.warn("socket,".concat(_this3._domain, ": error event fired"), event);
+        };
+        sockets.set(_this3, socket);
+        _this3.logger.info("socket,".concat(_this3._domain, ": waiting for server"));
+      });
+    }
+
+    /**
+     * Handles incoming CloseEvents
+     * @param {CloseEvent} event
+     * @returns {undefined}
+     */
+  }, {
+    key: "onclose",
+    value: function onclose(event) {
+      this.logger.info("socket,".concat(this._domain, ": closed"), event.code, event.reason);
+      event = this._fixCloseCode(event);
+      this._rejectPendingResponses(new _errors.ConnectionError(event));
+      this.emit('close', event);
+
+      // Remove all listeners to (a) avoid reacting to late pongs and (b) ensure
+      // we don't have a retain cycle.
+      this.removeAllListeners();
+    }
+
+    /**
+     * Handles incoming message events
+     * @param {MessageEvent} event
+     * @returns {undefined}
+     */
+  }, {
+    key: "onmessage",
+    value: function onmessage(event) {
+      var _this4 = this;
+      try {
+        var data = JSON.parse(event.data);
+        var processedEvent = {
+          data: data
+        };
+        if (data.type === 'async_event') {
+          this._acknowledge(processedEvent).catch(function (error) {
+            _this4.logger.warn("socket,".concat(_this4._domain, ": failed to acknowledge async event"), error);
+          });
+        }
+
+        // Match pending request/response promises before emitting the public message event.
+        // The message is still emitted afterward for any external listeners that care about it.
+        this._handlePendingResponse(data);
+        this.emit('message', processedEvent);
+      } catch (error) {
+        /* istanbul ignore next */
+        this.logger.warn("socket,".concat(this._domain, ": error while receiving WebSocket message"), error);
+      }
+    }
+
+    /**
+     * Sends a message up the socket
+     * @param {mixed} data
+     * @returns {Promise}
+     */
+  }, {
+    key: "send",
+    value: function send(data) {
+      var _this5 = this;
+      return new _promise.default(function (resolve, reject) {
+        if (_this5.readyState !== _constants.SOCKET_READY_STATE.OPEN) {
+          return reject(new Error('INVALID_STATE_ERROR'));
+        }
+        if ((0, _isObject2.default)(data)) {
+          data = (0, _stringify.default)(data);
+        }
+        var socket = sockets.get(_this5);
+        socket.send(data);
+        return resolve();
+      });
+    }
+
+    /**
+     * Sends a request and resolves when the matching response arrives.
+     * @param {Object} data
+     * @param {Object} [options={}]
+     * @param {Function} [options.matchesResponse]
+     * @param {Function} [options.createError]
+     * @param {Function} [options.createTimeoutError]
+     * @param {Function} [options.getStatusCode]
+     * @param {Function} [options.getStatusMessage]
+     * @param {number} [options.timeout]
+     * @returns {Promise<Object>}
+     */
+  }, {
+    key: "sendRequest",
+    value: function sendRequest(data) {
+      var _this6 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!(0, _isObject2.default)(data)) {
+        return _promise.default.reject(new Error('`data` is required'));
+      }
+      var request = _objectSpread({}, data);
+      var trackingId = request.trackingId || this._createTrackingId();
+      var timeout = options.timeout || this.wssResponseTimeout || 10000;
+      var matchesResponse = options.matchesResponse || function (response) {
+        return (response === null || response === void 0 ? void 0 : response.trackingId) === trackingId && (response === null || response === void 0 ? void 0 : response.type) === 'response_event';
+      };
+      var getStatusCode = options.getStatusCode || function (response) {
+        return response === null || response === void 0 ? void 0 : response.statusCode;
+      };
+      var getStatusMessage = options.getStatusMessage || function (response) {
+        return response === null || response === void 0 ? void 0 : response.statusMessage;
+      };
+      var createError = options.createError || function (response, statusCode, statusMessage) {
+        return new _errors.ConnectionError({
+          code: statusCode,
+          reason: statusMessage || (response === null || response === void 0 ? void 0 : response.reason) || 'Socket request failed'
+        });
+      };
+      var createTimeoutError = options.createTimeoutError || function () {
+        return new _errors.ConnectionError({
+          reason: 'Socket response not received before timeout'
+        });
+      };
+      if (this._pendingResponses.has(trackingId)) {
+        return _promise.default.reject(new Error("socket request already pending for trackingId ".concat(trackingId)));
+      }
+      request.trackingId = trackingId;
+      return new _promise.default(function (_resolve, _reject) {
+        var timeoutId = (0, _commonTimers.safeSetTimeout)(function () {
+          _this6._clearPendingResponse(trackingId);
+          _reject(createTimeoutError(request));
+        }, timeout);
+        _this6._pendingResponses.set(trackingId, {
+          request: request,
+          matchesResponse: matchesResponse,
+          getStatusCode: getStatusCode,
+          getStatusMessage: getStatusMessage,
+          createError: createError,
+          resolve: function resolve(response) {
+            _this6._clearPendingResponse(trackingId);
+            _resolve(response);
+          },
+          reject: function reject(error) {
+            _this6._clearPendingResponse(trackingId);
+            _reject(error);
+          },
+          timeoutId: timeoutId
+        });
+        _this6.send(request).catch(function (error) {
+          _this6._clearPendingResponse(trackingId);
+          _reject(error);
+        });
+      });
+    }
+
+    /**
+     * Sends an acknowledgment for a specific event
+     * @param {MessageEvent} event
+     * @returns {Promise}
+     */
+  }, {
+    key: "_acknowledge",
+    value: function _acknowledge(event) {
+      if (!event) {
+        return _promise.default.reject(new Error('`event` is required'));
+      }
+      if (!(0, _has2.default)(event, 'data.eventId')) {
+        return _promise.default.reject(new Error('`event.data.eventId` is required'));
+      }
+
+      // Don't try to acknowledge if socket is not in open state
+      if (this.readyState !== _constants.SOCKET_READY_STATE.OPEN) {
+        return _promise.default.resolve();
+      }
+      return this.send({
+        type: _constants.MESSAGE_TYPES.EVENT_ACK,
+        trackingId: event.data.trackingId || this._createTrackingId(),
+        eventId: event.data.eventId
+      }).catch(function (error) {
+        if (error.message === 'INVALID_STATE_ERROR') {
+          return _promise.default.resolve();
+        }
+        throw error;
+      });
+    }
+  }, {
+    key: "refresh",
+    value: function refresh(token) {
+      if (!token) {
+        return _promise.default.reject(new Error('`token` is required for Socket#refresh()'));
+      }
+      var refreshedToken = token && typeof token.toString === 'function' ? token.toString() : token;
+      return this._authorize(refreshedToken);
+    }
+
+    /**
+     * Sends an auth message up the socket with a refreshed token.
+     * @param {string} token
+     * @returns {Promise}
+     */
+  }, {
+    key: "_authorize",
+    value: function _authorize(token) {
+      this.logger.info("socket,".concat(this._domain, ": authorizing"));
+      return this.sendRequest({
+        type: _constants.MESSAGE_TYPES.AUTH,
+        data: {
+          token: token
+        }
+      }, {
+        matchesResponse: function matchesResponse(response, request) {
+          return (response === null || response === void 0 ? void 0 : response.type) === 'response_event' && (response === null || response === void 0 ? void 0 : response.subtype) === _constants.MESSAGE_TYPES.AUTH && (response === null || response === void 0 ? void 0 : response.trackingId) === request.trackingId;
+        },
+        getStatusCode: function getStatusCode(response) {
+          return response === null || response === void 0 ? void 0 : response.statusCode;
+        },
+        getStatusMessage: function getStatusMessage(response) {
+          return response === null || response === void 0 ? void 0 : response.statusMessage;
+        },
+        createError: function createError(response, statusCode, statusMessage) {
+          return new _errors.NotAuthorized({
+            code: statusCode,
+            reason: statusMessage || 'Mobius auth failed'
+          });
+        },
+        createTimeoutError: function createTimeoutError() {
+          return new _errors.NotAuthorized({
+            reason: 'Mobius auth response not received before timeout'
+          });
+        }
+      });
+    }
+
+    /**
+     * Creates a unique tracking ID
+     * @private
+     * @returns {string}
+     */
+  }, {
+    key: "_createTrackingId",
+    value: function _createTrackingId() {
+      return "".concat(this.trackingId, "_").concat(crypto.randomUUID());
+    }
+
+    /**
+     * Clears a pending response entry.
+     * @param {string} trackingId
+     * @returns {void}
+     */
+  }, {
+    key: "_clearPendingResponse",
+    value: function _clearPendingResponse(trackingId) {
+      var pendingResponse = this._pendingResponses.get(trackingId);
+      if (pendingResponse !== null && pendingResponse !== void 0 && pendingResponse.timeoutId) {
+        clearTimeout(pendingResponse.timeoutId);
+      }
+      this._pendingResponses.delete(trackingId);
+    }
+
+    /**
+     * Rejects all pending responses with the provided error.
+     * @param {Error} error
+     * @returns {void}
+     */
+  }, {
+    key: "_rejectPendingResponses",
+    value: function _rejectPendingResponses(error) {
+      if (!this._pendingResponses.size) {
+        return;
+      }
+      (0, _from.default)(this._pendingResponses.values()).forEach(function (pendingResponse) {
+        pendingResponse.reject(error);
+      });
+    }
+
+    /**
+     * Handles incoming responses for pending requests.
+     * @param {Object} response
+     * @returns {boolean}
+     */
+  }, {
+    key: "_handlePendingResponse",
+    value: function _handlePendingResponse(response) {
+      var _this7 = this;
+      if (!response) {
+        return false;
+      }
+
+      // Pending request correlation currently requires trackingId on the response.
+      var pendingResponse = response.trackingId ? this._pendingResponses.get(response.trackingId) : undefined;
+      if (!pendingResponse) {
+        return false;
+      }
+      if (!pendingResponse.matchesResponse(response, pendingResponse.request)) {
+        return false;
+      }
+      var statusCode = pendingResponse.getStatusCode(response);
+      var statusMessage = pendingResponse.getStatusMessage(response);
+      if (statusCode === 440 && (response === null || response === void 0 ? void 0 : response.subtype) !== _constants.MESSAGE_TYPES.AUTH) {
+        if (typeof this.refreshToken === 'function') {
+          _promise.default.resolve(this.refreshToken(response)).catch(function (error) {
+            _this7.logger.warn("socket,".concat(_this7._domain, ": failed token-expiry re-auth"), error);
+          });
+        } else {
+          this.logger.warn("socket,".concat(this._domain, ": refreshToken callback is unavailable for statusCode 440"));
+        }
+      }
+      if (statusCode === undefined) {
+        pendingResponse.reject(pendingResponse.createError(response, statusCode, statusMessage || 'Socket response missing status code'));
+      } else if (statusCode >= 200 && statusCode < 300) {
+        pendingResponse.resolve(response);
+      } else {
+        pendingResponse.reject(pendingResponse.createError(response, statusCode, statusMessage));
+      }
+      return true;
+    }
+
+    /**
+     * Deals with the fact that some browsers drop some close codes (but not
+     * close reasons).
+     * @param {CloseEvent} event
+     * @private
+     * @returns {CloseEvent}
+     */
+  }, {
+    key: "_fixCloseCode",
+    value: function _fixCloseCode(event) {
+      if (event.code === 1005 && event.reason) {
+        switch (event.reason.toLowerCase()) {
+          case 'replaced':
+            this.logger.info("socket,".concat(this._domain, ": fixing CloseEvent code for reason: "), event.reason);
+            event.code = 4000;
+            break;
+          case 'authentication failed':
+          case 'authentication did not happen within the timeout window of 30000 seconds.':
+            this.logger.info("socket,".concat(this._domain, ": fixing CloseEvent code for reason: "), event.reason);
+            event.code = 1008;
+            break;
+          default:
+          // do nothing
+        }
+      }
+      return event;
+    }
+  }], [{
+    key: "getWebSocketConstructor",
+    value: function getWebSocketConstructor() {
+      throw new Error('Socket.getWebSocketConstructor() must be implemented in an environmentally appropriate way');
+    }
+  }]);
+}(_events.EventEmitter);
+//# sourceMappingURL=socket-base.js.map