@splitsoftware/splitio-commons 3.1.1-rc.7 → 3.1.1-rc.9

package/cjs/sdkClient/sdkLifecycle.js

@@ -61,9 +61,10 @@ function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
+            // Stop the service API (the auth provider backoff retries specifically) before flushing,
+            // so that a pending/never-resolved auth retry doesn't block the flush forever
+            serviceApi && serviceApi.stop();
             return __flush().then(function () {
-                // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
-                serviceApi && serviceApi.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/cjs/services/authProvider.js

@@ -45,7 +45,7 @@ function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
     }
     return {
         credential: function () {
-            if (cachedCredential && !isExpired(cachedCredential)) {
+            if (stopped || (cachedCredential && !isExpired(cachedCredential))) {
                 return Promise.resolve(cachedCredential);
             }
             if (cachedCredential)
@@ -57,9 +57,10 @@ function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
         },
         stop: function () {
             stopped = true;
-            cachedCredential = undefined;
             inFlightPromise = undefined;
-            backoff.reset();
+            // Keep any already-cached credential usable (e.g. by a final flush on destroy).
+            // Pass it to reset() so a pending retry's promise settles with it immediately.
+            backoff.reset(cachedCredential);
         }
     };
 }

package/cjs/utils/Backoff.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Backoff = void 0;
 var Backoff = /** @class */ (function () {
     /**
-     * Schedule function calls with exponential backoff
+     * Schedule function calls with exponential backoff.
+     * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
      */
     function Backoff(cb, baseMillis, maxMillis) {
         this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -20,11 +21,11 @@ var Backoff = /** @class */ (function () {
         var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
+        this.attempts++;
         this.timeoutID = setTimeout(function () {
             _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
-        this.attempts++;
         return delayInMillis;
     };
     /**
@@ -38,21 +39,28 @@ var Backoff = /** @class */ (function () {
             clearTimeout(this.timeoutID);
         this.attempts++;
         return new Promise(function (resolve, reject) {
+            _this.pendingResolve = resolve;
             _this.timeoutID = setTimeout(function () {
                 _this.timeoutID = undefined;
+                _this.pendingResolve = undefined;
                 _this.cb().then(resolve, reject);
             }, delayInMillis);
         });
     };
     /**
-     * Reset the backoff attempts
+     * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending,
+     * its promise is resolved immediately with provided `value`, instead of invoking `cb` again.
      */
-    Backoff.prototype.reset = function () {
+    Backoff.prototype.reset = function (value) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (this.pendingResolve) {
+            this.pendingResolve(value);
+            this.pendingResolve = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes

package/esm/sdkClient/sdkLifecycle.js

@@ -58,9 +58,10 @@ export function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
+            // Stop the service API (the auth provider backoff retries specifically) before flushing,
+            // so that a pending/never-resolved auth retry doesn't block the flush forever
+            serviceApi && serviceApi.stop();
             return __flush().then(function () {
-                // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
-                serviceApi && serviceApi.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/esm/services/authProvider.js

@@ -42,7 +42,7 @@ export function authProviderFactory(settings, splitHttpClient, telemetryTracker)
     }
     return {
         credential: function () {
-            if (cachedCredential && !isExpired(cachedCredential)) {
+            if (stopped || (cachedCredential && !isExpired(cachedCredential))) {
                 return Promise.resolve(cachedCredential);
             }
             if (cachedCredential)
@@ -54,9 +54,10 @@ export function authProviderFactory(settings, splitHttpClient, telemetryTracker)
         },
         stop: function () {
             stopped = true;
-            cachedCredential = undefined;
             inFlightPromise = undefined;
-            backoff.reset();
+            // Keep any already-cached credential usable (e.g. by a final flush on destroy).
+            // Pass it to reset() so a pending retry's promise settles with it immediately.
+            backoff.reset(cachedCredential);
         }
     };
 }

package/esm/utils/Backoff.js

@@ -1,6 +1,7 @@
 var Backoff = /** @class */ (function () {
     /**
-     * Schedule function calls with exponential backoff
+     * Schedule function calls with exponential backoff.
+     * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
      */
     function Backoff(cb, baseMillis, maxMillis) {
         this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -17,11 +18,11 @@ var Backoff = /** @class */ (function () {
         var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
+        this.attempts++;
         this.timeoutID = setTimeout(function () {
             _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
-        this.attempts++;
         return delayInMillis;
     };
     /**
@@ -35,21 +36,28 @@ var Backoff = /** @class */ (function () {
             clearTimeout(this.timeoutID);
         this.attempts++;
         return new Promise(function (resolve, reject) {
+            _this.pendingResolve = resolve;
             _this.timeoutID = setTimeout(function () {
                 _this.timeoutID = undefined;
+                _this.pendingResolve = undefined;
                 _this.cb().then(resolve, reject);
             }, delayInMillis);
         });
     };
     /**
-     * Reset the backoff attempts
+     * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending,
+     * its promise is resolved immediately with provided `value`, instead of invoking `cb` again.
      */
-    Backoff.prototype.reset = function () {
+    Backoff.prototype.reset = function (value) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (this.pendingResolve) {
+            this.pendingResolve(value);
+            this.pendingResolve = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.7",
+  "version": "3.1.1-rc.9",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -20,8 +20,8 @@
     "check:lint": "eslint src types --ext .js,.ts",
     "check:types": "tsc --noEmit",
     "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm",
-    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
+    "build:esm": "rimraf esm && tsc -p tsconfig.build.json -m es2015 --outDir esm",
+    "build:cjs": "rimraf cjs && tsc -p tsconfig.build.json -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",

package/src/sdkClient/sdkLifecycle.ts

@@ -70,9 +70,11 @@ export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?:
       // Stop background jobs
       syncManager && syncManager.stop();
 
+      // Stop the service API (the auth provider backoff retries specifically) before flushing,
+      // so that a pending/never-resolved auth retry doesn't block the flush forever
+      serviceApi && serviceApi.stop();
+
       return __flush().then(() => {
-        // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
-        serviceApi && serviceApi.stop();
         // Cleanup storage
         return storage.destroy();
       });

package/src/services/authProvider.ts

@@ -69,8 +69,8 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
 
   return {
     credential(): Promise<IJwtCredential> {
-      if (cachedCredential && !isExpired(cachedCredential)) {
-        return Promise.resolve(cachedCredential);
+      if (stopped || (cachedCredential && !isExpired(cachedCredential))) {
+        return Promise.resolve(cachedCredential!);
       }
 
       if (cachedCredential) log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
@@ -84,9 +84,10 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
 
     stop() {
       stopped = true;
-      cachedCredential = undefined;
       inFlightPromise = undefined;
-      backoff.reset();
+      // Keep any already-cached credential usable (e.g. by a final flush on destroy).
+      // Pass it to reset() so a pending retry's promise settles with it immediately.
+      backoff.reset(cachedCredential);
     }
   };
 }

package/src/utils/Backoff.ts

@@ -12,9 +12,11 @@ export class Backoff {
   attempts: number;
   cb: (...args: any[]) => any;
   timeoutID: ReturnType<typeof setTimeout> | undefined;
+  pendingResolve: ((value: any) => void) | undefined;
 
   /**
-   * Schedule function calls with exponential backoff
+   * Schedule function calls with exponential backoff.
+   * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
    */
   constructor(cb: (...args: any[]) => any, baseMillis?: number, maxMillis?: number) {
     this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -31,11 +33,12 @@ export class Backoff {
     let delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
 
     if (this.timeoutID) clearTimeout(this.timeoutID);
+    this.attempts++;
+
     this.timeoutID = setTimeout(() => {
       this.timeoutID = undefined;
       this.cb();
     }, delayInMillis);
-    this.attempts++;
 
     return delayInMillis;
   }
@@ -51,22 +54,29 @@ export class Backoff {
     this.attempts++;
 
     return new Promise<T>((resolve, reject) => {
+      this.pendingResolve = resolve;
       this.timeoutID = setTimeout(() => {
         this.timeoutID = undefined;
+        this.pendingResolve = undefined;
         this.cb().then(resolve, reject);
       }, delayInMillis);
     });
   }
 
   /**
-   * Reset the backoff attempts
+   * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending,
+   * its promise is resolved immediately with provided `value`, instead of invoking `cb` again.
    */
-  reset() {
+  reset<T>(value?: T) {
     this.attempts = 0;
     if (this.timeoutID) {
       clearTimeout(this.timeoutID);
       this.timeoutID = undefined;
     }
+    if (this.pendingResolve) {
+      this.pendingResolve(value);
+      this.pendingResolve = undefined;
+    }
   }
 
 }