feat(retry-policy): retry policy now applies to all requests

The configured retry policy will be used for any failed request.

feat(retry-policy): exponential retry policy used by default for subscribe

By default, the SDK is configured to use an exponential retry policy for failed subscribe requests.

fix(subscribe): add missing `subscription change` status

`PNSubscriptionChangedCategory` will be emitted each time the list of channels and groups is
changing.

refactor(network): request retries moved to the network

Automated request retry has been moved into the network layer to handle all requests (not only
subscribed).

test(cleanup): make proper clean up after each test case

Properly destroy `PubNub` instance after each test case to make sure that all connections closed
and prevent tests from hanging.

Author: parfeon

.mocharc.json

@@ -1,10 +1,11 @@
 {
   "require": "tsx",
+  "file": ["test/setup-why.ts"],
   "spec": "test/**/*.test.ts",
   "exclude": [
     "test/dist/*.{js,ts}",
     "test/feature/*.{js,ts}"
   ],
   "timeout": 5000,
   "reporter": "spec"
-}
+}

dist/web/pubnub.js

@@ -9,6 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeConfiguration = void 0;
+const retryPolicy_1 = require("./retryPolicy");
 const uuid_1 = __importDefault(require("./uuid"));
 // --------------------------------------------------------
 // ----------------------- Defaults -----------------------
