centrifuge 5.3.1 → 5.3.2

package/build/centrifuge.d.ts

@@ -112,6 +112,7 @@ export declare class Centrifuge extends Centrifuge_base {
     private _initializeTransport;
     private _sendConnect;
     private _startReconnecting;
+    private _handleGetDataError;
     private _connectError;
     private _scheduleReconnect;
     private _constructConnectCommand;

package/build/index.js

@@ -651,12 +651,10 @@ class Subscription extends EventEmitter$1 {
         // @ts-ignore – we are hiding some symbols from public API autocompletion.
         if (this._centrifuge._debugEnabled) {
             this.on('state', (ctx) => {
-                // @ts-ignore – we are hiding some symbols from public API autocompletion.
-                this._centrifuge._debug('subscription state', channel, ctx.oldState, '->', ctx.newState);
+                this._debug('subscription state', channel, ctx.oldState, '->', ctx.newState);
             });
             this.on('error', (ctx) => {
-                // @ts-ignore – we are hiding some symbols from public API autocompletion.
-                this._centrifuge._debug('subscription error', channel, ctx);
+                this._debug('subscription error', channel, ctx);
             });
         }
         else {
@@ -837,119 +835,121 @@ class Subscription extends EventEmitter$1 {
         });
     }
     _subscribe() {
+        this._debug('subscribing on', this.channel);
+        if (!this._isTransportOpen()) {
+            this._debug('delay subscribe on', this.channel, 'till connected');
+            return null;
+        }
+        if (this._inflight) {
+            return null;
+        }
+        this._inflight = true;
+        if (this._canSubscribeWithoutGettingToken()) {
+            return this._subscribeWithoutToken();
+        }
+        this._getSubscriptionToken()
+            .then(token => this._handleTokenResponse(token))
+            .catch(e => this._handleTokenError(e));
+        return null;
+    }
+    _isTransportOpen() {
         // @ts-ignore – we are hiding some symbols from public API autocompletion.
-        this._centrifuge._debug('subscribing on', this.channel);
-        // need to check transport readiness here, because there's no point for calling getData or getToken
-        // if transport is not ready yet
-        // @ts-ignore – we are hiding some symbols from public API autocompletion.
-        if (!this._centrifuge._transportIsOpen) {
-            // @ts-ignore – we are hiding some symbols from public API autocompletion.
-            this._centrifuge._debug('delay subscribe on', this.channel, 'till connected');
-            // subscribe will be called later automatically.
+        return this._centrifuge._transportIsOpen;
+    }
+    _canSubscribeWithoutGettingToken() {
+        return !this._usesToken() || !!this._token;
+    }
+    _subscribeWithoutToken() {
+        if (this._getData) {
+            this._getDataAndSubscribe(this._token);
             return null;
         }
-        const self = this;
-        const getDataCtx = {
-            channel: self.channel
-        };
-        if (!this._usesToken() || this._token) {
-            if (self._getData) {
-                self._getData(getDataCtx).then(function (data) {
-                    if (!self._isSubscribing()) {
-                        return;
-                    }
-                    self._data = data;
-                    self._sendSubscribe(self._token);
-                });
-                return null;
-            }
-            else {
-                return self._sendSubscribe(self._token);
-            }
+        else {
+            return this._sendSubscribe(this._token);
         }
-        this._getSubscriptionToken().then(function (token) {
-            if (!self._isSubscribing()) {
-                return;
-            }
-            if (!token) {
-                self._failUnauthorized();
-                return;
-            }
-            self._token = token;
-            if (self._getData) {
-                self._getData(getDataCtx).then(function (data) {
-                    if (!self._isSubscribing()) {
-                        return;
-                    }
-                    self._data = data;
-                    self._sendSubscribe(token);
-                });
-            }
-            else {
-                self._sendSubscribe(token);
-            }
-        }).catch(function (e) {
-            if (!self._isSubscribing()) {
+    }
+    _getDataAndSubscribe(token) {
+        if (!this._getData) {
+            this._inflight = false;
+            return;
+        }
+        this._getData({ channel: this.channel })
+            .then(data => {
+            if (!this._isSubscribing()) {
+                this._inflight = false;
                 return;
             }
-            if (e instanceof UnauthorizedError) {
-                self._failUnauthorized();
-                return;
+            this._data = data;
+            this._sendSubscribe(token);
+        })
+            .catch(e => this._handleGetDataError(e));
+    }
+    _handleGetDataError(error) {
+        if (!this._isSubscribing()) {
+            this._inflight = false;
+            return;
+        }
+        if (error instanceof UnauthorizedError) {
+            this._inflight = false;
+            this._failUnauthorized();
+            return;
+        }
+        this.emit('error', {
+            type: 'subscribeData',
+            channel: this.channel,
+            error: {
+                code: exports.errorCodes.badConfiguration,
+                message: (error === null || error === void 0 ? void 0 : error.toString()) || ''
             }
-            self.emit('error', {
-                type: 'subscribeToken',
-                channel: self.channel,
-                error: {
-                    code: exports.errorCodes.subscriptionSubscribeToken,
-                    message: e !== undefined ? e.toString() : ''
-                }
-            });
-            self._scheduleResubscribe();
         });
-        return null;
+        this._inflight = false;
+        this._scheduleResubscribe();
     }
-    _sendSubscribe(token) {
-        // we also need to check for transport state before sending subscription
-        // because it may change for subscription with side effects (getData, getToken options)
-        // @ts-ignore – we are hiding some symbols from public API autocompletion.
-        if (!this._centrifuge._transportIsOpen || this._inflight) {
-            return null;
+    _handleTokenResponse(token) {
+        if (!this._isSubscribing()) {
+            this._inflight = false;
+            return;
         }
-        this._inflight = true;
-        const channel = this.channel;
-        const req = {
-            channel: channel
-        };
-        if (token) {
-            req.token = token;
+        if (!token) {
+            this._inflight = false;
+            this._failUnauthorized();
+            return;
         }
-        if (this._data) {
-            req.data = this._data;
+        this._token = token;
+        if (this._getData) {
+            this._getDataAndSubscribe(token);
         }
-        if (this._positioned) {
-            req.positioned = true;
+        else {
+            this._sendSubscribe(token);
         }
-        if (this._recoverable) {
-            req.recoverable = true;
+    }
+    _handleTokenError(error) {
+        if (!this._isSubscribing()) {
+            this._inflight = false;
+            return;
         }
-        if (this._joinLeave) {
-            req.join_leave = true;
+        if (error instanceof UnauthorizedError) {
+            this._inflight = false;
+            this._failUnauthorized();
+            return;
         }
-        if (this._needRecover()) {
-            req.recover = true;
-            const offset = this._getOffset();
-            if (offset) {
-                req.offset = offset;
+        this.emit('error', {
+            type: 'subscribeToken',
+            channel: this.channel,
+            error: {
+                code: exports.errorCodes.subscriptionSubscribeToken,
+                message: (error === null || error === void 0 ? void 0 : error.toString()) || ''
             }
-            const epoch = this._getEpoch();
-            if (epoch) {
-                req.epoch = epoch;
-            }
-        }
-        if (this._delta) {
-            req.delta = this._delta;
+        });
+        this._inflight = false;
+        this._scheduleResubscribe();
+    }
+    _sendSubscribe(token) {
+        if (!this._isTransportOpen()) {
+            this._inflight = false;
+            return null;
         }
-        const cmd = { subscribe: req };
+        const cmd = this._buildSubscribeCommand(token);
         // @ts-ignore – we are hiding some symbols from public API autocompletion.
         this._centrifuge._call(cmd).then(resolveCtx => {
             this._inflight = false;
@@ -970,6 +970,35 @@ class Subscription extends EventEmitter$1 {
         });
         return cmd;
     }
+    _buildSubscribeCommand(token) {
+        const req = { channel: this.channel };
+        if (token)
+            req.token = token;
+        if (this._data)
+            req.data = this._data;
+        if (this._positioned)
+            req.positioned = true;
+        if (this._recoverable)
+            req.recoverable = true;
+        if (this._joinLeave)
+            req.join_leave = true;
+        if (this._needRecover()) {
+            req.recover = true;
+            const offset = this._getOffset();
+            if (offset)
+                req.offset = offset;
+            const epoch = this._getEpoch();
+            if (epoch)
+                req.epoch = epoch;
+        }
+        if (this._delta)
+            req.delta = this._delta;
+        return { subscribe: req };
+    }
+    _debug(...args) {
+        // @ts-ignore – we are hiding some symbols from public API autocompletion.
+        this._centrifuge._debug(...args);
+    }
     _handleSubscribeError(error) {
         if (!this._isSubscribing()) {
             return;
@@ -1062,6 +1091,10 @@ class Subscription extends EventEmitter$1 {
         }
     }
     _scheduleResubscribe() {
+        if (!this._isSubscribing()) {
+            this._debug('not in subscribing state, skip resubscribe scheduling', this.channel);
+            return;
+        }
         const self = this;
         const delay = this._getResubscribeDelay();
         this._resubscribeTimeout = setTimeout(function () {
@@ -1069,6 +1102,7 @@ class Subscription extends EventEmitter$1 {
                 self._subscribe();
             }
         }, delay);
+        this._debug('resubscribe scheduled after ' + delay, this.channel);
     }
     _subscribeError(err) {
         if (!this._isSubscribing()) {
@@ -1167,8 +1201,7 @@ class Subscription extends EventEmitter$1 {
         }
     }
     _getSubscriptionToken() {
-        // @ts-ignore – we are hiding some methods from public API autocompletion.
-        this._centrifuge._debug('get subscription token for channel', this.channel);
+        this._debug('get subscription token for channel', this.channel);
         const ctx = {
             channel: this.channel
         };
@@ -1241,8 +1274,7 @@ class Subscription extends EventEmitter$1 {
         if (!this._isSubscribed()) {
             return;
         }
-        // @ts-ignore – we are hiding some methods from public API autocompletion.
-        this._centrifuge._debug('subscription token refreshed, channel', this.channel);
+        this._debug('subscription token refreshed, channel', this.channel);
         this._clearRefreshTimeout();
         if (result.expires === true) {
             this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));
@@ -2804,24 +2836,25 @@ class Centrifuge extends EventEmitter$1 {
             return;
         }
         this._reconnecting = true;
-        const self = this;
         const emptyToken = this._token === '';
         const needTokenRefresh = this._refreshRequired || (emptyToken && this._config.getToken !== null);
         if (!needTokenRefresh) {
             if (this._config.getData) {
-                this._config.getData().then(function (data) {
-                    if (!self._isConnecting()) {
+                this._config.getData().then(data => {
+                    if (!this._isConnecting()) {
                         return;
                     }
-                    self._data = data;
-                    self._initializeTransport();
-                });
+                    this._data = data;
+                    this._initializeTransport();
+                })
+                    .catch(e => this._handleGetDataError(e));
             }
             else {
                 this._initializeTransport();
             }
             return;
         }
+        const self = this;
         this._getToken().then(function (token) {
             if (!self._isConnecting()) {
                 return;
@@ -2839,7 +2872,8 @@ class Centrifuge extends EventEmitter$1 {
                     }
                     self._data = data;
                     self._initializeTransport();
-                });
+                })
+                    .catch(e => self._handleGetDataError(e));
             }
             else {
                 self._initializeTransport();
@@ -2860,13 +2894,32 @@ class Centrifuge extends EventEmitter$1 {
                 }
             });
             const delay = self._getReconnectDelay();
-            self._debug('error on connection token refresh, reconnect after ' + delay + ' milliseconds', e);
+            self._debug('error on getting connection token, reconnect after ' + delay + ' milliseconds', e);
             self._reconnecting = false;
             self._reconnectTimeout = setTimeout(() => {
                 self._startReconnecting();
             }, delay);
         });
     }
+    _handleGetDataError(e) {
+        if (e instanceof UnauthorizedError) {
+            this._failUnauthorized();
+            return;
+        }
+        this.emit('error', {
+            type: 'connectData',
+            error: {
+                code: exports.errorCodes.badConfiguration,
+                message: (e === null || e === void 0 ? void 0 : e.toString()) || ''
+            }
+        });
+        const delay = this._getReconnectDelay();
+        this._debug('error on getting connect data, reconnect after ' + delay + ' milliseconds', e);
+        this._reconnecting = false;
+        this._reconnectTimeout = setTimeout(() => {
+            this._startReconnecting();
+        }, delay);
+    }
     _connectError(err) {
         if (this.state !== exports.State.Connecting) {
             return;