backendless-rt-client/es/socket.js

Backendless RT Client for connect to Backendless RT Server

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _constants = require("./constants");
var RTSocket = exports["default"] = /*#__PURE__*/function () {
  function RTSocket(config, host) {
    (0, _classCallCheck2["default"])(this, RTSocket);
    var _require = require('socket.io-client'),
      io = _require.io;
    this.config = config;
    this.events = {};
    var _config$getSocketConf = config.getSocketConfig(),
      url = _config$getSocketConf.url,
      options = _config$getSocketConf.options;
    this.ioSocket = io(url, options);
  }
  return (0, _createClass2["default"])(RTSocket, [{
    key: "connect",
    value: function connect() {
      this.ioSocket.connect();
    }
  }, {
    key: "close",
    value: function close() {
      this.log('log', 'close socket');
      this.events = {};
      this.ioSocket.off();
      this.ioSocket.close();
    }
  }, {
    key: "on",
    value: function on(event, callback) {
      var _this = this;
      if (!this.events[event]) {
        this.ioSocket.on(event, function (data) {
          return _this.onEvent(event, data);
        });
      }
      this.events[event] = this.events[event] || [];
      this.events[event].push(callback);
    }
  }, {
    key: "off",
    value: function off(event, callback) {
      this.events[event] = callback ? this.events[event].filter(function (f) {
        return f !== callback;
      }) : [];
      if (!this.events[event].length) {
        delete this.events[event];
      }
      if (!this.events[event]) {
        this.ioSocket.off(event);
      }
    }
  }, {
    key: "onEvent",
    value: function onEvent(event, data) {
      this.logMessage('FROM SERVER', event, data);
      if (this.events[event]) {
        this.events[event].forEach(function (callback) {
          return callback(data);
        });
      }
    }
  }, {
    key: "emit",
    value: function emit(event, data) {
      this.logMessage('TO SERVER', event, data);
      this.ioSocket.emit(event, data);
    }
  }, {
    key: "log",
    value: function log(type) {
      if (this.config.debugMode) {
        var _console;
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
        // eslint-disable-next-line
        (_console = console)[type].apply(_console, ['[RT Client]:'].concat(args));
      }
    }
  }, {
    key: "logMessage",
    value: function logMessage(type, event, data) {
      this.log('log', "[".concat(type, "] - [event: ").concat(event, "] - arguments: ").concat(JSON.stringify(data), " "));
    }
  }], [{
    key: "connect",
    value: function connect(config, onDisconnect) {
      return Promise.resolve().then(function () {
        return config.prepare();
      }).then(function () {
        return new Promise(function (resolve, reject) {
          var rtSocket = new RTSocket(config);
          rtSocket.on(_constants.NativeSocketEvents.CONNECT, onConnect);
          rtSocket.on(_constants.NativeSocketEvents.CONNECT_ERROR, onError);
          rtSocket.on(_constants.NativeSocketEvents.CONNECT_TIMEOUT, onError);
          rtSocket.on(_constants.NativeSocketEvents.ERROR, function (error) {
            rtSocket.log('error', 'received ERROR event while connecting', error);
            closeAndReject(error);
          });
          rtSocket.connect();
          function onConnect() {
            rtSocket.log('log', 'socket connected');
            resolve(rtSocket);
          }
          function onError(error) {
            rtSocket.log('error', 'received one of [CONNECT_ERROR,CONNECT_TIMEOUT] socket event while connecting', error);
            closeAndReject(error);
          }
          function closeAndReject(error) {
            rtSocket.log('log', 'close and reject socket with error:', error);
            rtSocket.close();
            reject(error);
          }
        });
      }).then(function (rtSocket) {
        rtSocket.on(_constants.NativeSocketEvents.DISCONNECT, onDisconnect);
        rtSocket.on(_constants.NativeSocketEvents.ERROR, onDisconnect);
        return rtSocket;
      });
    }
  }]);
}();