@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.11

package/cjs/sync/polling/pollingManagerSS.js

@@ -4,46 +4,54 @@ exports.pollingManagerSSFactory = void 0;
 var definitionsSyncTask_1 = require("./syncTasks/definitionsSyncTask");
 var segmentsSyncTask_1 = require("./syncTasks/segmentsSyncTask");
 var constants_1 = require("../../logger/constants");
+var segmentChangesFetcher_1 = require("./fetchers/segmentChangesFetcher");
+var splitChangesFetcher_1 = require("./fetchers/splitChangesFetcher");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
-    var storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: segmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(constants_1.POLLING_START);
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
-            var startingUp = definitionsSyncTask.start();
-            if (startingUp) {
-                startingUp.then(function () {
-                    if (definitionsSyncTask.isRunning())
-                        segmentsSyncTask.start();
+function pollingManagerSSFactory(definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+    return function (params) {
+        var storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var segmentChangesFetcher = segmentFetcherFactory(params);
+        var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
+        var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: segmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(constants_1.POLLING_START);
+                log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
+                log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
+                var startingUp = definitionsSyncTask.start();
+                if (startingUp) {
+                    startingUp.then(function () {
+                        if (definitionsSyncTask.isRunning())
+                            segmentsSyncTask.start();
+                    });
+                }
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(constants_1.POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                if (segmentsSyncTask.isRunning())
+                    segmentsSyncTask.stop();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            syncAll: function () {
+                // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+                return definitionsSyncTask.execute().then(function () {
+                    return segmentsSyncTask.execute();
                 });
             }
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(constants_1.POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            if (segmentsSyncTask.isRunning())
-                segmentsSyncTask.stop();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        syncAll: function () {
-            // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-            return definitionsSyncTask.execute().then(function () {
-                return segmentsSyncTask.execute();
-            });
-        }
+        };
     };
 }
 exports.pollingManagerSSFactory = pollingManagerSSFactory;

package/cjs/sync/polling/updaters/definitionChangesUpdater.js

