centrifuge 5.3.0 → 5.3.2

package/README.md

@@ -5,7 +5,7 @@ This SDK provides a client to connect to [Centrifugo](https://github.com/centrif
 
 The features implemented by this SDK can be found in [SDK feature matrix](https://centrifugal.dev/docs/transports/client_sdk#sdk-feature-matrix).
 
-> `centrifuge-js` v5.x is compatible with [Centrifugo](https://github.com/centrifugal/centrifugo) server v4 and v5 and [Centrifuge](https://github.com/centrifugal/centrifuge) >= 0.25.0. For Centrifugo v2, Centrifugo v3 and Centrifuge < 0.25.0 you should use `centrifuge-js` v2.x.
+> `centrifuge-js` v5.x is compatible with [Centrifugo](https://github.com/centrifugal/centrifugo) server v6, v5 and v4, and [Centrifuge](https://github.com/centrifugal/centrifuge) >= 0.25.0. For Centrifugo v2, Centrifugo v3 and Centrifuge < 0.25.0 you should use `centrifuge-js` v2.x.
 
 * [Install](#install)
 * [Quick start](#quick-start)
@@ -131,14 +131,14 @@ Supported transports are:
 * `websocket`
 * `http_stream`
 * `sse`
-* `sockjs` - SockJS can also be used as a fallback, SockJS is currently in DEPRECATED status in Centrifugal ecosystem. Also, sticky sessions must be used on the backend in distributed case with it. See more details below
+* `sockjs` - SockJS can also be used as a fallback in Centrifugo < v6, in Centrifugo v6 SockJS was removed and will be removed in `centrifuge-js` v6 too. Also, sticky sessions must be used on the backend in distributed case with it. See more details below
 * `webtransport` - this SDK also supports WebTransport in experimental form. See details below
 
 If you want to use sticky sessions on a load balancer level as an optimimization for Centrifugal bidirectional emulation layer keep in mind that we currently use `same-origin` credentials policy for emulation requests in `http_stream` and `sse` transport cases. So cookies will only be passed in same-origin case. Please open an issue in case you need to configure more relaxed credentials. Though in most cases stickyness based on client's IP may be sufficient enough.
 
 ### Using SockJS
 
-**SockJS usage is DEPRECATED in the Centrifugal ecosystem**
+**SockJS usage is DEPRECATED**. Its support was removed in Centrifugo v6, and it will also be removed from this SDK in v6 release.
 
 If you want to use SockJS you must also import SockJS client before centrifuge.js
 

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) {
-            return null;
+    _handleTokenResponse(token) {
+        if (!this._isSubscribing()) {
+            this._inflight = false;
+            return;
         }
-        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 };
-        this._inflight = true;
+        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;
@@ -1006,6 +1035,7 @@ class Subscription extends EventEmitter$1 {
             }
             this._clearSubscribingState();
         }
+        this._inflight = false;
         if (this._setState(exports.SubscriptionState.Unsubscribed)) {
             this.emit('unsubscribed', { channel: this.channel, code: code, reason: reason });
         }
@@ -1061,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 () {
@@ -1068,6 +1102,7 @@ class Subscription extends EventEmitter$1 {
                 self._subscribe();
             }
         }, delay);
+        this._debug('resubscribe scheduled after ' + delay, this.channel);
     }
     _subscribeError(err) {
         if (!this._isSubscribing()) {
@@ -1166,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
         };
@@ -1240,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));
@@ -2803,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;
@@ -2838,7 +2872,8 @@ class Centrifuge extends EventEmitter$1 {
                     }
                     self._data = data;
                     self._initializeTransport();
-                });
+                })
+                    .catch(e => self._handleGetDataError(e));
             }
             else {
                 self._initializeTransport();
@@ -2859,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;