@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.1

package/esm/logger/constants.js

@@ -54,7 +54,6 @@ export var USER_CONSENT_INITIAL = 124;
 export var SUBMITTERS_PUSH_PAGE_HIDDEN = 125;
 export var ENGINE_VALUE_INVALID = 200;
 export var ENGINE_VALUE_NO_ATTRIBUTES = 201;
-export var CLIENT_NO_LISTENER = 202;
 export var CLIENT_NOT_READY_FROM_CACHE = 203;
 export var SYNC_FETCH_RETRY = 204;
 export var SYNC_FETCH_FAILS = 205;
@@ -119,6 +118,7 @@ export var LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';
 export var LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';
 export var LOG_PREFIX_ENGINE_VALUE = LOG_PREFIX_ENGINE + ':value: ';
 export var LOG_PREFIX_SYNC = 'sync: ';
+export var LOG_PREFIX_SYNC_AUTH = 'sync:auth: ';
 export var LOG_PREFIX_SYNC_MANAGER = 'sync:sync-manager: ';
 export var LOG_PREFIX_SYNC_OFFLINE = 'sync:offline: ';
 export var LOG_PREFIX_SYNC_STREAMING = 'sync:streaming: ';

package/esm/logger/messages/warn.js

@@ -14,7 +14,6 @@ export var codesWarn = codesError.concat([
     [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s'],
     // client status
     [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
-    [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
     // input validation
     [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
     [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],

package/esm/readiness/constants.js

@@ -1,6 +1,6 @@
-// Splits events:
-export var SDK_SPLITS_ARRIVED = 'state::splits-arrived';
-export var SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
+// Definitions events:
+export var SDK_DEFINITIONS_ARRIVED = 'state::splits-arrived';
+export var SDK_DEFINITIONS_CACHE_LOADED = 'state::splits-cache-loaded';
 // Segments events:
 export var SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';
 // Readiness events:

package/esm/readiness/readinessManager.js

@@ -1,19 +1,19 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-function splitsEventEmitterFactory(EventEmitter) {
-    var splitsEventEmitter = objectAssign(new EventEmitter(), {
-        splitsArrived: false,
-        splitsCacheLoaded: false,
+import { SDK_DEFINITIONS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
+function definitionsEventEmitterFactory(EventEmitter) {
+    var definitionsEventEmitter = objectAssign(new EventEmitter(), {
+        definitionsArrived: false,
+        definitionsCacheLoaded: false,
         hasInit: false,
         initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-    splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
-        splitsEventEmitter.splitsArrived = true; });
-    splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
-    return splitsEventEmitter;
+    definitionsEventEmitter.on(SDK_DEFINITIONS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
+        definitionsEventEmitter.definitionsArrived = true; });
+    definitionsEventEmitter.once(SDK_DEFINITIONS_CACHE_LOADED, function () { definitionsEventEmitter.definitionsCacheLoaded = true; });
+    return definitionsEventEmitter;
 }
 function segmentsEventEmitterFactory(EventEmitter) {
     var segmentsEventEmitter = objectAssign(new EventEmitter(), {
@@ -25,8 +25,8 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
-    if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
+export function readinessManagerFactory(EventEmitter, settings, definitions, isShared) {
+    if (definitions === void 0) { definitions = definitionsEventEmitterFactory(EventEmitter); }
     var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
     var gate = new EventEmitter();
@@ -41,10 +41,10 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     };
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
-    if (splits.splitsCacheLoaded)
+    if (definitions.definitionsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
-        splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
+        definitions.once(SDK_DEFINITIONS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
@@ -56,7 +56,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
-    splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
+    definitions.on(SDK_DEFINITIONS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
     var readyTimeoutId;
@@ -65,8 +65,8 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         if (readyTimeout > 0 && !isReady)
             readyTimeoutId = setTimeout(timeout, readyTimeout);
     }
-    splits.initCallbacks.push(__init);
-    if (splits.hasInit)
+    definitions.initCallbacks.push(__init);
+    if (definitions.hasInit)
         __init();
     function checkIsReadyFromCache(cacheMetadata) {
         metadataReady = cacheMetadata;
@@ -97,7 +97,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
             }
         }
         else {
-            if (splits.splitsArrived && segments.segmentsArrived) {
+            if (definitions.definitionsArrived && segments.segmentsArrived) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
@@ -120,11 +120,11 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     return {
-        splits: splits,
+        definitions: definitions,
         segments: segments,
         gate: gate,
         shared: function () {
-            return readinessManagerFactory(EventEmitter, settings, splits, true);
+            return readinessManagerFactory(EventEmitter, settings, definitions, true);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -133,17 +133,17 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
         init: function () {
-            if (splits.hasInit)
+            if (definitions.hasInit)
                 return;
-            splits.hasInit = true;
-            splits.initCallbacks.forEach(function (cb) { return cb(); });
+            definitions.hasInit = true;
+            definitions.initCallbacks.forEach(function (cb) { return cb(); });
         },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();
             clearTimeout(readyTimeoutId);
             if (!isShared)
-                splits.hasInit = false;
+                definitions.hasInit = false;
         },
         isReady: function () { return isReady; },
         isReadyFromCache: function () { return isReadyFromCache; },

package/esm/readiness/sdkReadinessManager.js

@@ -2,9 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
+import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY } from '../logger/constants';
 var NEW_LISTENER_EVENT = 'newListener';
-var REMOVE_LISTENER_EVENT = 'removeListener';
 var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
@@ -16,21 +15,11 @@ var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 export function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
     if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, settings); }
     var log = settings.log;
-    /** Ready callback warning */
-    var internalReadyCbCount = 0;
-    var readyCbCount = 0;
-    readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
-        if (event === SDK_READY)
-            readyCbCount--;
-    });
     readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
         if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
             if (readinessManager.isReady()) {
                 log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
             }
-            else if (event === SDK_READY) {
-                readyCbCount++;
-            }
         }
         else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
             log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
@@ -49,8 +38,6 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         var promise = promiseWrapper(new Promise(function (resolve, reject) {
             readinessManager.gate.once(SDK_READY, function () {
                 log.info(CLIENT_READY);
-                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())
-                    log.warn(CLIENT_NO_LISTENER);
                 resolve();
             });
             readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {
@@ -75,9 +62,6 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         shared: function () {
             return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
         },
-        incInternalReadyCbCount: function () {
-            internalReadyCbCount++;
-        },
         sdkStatus: objectAssign(
         // Expose Event Emitter functionality
         Object.create(readinessManager.gate), {

package/esm/sdkClient/sdkLifecycle.js

@@ -4,7 +4,7 @@ var COOLDOWN_TIME_IN_MILLIS = 1000;
  * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkLifecycleFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker, platform = params.platform;
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker, platform = params.platform, splitApi = params.splitApi;
     var hasInit = false;
     var lastActionTime = 0;
     var signalListener = platform.SignalListener && new platform.SignalListener(params);
@@ -57,6 +57,7 @@ export function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
+            splitApi && splitApi.stop();
             return __flush().then(function () {
                 // Cleanup storage
                 return storage.destroy();

package/esm/sdkClient/trackMethod.js

@@ -10,7 +10,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  */
 export function trackMethodFactory(params, warnTTExistence) {
     if (warnTTExistence === void 0) { warnTTExistence = true; }
-    var settings = params.settings, splits = params.storage.splits, telemetryTracker = params.telemetryTracker, eventTracker = params.eventTracker, readinessManager = params.sdkReadinessManager.readinessManager;
+    var settings = params.settings, definitions = params.storage.definitions, telemetryTracker = params.telemetryTracker, eventTracker = params.eventTracker, readinessManager = params.sdkReadinessManager.readinessManager;
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     return function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
@@ -36,7 +36,7 @@ export function trackMethodFactory(params, warnTTExistence) {
         };
         // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
         if (warnTTExistence)
-            validateTrafficTypeExistence(log, readinessManager, splits, mode, trafficTypeName, TRACK_FN_LABEL);
+            validateTrafficTypeExistence(log, readinessManager, definitions, mode, trafficTypeName, TRACK_FN_LABEL);
         var result = eventTracker.track(eventData, size);
         if (thenable(result)) {
             return result.then(function (result) {

package/esm/sdkFactory/index.js

@@ -4,7 +4,7 @@ import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
@@ -27,18 +27,18 @@ export function sdkFactory(params) {
                 readiness.timeout();
                 return;
             }
-            readiness.splits.emit(SDK_SPLITS_ARRIVED);
+            readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED);
         }
     });
     var fallbackCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
-        if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
+        if (storage.definitions.getChangeNumber() > -1)
+            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
     }
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
@@ -51,7 +51,7 @@ export function sdkFactory(params) {
     ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx);
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.definitions, sdkReadinessManager);
     function init() {
         Object.keys(clients).map(function (key) { return clients[key].init(); });
     }

package/esm/sdkManager/index.js

@@ -54,7 +54,7 @@ export function sdkManagerFactory(settings, splits, _a) {
             if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
                 return isAsync ? Promise.resolve(null) : null;
             }
-            var split = splits.getSplit(splitName);
+            var split = splits.get(splitName);
             if (thenable(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
                     validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
@@ -83,7 +83,7 @@ export function sdkManagerFactory(settings, splits, _a) {
             if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
-            var splitNames = splits.getSplitNames();
+            var splitNames = splits.getNames();
             return thenable(splitNames) ?
                 splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage
                 splitNames;

package/esm/services/authProvider.js

@@ -0,0 +1,63 @@
+import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { Backoff } from '../utils/Backoff';
+import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
+import { TOKEN } from '../utils/constants';
+var SKEW_SECONDS = 30;
+function isExpired(credential) {
+    return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
+}
+/**
+ * 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 url = "".concat(urls.auth, "/v3/auth?capabilities=config");
+        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+    }
+    var authenticate = authenticateFactory(fetchAuth);
+    var backoff = new Backoff(fetchCredential);
+    var cachedCredential;
+    var inFlightPromise;
+    var stopped = false;
+    function fetchCredential() {
+        return authenticate().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()
+            if (stopped)
+                return cachedCredential;
+            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;
+                throw error;
+            }
+            log.warn(LOG_PREFIX_SYNC_AUTH + 'credential fetch failed (attempt ' + (backoff.attempts + 1) + '). Error: ' + error.message);
+            return backoff.scheduleCallAsync();
+        });
+    }
+    return {
+        credential: function () {
+            if (cachedCredential && !isExpired(cachedCredential)) {
+                return Promise.resolve(cachedCredential);
+            }
+            if (cachedCredential)
+                log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
+            return inFlightPromise || (inFlightPromise = fetchCredential());
+        },
+        invalidate: function () {
+            cachedCredential = undefined;
+        },
+        stop: function () {
+            stopped = true;
+            cachedCredential = undefined;
+            inFlightPromise = undefined;
+            backoff.reset();
+        }
+    };
+}

package/esm/services/secureSplitHttpClient.js

@@ -0,0 +1,35 @@
+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
+ */
+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);
+    }
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
+        return authProvider.credential().then(function (credential) {
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+                .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);
+                    });
+                }
+                throw error;
+            });
+        });
+    };
+    httpClient.stop = function () { return authProvider.stop(); };
+    return httpClient;
+}

package/esm/services/splitApi.js

@@ -13,11 +13,12 @@ function userKeyToQueryParam(userKey) {
  * @param platform - object containing environment-specific dependencies
  * @param telemetryTracker - telemetry tracker
  */
-export function splitApiFactory(settings, platform, telemetryTracker) {
+export function splitApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
     var urls = settings.urls;
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform);
+    var secureSplitHttpClient = secureSplitHttpClientFactory ? secureSplitHttpClientFactory(settings, platform, telemetryTracker) : undefined;
     return {
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
@@ -49,7 +50,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
         fetchConfigs: function (since, noCache, till) {
             var url = "".concat(urls.sdk, "/v1/configs?since=").concat(since).concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+            return (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
         },
         fetchSegmentChanges: function (since, segmentName, noCache, till) {
             var url = "".concat(urls.sdk, "/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
@@ -127,6 +128,10 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         postMetricsUsage: function (body, headers) {
             var url = "".concat(urls.telemetry, "/v1/metrics/usage");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
+        },
+        stop: function () {
+            if (secureSplitHttpClient)
+                secureSplitHttpClient.stop();
         }
     };
 }

package/esm/storages/AbstractDefinitionsCacheAsync.js

@@ -0,0 +1,48 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+/**
+ * This class provides a skeletal implementation of the IDefinitionsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractDefinitionsCacheAsync = /** @class */ (function () {
+    function AbstractDefinitionsCacheAsync() {
+    }
+    AbstractDefinitionsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        return Promise.all([
+            this.setChangeNumber(changeNumber),
+            Promise.all(toAdd.map(function (addedFF) { return _this.add(addedFF); })),
+            Promise.all(toRemove.map(function (removedFF) { return _this.remove(removedFF); }))
+        ]).then(function (_a) {
+            var added = _a[1], removed = _a[2];
+            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+        });
+    };
+    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
+    AbstractDefinitionsCacheAsync.prototype.usesSegments = function () {
+        return Promise.resolve(true);
+    };
+    /**
+     * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns a promise that is resolved once the definition kill operation is performed. The fulfillment value is a boolean: `true` if the operation succeeded updating the definition or `false` if no definition is updated,
+     * for instance, if the `changeNumber` is old, or if the definition is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     * The promise will never be rejected.
+     */
+    AbstractDefinitionsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var _this = this;
+        return this.get(name).then(function (definition) {
+            if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
+                var newDefinition = objectAssign({}, definition);
+                newDefinition.killed = true;
+                newDefinition.defaultTreatment = defaultTreatment;
+                newDefinition.changeNumber = changeNumber;
+                return _this.add(newDefinition);
+            }
+            return false;
+        }).catch(function () { return false; });
+    };
+    return AbstractDefinitionsCacheAsync;
+}());
+export { AbstractDefinitionsCacheAsync };

package/esm/storages/AbstractDefinitionsCacheSync.js

@@ -0,0 +1,71 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
+/**
+ * This class provides a skeletal implementation of the IDefinitionsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractDefinitionsCacheSync = /** @class */ (function () {
+    function AbstractDefinitionsCacheSync() {
+    }
+    AbstractDefinitionsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        var updated = toAdd.map(function (addedFF) { return _this.add(addedFF); }).some(function (result) { return result; });
+        updated = toRemove.map(function (removedFF) { return _this.remove(removedFF); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
+    };
+    AbstractDefinitionsCacheSync.prototype.getMany = function (names) {
+        var _this = this;
+        var definitions = {};
+        names.forEach(function (name) {
+            definitions[name] = _this.get(name);
+        });
+        return definitions;
+    };
+    AbstractDefinitionsCacheSync.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
+    /**
+     * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns `true` if the operation successed updating the definition, or `false` if no definition is updated,
+     * for instance, if the `changeNumber` is old, or if the definition is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     */
+    AbstractDefinitionsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var definition = this.get(name);
+        if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
+            var newDefinition = objectAssign({}, definition);
+            newDefinition.killed = true;
+            newDefinition.defaultTreatment = defaultTreatment;
+            newDefinition.changeNumber = changeNumber;
+            return this.add(newDefinition);
+        }
+        return false;
+    };
+    return AbstractDefinitionsCacheSync;
+}());
+export { AbstractDefinitionsCacheSync };
+/**
+ * Given a parsed definition, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
+ * This util is intended to simplify the implementation of `definitionsCache::usesSegments` method
+ */
+export function usesSegments(ruleEntity) {
+    var conditions = ruleEntity.conditions || [];
+    for (var i = 0; i < conditions.length; i++) {
+        var matchers = conditions[i].matcherGroup.matchers;
+        for (var j = 0; j < matchers.length; j++) {
+            var matcher = matchers[j].matcherType;
+            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
+                return true;
+        }
+    }
+    var excluded = ruleEntity.excluded;
+    if (excluded && excluded.segments && excluded.segments.length > 0)
+        return true;
+    return false;
+}
+export function usesSegmentsSync(storage) {
+    return storage.definitions.usesSegments() || storage.rbSegments.usesSegments();
+}

package/esm/storages/KeyBuilder.js

@@ -12,16 +12,16 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
         return "".concat(this.prefix, ".trafficType.").concat(trafficType);
     };
-    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return "".concat(this.prefix, ".flagSet.").concat(flagSet);
+    KeyBuilder.prototype.buildSetKey = function (set) {
+        return "".concat(this.prefix, ".flagSet.").concat(set);
     };
-    KeyBuilder.prototype.buildSplitKey = function (splitName) {
-        return "".concat(this.prefix, ".split.").concat(splitName);
+    KeyBuilder.prototype.buildDefinitionKey = function (definitionName) {
+        return "".concat(this.prefix, ".split.").concat(definitionName);
     };
-    KeyBuilder.prototype.buildSplitsTillKey = function () {
+    KeyBuilder.prototype.buildDefinitionsTillKey = function () {
         return "".concat(this.prefix, ".splits.till");
     };
-    KeyBuilder.prototype.buildSplitKeyPrefix = function () {
+    KeyBuilder.prototype.buildDefinitionKeyPrefix = function () {
         return "".concat(this.prefix, ".split.");
     };
     KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {

package/esm/storages/KeyBuilderCS.js

@@ -6,7 +6,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     function KeyBuilderCS(prefix, matchingKey) {
         var _this = _super.call(this, prefix) || this;
         _this.matchingKey = matchingKey;
-        _this.regexSplitsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
+        _this.regexDefinitionsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
         return _this;
     }
     /**
@@ -23,19 +23,19 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return "".concat(this.prefix, ".splits.lastUpdated");
     };
-    KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
-        return this.regexSplitsCacheKey.test(key);
+    KeyBuilderCS.prototype.isDefinitionsCacheKey = function (key) {
+        return this.regexDefinitionsCacheKey.test(key);
     };
     KeyBuilderCS.prototype.buildTillKey = function () {
         return "".concat(this.prefix, ".").concat(this.matchingKey, ".segments.till");
     };
-    KeyBuilderCS.prototype.isSplitKey = function (key) {
+    KeyBuilderCS.prototype.isDefinitionKey = function (key) {
         return startsWith(key, "".concat(this.prefix, ".split."));
     };
     KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
         return startsWith(key, "".concat(this.prefix, ".rbsegment."));
     };
-    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
+    KeyBuilderCS.prototype.buildDefinitionsWithSegmentCountKey = function () {
         return "".concat(this.prefix, ".splits.usingSegments");
     };
     KeyBuilderCS.prototype.buildLastClear = function () {

package/esm/storages/KeyBuilderSS.js

@@ -36,8 +36,8 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return "".concat(this.prefix, ".events");
     };
-    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
-        return "".concat(this.buildSplitKeyPrefix(), "*");
+    KeyBuilderSS.prototype.searchPatternForDefinitionKeys = function () {
+        return "".concat(this.buildDefinitionKeyPrefix(), "*");
     };
     KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
         return "".concat(this.buildRBSegmentKeyPrefix(), "*");