@@ -125,14 +125,14 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
             var since = sinces[0], rbSince = sinces[1];
             log.debug(constants_2.SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
             return Promise.resolve(instantUpdate ?
-                instantUpdate.type === constants_4.SPLIT_UPDATE ?
+                instantUpdate.type === constants_4.RB_SEGMENT_UPDATE ?
+                    { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                     // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
                     Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, constants_3.IN_RULE_BASED_SEGMENT))).then(function (contains) {
                         return contains ?
                             { d: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                             definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
                     }) :
-                    { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                 definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (definitionChanges) {
                 var usedSegments = new Set();

package/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -31,7 +31,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with since = ").concat(x.since, " and till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });

package/cjs/sync/streaming/AuthClient/index.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashUserKey = exports.authenticateFactory = void 0;
+exports.fetchAuthFactory = void 0;
 var objectAssign_1 = require("../../../utils/lang/objectAssign");
-var base64_1 = require("../../../utils/base64");
 var jwt_1 = require("../../../utils/jwt");
-var murmur3_1 = require("../../../utils/murmur3/murmur3");
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth - `ServiceApi.fetchAuth` endpoint
+ * @param fetchAuth - /auth endpoint
  */
-function authenticateFactory(fetchAuth) {
+function fetchAuthFactory(fetchAuth) {
     /**
      * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
      * @param userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
@@ -24,20 +22,21 @@ function authenticateFactory(fetchAuth) {
                 if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number')
                     throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
                 var channels = JSON.parse(decodedToken['x-ably-capability']);
-                return (0, objectAssign_1.objectAssign)({
+                var credential = (0, objectAssign_1.objectAssign)({
                     decodedToken: decodedToken,
                     channels: channels
                 }, json);
+                // The `/api/v3/auth` endpoint nests the streaming settings under `config.streaming`. Normalize
+                // them into the flat `pushEnabled`/`connDelay` properties used by the PushManager.
+                var streaming = credential.config && credential.config.streaming;
+                if (streaming) {
+                    credential.pushEnabled = streaming.enabled;
+                    credential.connDelay = streaming.delay;
+                }
+                return credential;
             }
             return json;
         });
     };
 }
-exports.authenticateFactory = authenticateFactory;
-/**
- * Returns the hash of a given user key
- */
-function hashUserKey(userKey) {
-    return (0, base64_1.encodeToBase64)((0, murmur3_1.hash)(userKey, 0).toString());
-}
-exports.hashUserKey = hashUserKey;
+exports.fetchAuthFactory = fetchAuthFactory;

package/cjs/sync/streaming/SSEHandler/index.js

@@ -74,6 +74,7 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             switch (parsedData.type) {
                 /* update events */
                 case constants_1.SPLIT_UPDATE:
+                case constants_1.CONFIG_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
                 case constants_1.MEMBERSHIPS_MS_UPDATE:
                 case constants_1.MEMBERSHIPS_LS_UPDATE:

package/cjs/sync/streaming/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.RB_SEGMENT_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MEMBERSHIPS_LS_UPDATE = exports.MEMBERSHIPS_MS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NON_RETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.RB_SEGMENT_UPDATE = exports.CONFIG_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MEMBERSHIPS_LS_UPDATE = exports.MEMBERSHIPS_MS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NON_RETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -30,6 +30,7 @@ exports.MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 exports.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';
+exports.CONFIG_UPDATE = 'CONFIG_UPDATE';
 exports.RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 exports.CONTROL = 'CONTROL';

package/cjs/sync/streaming/pushManager.js

@@ -7,7 +7,6 @@ var SSEHandler_1 = require("./SSEHandler");
 var MySegmentsUpdateWorker_1 = require("./UpdateWorkers/MySegmentsUpdateWorker");
 var SegmentsUpdateWorker_1 = require("./UpdateWorkers/SegmentsUpdateWorker");
 var DefinitionsUpdateWorker_1 = require("./UpdateWorkers/DefinitionsUpdateWorker");
-var AuthClient_1 = require("./AuthClient");
 var lang_1 = require("../../utils/lang");
 var SSEClient_1 = require("./SSEClient");
 var key_1 = require("../../utils/key");
@@ -37,7 +36,6 @@ function pushManagerFactory(params, pollingManager) {
         log.warn(constants_2.STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = (0, AuthClient_1.authenticateFactory)(serviceApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = (0, SSEHandler_1.SSEHandlerFactory)(log, pushEmitter, telemetryTracker);
@@ -47,8 +45,6 @@ function pushManagerFactory(params, pollingManager) {
     var segmentsUpdateWorker = userKey ? undefined : (0, SegmentsUpdateWorker_1.SegmentsUpdateWorker)(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
     var definitionsUpdateWorker = (0, DefinitionsUpdateWorker_1.DefinitionsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
-    // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
-    var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
@@ -93,7 +89,7 @@ function pushManagerFactory(params, pollingManager) {
         log.info(constants_2.STREAMING_CONNECTING);
         disconnected = false;
         var userKeys = userKey ? Object.keys(clients) : undefined;
-        authenticate(userKeys).then(function (authData) {
+        serviceApi.fetchAuth(userKeys).then(function (authData) {
             if (disconnected)
                 return;
             // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
@@ -181,8 +177,11 @@ function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
+    // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+    // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
     pushEmitter.on(constants_1.SPLIT_KILL, definitionsUpdateWorker.killDefinition);
     pushEmitter.on(constants_1.SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(constants_1.CONFIG_UPDATE, definitionsUpdateWorker.put);
     pushEmitter.on(constants_1.RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
@@ -285,9 +284,7 @@ function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var hash = (0, AuthClient_1.hashUserKey)(userKey);
-            if (!userKeyHashes[hash]) {
-                userKeyHashes[hash] = userKey;
+            if (!clients[userKey]) {
                 clients[userKey] = {
                     hash64: (0, murmur3_64_1.hash64)(userKey),
                     worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -308,8 +305,6 @@ function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = (0, AuthClient_1.hashUserKey)(userKey);
-            delete userKeyHashes[hash];
             delete clients[userKey];
         }
     });

package/cjs/sync/submitters/impressionsSubmitter.js

@@ -23,7 +23,7 @@ function fromImpressionsCollector(sendLabels, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
                     et: entry.entityType, // Definition type
                 };
             })

package/cjs/sync/syncManagerOnline.js

@@ -8,8 +8,6 @@ var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
 var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCacheSync");
-var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
-var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -17,18 +15,15 @@ var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher"
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
     return function (params) {
         var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :

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,32 @@ var Backoff = /** @class */ (function () {
             clearTimeout(this.timeoutID);
         this.attempts++;
         return new Promise(function (resolve, reject) {
+            _this.pending = { resolve: resolve, reject: reject };
             _this.timeoutID = setTimeout(function () {
                 _this.timeoutID = undefined;
+                _this.pending = 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
+     * and the caller wants to settle it immediately instead of waiting for `cb` to be invoked, pass `settle`:
+     * `{ value }` to resolve, or `{ error }` to reject.
      */
-    Backoff.prototype.reset = function () {
+    Backoff.prototype.reset = function (settle) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (settle && this.pending) {
+            if ('value' in settle)
+                this.pending.resolve(settle.value);
+            else
+                this.pending.reject(settle.error);
+            this.pending = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes

package/esm/evaluator/index.js

@@ -22,6 +22,12 @@ function treatmentsException(definitionNames) {
     });
     return evaluations;
 }
+function setEvaluationDataFromDefinition(evaluation, definition) {
+    return objectAssign(evaluation, {
+        definition: definition,
+        config: definition.configurations && definition.configurations[evaluation.treatment] || null
+    });
+}
 export function evaluateFeature(log, key, definitionName, attributes, storage) {
     var definition;
     try {
@@ -92,8 +98,8 @@ function getEvaluation(log, key, definition, attributes, storage) {
         var split = engineParser(log, definition, storage);
         var evaluation = split.getTreatment(key, attributes, evaluateFeature);
         return thenable(evaluation) ?
-            evaluation.then(function (result) { return objectAssign(result, { definition: definition }); }) :
-            objectAssign(evaluation, { definition: definition });
+            evaluation.then(function (result) { return setEvaluationDataFromDefinition(result, definition); }) :
+            setEvaluationDataFromDefinition(evaluation, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }
@@ -124,11 +130,10 @@ export function evaluateDefaultTreatment(definitionName, storage) {
 }
 function getDefaultTreatment(definition) {
     if (definition) {
-        return {
+        return setEvaluationDataFromDefinition({
             treatment: definition.defaultTreatment,
-            label: NO_CONDITION_MATCH,
-            definition: definition,
-        };
+            label: NO_CONDITION_MATCH, // "default rule"
+        }, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }

package/esm/presets/serverSide.js

@@ -1,4 +1,4 @@
-import { serviceApiFactory } from '../services/serviceApi';
+import { splitApiFactory } from '../services/splitApi';
 import { syncManagerOnlineFactory } from '../sync/syncManagerOnline';
 import { pushManagerFactory } from '../sync/streaming/pushManager';
 import { pollingManagerSSFactory } from '../sync/polling/pollingManagerSS';
@@ -6,10 +6,10 @@ import { InMemoryStorageFactory } from '../storages/inMemory/InMemoryStorage';
 import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
-var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 export var serverSideModules = {
     storageFactory: InMemoryStorageFactory,
-    serviceApiFactory: serviceApiFactory,
+    serviceApiFactory: splitApiFactory,
     syncManagerFactory: syncManagerOnlineSSFactory,
     sdkManagerFactory: sdkManagerFactory,
     sdkClientMethodFactory: sdkClientMethodFactory,

package/esm/sdkClient/client.js

@@ -108,13 +108,11 @@ export function clientFactory(params) {
     }
     // Internal function
     function processEvaluation(evaluation, featureFlagName, key, withConfig, invokingMethodName, queue, options) {
-        var _a;
         if (options === void 0) { options = {}; }
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
         var definition = evaluation.definition;
-        var treatment = evaluation.treatment, label = evaluation.label;
-        var config = ((_a = definition === null || definition === void 0 ? void 0 : definition.configurations) === null || _a === void 0 ? void 0 : _a[treatment]) || null;
+        var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === CONTROL) {
             var fallbackTreatment = fallbackCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
@@ -131,10 +129,10 @@ export function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: definition.changeNumber,
+                    changeNumber: definition === null || definition === void 0 ? void 0 : definition.changeNumber,
                     properties: stringify(options.properties)
                 },
-                disabled: options.impressionsDisabled || definition.impressionsDisabled
+                disabled: options.impressionsDisabled || (definition === null || definition === void 0 ? void 0 : definition.impressionsDisabled)
             });
         }
         if (withConfig) {

package/esm/sdkClient/sdkLifecycle.js

@@ -58,6 +58,8 @@ 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 () {
                 // Cleanup storage

package/esm/services/authProvider.js

@@ -1,4 +1,4 @@
-import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { TOKEN } from '../utils/constants';
@@ -6,32 +6,35 @@ var SKEW_SECONDS = 30;
 function isExpired(credential) {
     return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
 }
+function noCachedCredentialError() {
+    return new Error(LOG_PREFIX_SYNC_AUTH + 'stopped without a cached credential');
+}
 /**
  * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
  * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
  */
 export function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
     var urls = settings.urls, log = settings.log;
-    function fetchAuth() {
+    var fetchAuth = fetchAuthFactory(function () {
         var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
         return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
-    }
-    var authenticate = authenticateFactory(fetchAuth);
+    });
     var backoff = new Backoff(fetchCredential);
     var cachedCredential;
     var inFlightPromise;
     var stopped = false;
     function fetchCredential() {
-        return authenticate().then(function (credential) {
+        return fetchAuth().then(function (credential) {
             log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
             cachedCredential = credential;
             inFlightPromise = undefined;
             backoff.reset();
             return credential;
         }).catch(function (error) {
-            // Avoid rejected promises and unnecessary retries after stop()
+            // Avoid unnecessary retries after stop(): fall back to any cached credential, or reject
+            // (never resolve with `undefined`, which callers would otherwise send as an unauthenticated request).
             if (stopped)
-                return cachedCredential;
+                return cachedCredential || Promise.reject(noCachedCredentialError());
             if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
                 log.error(LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
                 inFlightPromise = undefined;
@@ -46,18 +49,28 @@ export function authProviderFactory(settings, splitHttpClient, telemetryTracker)
             if (cachedCredential && !isExpired(cachedCredential)) {
                 return Promise.resolve(cachedCredential);
             }
+            // Reuse any fetch already in flight (e.g. one started just before stop()), instead of firing a redundant one.
+            if (inFlightPromise)
+                return inFlightPromise;
+            // No cached credential to fall back to and stopped: reject so callers don't send an unauthenticated request.
+            if (stopped && !cachedCredential) {
+                return Promise.reject(noCachedCredentialError());
+            }
             if (cachedCredential)
                 log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
-            return inFlightPromise || (inFlightPromise = fetchCredential());
+            // If stopped, this is a last, bounded refetch: fetchCredential()'s catch short-circuits (no backoff retry)
+            // once stopped, so it's a single attempt that falls back to the stale cached credential on failure.
+            return inFlightPromise = fetchCredential();
         },
         invalidate: function () {
             cachedCredential = undefined;
         },
         stop: function () {
             stopped = true;
-            cachedCredential = undefined;
-            inFlightPromise = undefined;
-            backoff.reset();
+            // Keep any in-flight fetch and already-cached credential usable (e.g. by a final flush on destroy).
+            // If a retry is only pending (not actively in flight), settle it immediately instead of waiting out the
+            // backoff delay: with the cached credential if there is one, or rejected otherwise.
+            backoff.reset(cachedCredential ? { value: cachedCredential } : { error: noCachedCredentialError() });
         }
     };
 }

package/esm/services/secureSplitHttpClient.js

@@ -1,29 +1,26 @@
 import { __assign } from "tslib";
-import { splitHttpClientFactory } from './splitHttpClient';
-import { authProviderFactory } from './authProvider';
 /**
  * Factory of Secure HTTP client, which authenticates requests using a JWT token.
  * On 401 responses, invalidates the cached credential and retries once with a fresh token.
  *
- * @param settings - SDK settings
- * @param platform - object containing environment-specific dependencies
- * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
+ * @param splitHttpClient - `splitHttpClientFactory` to use for making requests
+ * @param authProvider - `authProviderFactory` to use for authentication
  */
-export function secureSplitHttpClientFactory(settings, platform, telemetryTracker) {
-    var splitHttpClient = splitHttpClientFactory(settings, platform);
-    var authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
-    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
+export function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
     }
-    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt) {
+        if (newVersionHeader === void 0) { newVersionHeader = true; }
+        if (useJwt === void 0) { useJwt = true; }
         return authProvider.credential().then(function (credential) {
-            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
                 .catch(function (error) {
                 if (error.statusCode === 401) {
                     // retry once for 401, in case the token has just expired
                     authProvider.invalidate();
                     return authProvider.credential().then(function (newCredential) {
-                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
                     });
                 }
                 throw error;