@@ -32,6 +33,24 @@ const USE_RANDOM_INITIALIZATION_VECTOR = true;
  */
 const makeConfiguration = (base, setupCryptoModule) => {
     var _a, _b, _c;
+    // Set default retry policy for subscribe (if new subscribe logic not used).
+    if (!base.retryConfiguration && base.enableEventEngine) {
+        base.retryConfiguration = retryPolicy_1.RetryPolicy.ExponentialRetryPolicy({
+            minimumDelay: 2,
+            maximumDelay: 150,
+            maximumRetry: 6,
+            excluded: [
+                retryPolicy_1.Endpoint.MessageSend,
+                retryPolicy_1.Endpoint.Presence,
+                retryPolicy_1.Endpoint.Files,
+                retryPolicy_1.Endpoint.MessageStorage,
+                retryPolicy_1.Endpoint.ChannelGroups,
+                retryPolicy_1.Endpoint.DevicePushNotifications,
+                retryPolicy_1.Endpoint.AppContext,
+                retryPolicy_1.Endpoint.MessageReactions,
+            ],
+        });
+    }
     // Ensure that retry policy has proper configuration (if has been set).
     (_a = base.retryConfiguration) === null || _a === void 0 ? void 0 : _a.validate();
     (_b = base.useRandomIVs) !== null && _b !== void 0 ? _b : (base.useRandomIVs = USE_RANDOM_INITIALIZATION_VECTOR);

dist/web/pubnub.min.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryPolicy = exports.Endpoint = void 0;
+const categories_1 = __importDefault(require("../constants/categories"));
+// --------------------------------------------------------
+// ------------------------ Types -------------------------
+// --------------------------------------------------------
+// region Types
+/**
+ * List of known endpoint groups (by context).
+ */
+var Endpoint;
+(function (Endpoint) {
+    /**
+     * Unknown endpoint.
+     *
+     * @internal
+     */
+    Endpoint["Unknown"] = "UnknownEndpoint";
+    /**
+     * The endpoints to send messages.
+     */
+    Endpoint["MessageSend"] = "MessageSendEndpoint";
+    /**
+     * The endpoint for real-time update retrieval.
+     */
+    Endpoint["Subscribe"] = "SubscribeEndpoint";
+    /**
+     * The endpoint to access and manage `user_id` presence and fetch channel presence information.
+     */
+    Endpoint["Presence"] = "PresenceEndpoint";
+    /**
+     * The endpoint to access and manage files in channel-specific storage.
+     */
+    Endpoint["Files"] = "FilesEndpoint";
+    /**
+     * The endpoint to access and manage messages for a specific channel(s) in the persistent storage.
+     */
+    Endpoint["MessageStorage"] = "MessageStorageEndpoint";
+    /**
+     * The endpoint to access and manage channel groups.
+     */
+    Endpoint["ChannelGroups"] = "ChannelGroupsEndpoint";
+    /**
+     * The endpoint to access and manage device registration for channel push notifications.
+     */
+    Endpoint["DevicePushNotifications"] = "DevicePushNotificationsEndpoint";
+    /**
+     * The endpoint to access and manage App Context objects.
+     */
+    Endpoint["AppContext"] = "AppContextEndpoint";
+    /**
+     * The endpoint to access and manage reactions for a specific message.
+     */
+    Endpoint["MessageReactions"] = "MessageReactionsEndpoint";
+})(Endpoint || (exports.Endpoint = Endpoint = {}));
+// endregion
+/**
+ * Failed request retry policy.
+ */
+class RetryPolicy {
+    static LinearRetryPolicy(configuration) {
+        var _a;
+        return {
+            delay: configuration.delay,
+            maximumRetry: configuration.maximumRetry,
+            excluded: (_a = configuration.excluded) !== null && _a !== void 0 ? _a : [],
+            shouldRetry(request, response, error, attempt) {
+                return isRetriableRequest(request, response, error, attempt !== null && attempt !== void 0 ? attempt : 0, this.maximumRetry, this.excluded);
+            },
+            getDelay(_, response) {
+                let delay = -1;
+                if (response && response.headers['retry-after'] !== undefined)
+                    delay = parseInt(response.headers['retry-after'], 10);
+                if (delay === -1)
+                    delay = this.delay;
+                return (delay + Math.random()) * 1000;
+            },
+            validate() {
+                if (this.delay < 2)
+                    throw new Error('Delay can not be set less than 2 seconds for retry');
+                if (this.maximumRetry > 10)
+                    throw new Error('Maximum retry for linear retry policy can not be more than 10');
+            },
+        };
+    }
+    static ExponentialRetryPolicy(configuration) {
+        var _a;
+        return {
+            minimumDelay: configuration.minimumDelay,
+            maximumDelay: configuration.maximumDelay,
+            maximumRetry: configuration.maximumRetry,
+            excluded: (_a = configuration.excluded) !== null && _a !== void 0 ? _a : [],
+            shouldRetry(request, response, error, attempt) {
+                return isRetriableRequest(request, response, error, attempt !== null && attempt !== void 0 ? attempt : 0, this.maximumRetry, this.excluded);
+            },
+            getDelay(attempt, response) {
+                let delay = -1;
+                if (response && response.headers['retry-after'] !== undefined)
+                    delay = parseInt(response.headers['retry-after'], 10);
+                if (delay === -1)
+                    delay = Math.min(Math.pow(2, attempt), this.maximumDelay);
+                return (delay + Math.random()) * 1000;
+            },
+            validate() {
+                if (this.minimumDelay < 2)
+                    throw new Error('Minimum delay can not be set less than 2 seconds for retry');
+                else if (this.maximumDelay > 150)
+                    throw new Error('Maximum delay can not be set more than 150 seconds for' + ' retry');
+                else if (this.maximumRetry > 6)
+                    throw new Error('Maximum retry for exponential retry policy can not be more than 6');
+            },
+        };
+    }
+}
+exports.RetryPolicy = RetryPolicy;
+/**
+ * Check whether request can be retried or not.
+ *
+ * @param req - Request for which retry ability is checked.
+ * @param res - Service response which should be taken into consideration.
+ * @param errorCategory - Request processing error category.
+ * @param retryAttempt - Current retry attempt.
+ * @param maximumRetry - Maximum retry attempts count according to the retry policy.
+ * @param excluded - List of endpoints for which retry policy won't be applied.
+ *
+ * @return `true` if request can be retried.
+ *
+ * @internal
+ */
+const isRetriableRequest = (req, res, errorCategory, retryAttempt, maximumRetry, excluded) => {
+    if (errorCategory && errorCategory === categories_1.default.PNCancelledCategory)
+        return false;
+    else if (isExcludedRequest(req, excluded))
+        return false;
+    else if (retryAttempt > maximumRetry)
+        return false;
+    return res ? res.status === 429 || res.status >= 500 : true;
+};
+/**
+ * Check whether the provided request is in the list of endpoints for which retry is not allowed or not.
+ *
+ * @param req - Request which will be tested.
+ * @param excluded - List of excluded endpoints configured for retry policy.
+ *
+ * @returns `true` if request has been excluded and shouldn't be retried.
+ *
+ * @internal
+ */
+const isExcludedRequest = (req, excluded) => excluded && excluded.length > 0 ? excluded.includes(endpointFromRequest(req)) : false;
+/**
+ * Identify API group from transport request.
+ *
+ * @param req - Request for which `path` will be analyzed to identify REST API group.
+ *
+ * @returns Endpoint group to which request belongs.
+ *
+ * @internal
+ */
+const endpointFromRequest = (req) => {
+    let endpoint = Endpoint.Unknown;
+    if (req.path.startsWith('/v2/subscribe'))
+        endpoint = Endpoint.Subscribe;
+    else if (req.path.startsWith('/publish/') || req.path.startsWith('/signal/'))
+        endpoint = Endpoint.MessageSend;
+    else if (req.path.startsWith('/v2/presence'))
+        endpoint = Endpoint.Presence;
+    else if (req.path.startsWith('/v2/history') || req.path.startsWith('/v3/history'))
+        endpoint = Endpoint.MessageStorage;
+    else if (req.path.startsWith('/v1/message-actions/'))
+        endpoint = Endpoint.MessageReactions;
+    else if (req.path.startsWith('/v1/channel-registration/'))
+        endpoint = Endpoint.ChannelGroups;
+    else if (req.path.startsWith('/v2/objects/'))
+        endpoint = Endpoint.ChannelGroups;
+    else if (req.path.startsWith('/v1/push/') || req.path.startsWith('/v2/push/'))
+        endpoint = Endpoint.DevicePushNotifications;
+    else if (req.path.startsWith('/v1/files/'))
+        endpoint = Endpoint.Files;
+    return endpoint;
+};

lib/core/components/configuration.js

@@ -69,6 +69,10 @@ var StatusCategory;
      * PubNub client connected to the real-time updates stream.
      */
     StatusCategory["PNConnectedCategory"] = "PNConnectedCategory";
+    /**
+     * Set of active channels and groups has been changed.
+     */
+    StatusCategory["PNSubscriptionChangedCategory"] = "PNSubscriptionChangedCategory";
     /**
      * Received real-time updates exceed specified threshold.
      *

lib/core/components/retryPolicy.js

@@ -29,7 +29,7 @@ const utils_1 = require("../../utils");
  */
 class HeartbeatRequest extends request_1.AbstractRequest {
     constructor(parameters) {
-        super();
+        super({ cancellable: true });
         this.parameters = parameters;
     }
     operation() {

lib/core/constants/categories.js

@@ -64,9 +64,9 @@ const categories_1 = __importDefault(require("./constants/categories"));
 // endregion
 const pubnub_error_1 = require("../errors/pubnub-error");
 const pubnub_api_error_1 = require("../errors/pubnub-api-error");
+const retryPolicy_1 = require("./components/retryPolicy");
 // region Event Engine
 const presence_1 = require("../event-engine/presence/presence");
-const retryPolicy_1 = require("../event-engine/core/retryPolicy");
 const event_engine_1 = require("../event-engine");
 // endregion
 // region Publish & Signal
@@ -198,7 +198,6 @@ class PubNubCore {
                                     else
                                         setTimeout(resolve, heartbeatInterval * 1000);
                                 }),
-                                retryDelay: (amount) => new Promise((resolve) => setTimeout(resolve, amount)),
                                 emitStatus: (status) => this.listenerManager.announceStatus(status),
                                 config: this._configuration,
                                 presenceState: this.presenceState,
@@ -212,6 +211,8 @@ class PubNubCore {
                         join: this.join.bind(this),
                         leave: this.leave.bind(this),
                         leaveAll: this.leaveAll.bind(this),
+                        presenceReconnect: this.presenceReconnect.bind(this),
+                        presenceDisconnect: this.presenceDisconnect.bind(this),
                         presenceState: this.presenceState,
                         config: this._configuration,
                         emitMessages: (events) => {
@@ -636,6 +637,10 @@ class PubNubCore {
             }
             else if (this.eventEngine)
                 this.eventEngine.dispose();
+            if (process.env.PRESENCE_MODULE !== 'disabled') {
+                if (this.presenceEventEngine)
+                    this.presenceEventEngine.dispose();
+            }
         }
     }
     /**
@@ -946,13 +951,17 @@ class PubNubCore {
     }
     /**
      * Temporarily disconnect from real-time events stream.
+     *
+     * **Note:** `isOffline` is set to `true` only when client experience network issues.
+     *
+     * @param [isOffline] - Whether `offline` presence should be notified or not.
      */
-    disconnect() {
+    disconnect(isOffline) {
         if (process.env.SUBSCRIBE_MODULE !== 'disabled') {
             if (this.subscriptionManager)
                 this.subscriptionManager.disconnect();
             else if (this.eventEngine)
-                this.eventEngine.disconnect();
+                this.eventEngine.disconnect(isOffline);
         }
         else
             throw new Error('Disconnection error: subscription module disabled');
@@ -1363,6 +1372,24 @@ class PubNubCore {
         else
             throw new Error('Announce UUID Presence error: presence module disabled');
     }
+    /**
+     * Reconnect presence event engine after network issues.
+     *
+     * @param parameters - List of channels and groups where `join` event should be sent.
+     *
+     * @internal
+     */
+    presenceReconnect(parameters) {
+        if (process.env.PRESENCE_MODULE !== 'disabled') {
+            if (this.presenceEventEngine)
+                this.presenceEventEngine.reconnect();
+            else {
+                this.heartbeat(Object.assign(Object.assign({ channels: parameters.channels, channelGroups: parameters.groups }, (this._configuration.maintainPresenceState && { state: this.presenceState })), { heartbeat: this._configuration.getPresenceTimeout() }), () => { });
+            }
+        }
+        else
+            throw new Error('Announce UUID Presence error: presence module disabled');
+    }
     // endregion
     // region Leave
     /**
@@ -1400,6 +1427,23 @@ class PubNubCore {
         else
             throw new Error('Announce UUID Leave error: presence module disabled');
     }
+    /**
+     * Announce user `leave` on disconnection.
+     *
+     * @internal
+     *
+     * @param parameters - List of channels and groups where `leave` event should be sent.
+     */
+    presenceDisconnect(parameters) {
+        if (process.env.PRESENCE_MODULE !== 'disabled') {
+            if (this.presenceEventEngine)
+                this.presenceEventEngine.disconnect(parameters.isOffline);
+            else if (!parameters.isOffline)
+                this.makeUnsubscribe({ channels: parameters.channels, channelGroups: parameters.groups }, () => { });
+        }
+        else
+            throw new Error('Announce UUID Leave error: presence module disabled');
+    }
     /**
      * Grant token permission.
      *