laravel-echo-api-gateway 0.1.2 → 0.5.2

package/dist/laravel-echo-api-gateway.iife.js

@@ -20,20 +20,44 @@ var LaravelEchoApiGateway = (function (exports) {
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
     return Constructor;
   }
 
+  function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+
   function _inherits(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
       throw new TypeError("Super expression must either be null or a function");
     }
 
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-      constructor: {
-        value: subClass,
-        writable: true,
-        configurable: true
-      }
+    Object.defineProperty(subClass, "prototype", {
+      value: Object.create(superClass && superClass.prototype, {
+        constructor: {
+          value: subClass,
+          writable: true,
+          configurable: true
+        }
+      }),
+      writable: false
     });
     if (superClass) _setPrototypeOf(subClass, superClass);
   }
@@ -60,7 +84,7 @@ var LaravelEchoApiGateway = (function (exports) {
     if (typeof Proxy === "function") return true;
 
     try {
-      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
       return true;
     } catch (e) {
       return false;
@@ -78,6 +102,8 @@ var LaravelEchoApiGateway = (function (exports) {
   function _possibleConstructorReturn(self, call) {
     if (call && (typeof call === "object" || typeof call === "function")) {
       return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
     }
 
     return _assertThisInitialized(self);
@@ -102,6 +128,80 @@ var LaravelEchoApiGateway = (function (exports) {
     };
   }
 
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (!it) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+        var i = 0;
+
+        var F = function () {};
+
+        return {
+          s: F,
+          n: function () {
+            if (i >= o.length) return {
+              done: true
+            };
+            return {
+              done: false,
+              value: o[i++]
+            };
+          },
+          e: function (e) {
+            throw e;
+          },
+          f: F
+        };
+      }
+
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    var normalCompletion = true,
+        didErr = false,
+        err;
+    return {
+      s: function () {
+        it = it.call(o);
+      },
+      n: function () {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      },
+      e: function (e) {
+        didErr = true;
+        err = e;
+      },
+      f: function () {
+        try {
+          if (!normalCompletion && it.return != null) it.return();
+        } finally {
+          if (didErr) throw err;
+        }
+      }
+    };
+  }
+
   class Connector {
       /**
        * Create a new class instance.
@@ -156,83 +256,136 @@ var LaravelEchoApiGateway = (function (exports) {
 
   var Websocket = /*#__PURE__*/function () {
     function Websocket(options) {
-      var _this = this;
-
       _classCallCheck(this, Websocket);
 
       this.buffer = [];
       this.listeners = {};
       this.internalListeners = {};
       this.channelBacklog = [];
+      this.closing = false;
+      this.hasConnected = false;
       this.options = options;
-      this.websocket = new WebSocket(options.host);
+      this.connect(this.options.host);
+      return this;
+    }
 
-      this.websocket.onopen = function () {
-        while (_this.buffer.length) {
-          var message = _this.buffer[0];
+    _createClass(Websocket, [{
+      key: "connect",
+      value: function connect(host) {
+        var _this = this;
 
-          _this.send(message);
+        this.options.debug && console.log('Trying to connect...');
+        this.websocket = new WebSocket(host);
 
-          _this.buffer.splice(0, 1);
-        }
-      };
+        this.websocket.onerror = function () {
+          if (!_this.hasConnected) {
+            setTimeout(function () {
+              _this.socketId = undefined;
 
-      this.websocket.onmessage = function (messageEvent) {
-        var message = _this.parseMessage(messageEvent.data);
+              _this.connect(host);
+            }, 3000);
+          }
+        };
 
-        if (!message) {
-          return;
-        }
+        this.websocket.onopen = function () {
+          _this.options.debug && console.log('Connected !');
+          _this.hasConnected = true;
 
-        if (message.channel) {
-          console.log("Received event ".concat(message.event, " on channel ").concat(message.channel));
+          _this.send({
+            event: 'whoami'
+          });
 
-          if (_this.listeners[message.channel] && _this.listeners[message.channel][message.event]) {
-            _this.listeners[message.channel][message.event](message.data);
-          }
+          while (_this.buffer.length) {
+            var message = _this.buffer[0];
 
-          return;
-        }
+            _this.send(message);
 
-        if (_this.internalListeners[message.event]) {
-          _this.internalListeners[message.event](message.data);
-        }
-      };
+            _this.buffer.splice(0, 1);
+          } // Register events only once connected, or they won't be registered if connection failed/lost
 
-      this.on('whoami', function (_ref) {
-        var socketId = _ref.socket_id;
-        _this.socketId = socketId;
-        console.log("just set socketId to ".concat(socketId));
 
-        while (_this.channelBacklog.length) {
-          var channel = _this.channelBacklog[0];
+          _this.websocket.onmessage = function (messageEvent) {
+            var message = _this.parseMessage(messageEvent.data);
 
-          _this.actuallySubscribe(channel);
+            _this.options.debug && console.log('onmessage', messageEvent.data);
 
-          _this.channelBacklog.splice(0, 1);
-        }
-      });
-      this.send({
-        event: 'whoami'
-      }); // send ping every 60 seconds to keep connection alive
+            if (!message) {
+              return;
+            }
 
-      this.pingInterval = setInterval(function () {
-        console.log('Sending ping');
+            if (message.channel) {
+              _this.options.debug && console.log("Received event ".concat(message.event, " on channel ").concat(message.channel));
 
-        _this.send({
-          event: 'ping'
-        });
-      }, 60 * 1000);
-      return this;
-    }
+              if (_this.listeners[message.channel] && _this.listeners[message.channel][message.event]) {
+                _this.listeners[message.channel][message.event](message.data);
+              }
 
-    _createClass(Websocket, [{
+              return;
+            }
+
+            if (_this.internalListeners[message.event]) {
+              _this.internalListeners[message.event](message.data);
+            }
+          }; // send ping every 60 seconds to keep connection alive
+
+
+          _this.pingInterval = setInterval(function () {
+            if (_this.websocket.readyState === _this.websocket.OPEN) {
+              _this.options.debug && console.log('Sending ping');
+
+              _this.send({
+                event: 'ping'
+              });
+            }
+          }, 60 * 1000);
+        };
+
+        this.websocket.onclose = function () {
+          _this.options.debug && console.info('Connection closed.');
+
+          if (_this.closing) {
+            return;
+          }
+
+          _this.hasConnected = false;
+          _this.options.debug && console.info('Connection lost, reconnecting...');
+          setTimeout(function () {
+            _this.socketId = undefined;
+
+            _this.connect(host);
+          }, 1000);
+        };
+
+        this.on('whoami', function (_ref) {
+          var socketId = _ref.socket_id;
+          _this.socketId = socketId;
+          _this.options.debug && console.log("just set socketId to ".concat(socketId)); // Handle the backlog and don't empty it, we'll need it if we lose connection
+
+          var channel;
+
+          var _iterator = _createForOfIteratorHelper(_this.channelBacklog),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              channel = _step.value;
+
+              _this.actuallySubscribe(channel);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        });
+      }
+    }, {
       key: "parseMessage",
       value: function parseMessage(body) {
         try {
           return JSON.parse(body);
         } catch (error) {
-          console.error(error);
+          this.options.debug && console.error(error);
           return undefined;
         }
       }
@@ -259,6 +412,7 @@ var LaravelEchoApiGateway = (function (exports) {
     }, {
       key: "close",
       value: function close() {
+        this.closing = true;
         this.internalListeners = {};
         clearInterval(this.pingInterval);
         this.pingInterval = undefined;
@@ -279,26 +433,32 @@ var LaravelEchoApiGateway = (function (exports) {
         var _this2 = this;
 
         if (channel.name.startsWith('private-') || channel.name.startsWith('presence-')) {
-          console.log("Sending auth request for channel ".concat(channel.name));
+          this.options.debug && console.log("Sending auth request for channel ".concat(channel.name));
+
+          if (this.options.bearerToken) {
+            this.options.auth.headers['Authorization'] = 'Bearer ' + this.options.bearerToken;
+          }
+
           axios.post(this.options.authEndpoint, {
             socket_id: this.getSocketId(),
             channel_name: channel.name
+          }, {
+            headers: this.options.auth.headers || {}
           }).then(function (response) {
-            console.log("Subscribing to channels ".concat(channel.name));
+            _this2.options.debug && console.log("Subscribing to channels ".concat(channel.name));
 
             _this2.send({
               event: 'subscribe',
-              data: {
-                channel: channel.name,
-                auth: response.data.auth
-              }
+              data: _extends({
+                channel: channel.name
+              }, response.data)
             });
           })["catch"](function (error) {
-            console.log("Auth request for channel ".concat(channel.name, " failed"));
-            console.error(error);
+            _this2.options.debug && console.log("Auth request for channel ".concat(channel.name, " failed"));
+            _this2.options.debug && console.error(error);
           });
         } else {
-          console.log("Subscribing to channels ".concat(channel.name));
+          this.options.debug && console.log("Subscribing to channels ".concat(channel.name));
           this.send({
             event: 'subscribe',
             data: {
@@ -507,9 +667,12 @@ var LaravelEchoApiGateway = (function (exports) {
     }, {
       key: "whisper",
       value: function whisper(event, data) {
+        var channel = this.name;
+        var formattedEvent = "client-" + event;
         this.socket.send({
-          event: event,
-          data: data
+          "event": formattedEvent,
+          data: data,
+          channel: channel
         });
         return this;
       }