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

package/esm/sdkClient/trackMethod.js

@@ -0,0 +1,52 @@
+import { thenable } from '../utils/promise/thenable';
+import { getMatching } from '../utils/key';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateKey, validateTrafficType, validateEvent, validateEventValue, validateEventProperties, validateIfNotDestroyed } from '../utils/inputValidation';
+import { TRACK, TRACK_FN_LABEL } from '../utils/constants';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+/**
+ * Creates a standalone `track` function with input validation.
+ * Reusable by FF SDK client, Configs SDK, and thin-client SDK.
+ */
+export function trackMethodFactory(params, warnTTExistence) {
+    if (warnTTExistence === void 0) { warnTTExistence = true; }
+    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) {
+        // Input validation
+        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+        var trafficTypeName = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+        var eventTypeId = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+        var value = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
+        if (!(isNotDestroyed && key && trafficTypeName && eventTypeId && value !== false && properties !== false)) {
+            return isAsync ? Promise.resolve(false) : false;
+        }
+        // Core logic
+        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+        var eventData = {
+            eventTypeId: eventTypeId,
+            trafficTypeName: trafficTypeName,
+            value: value,
+            timestamp: Date.now(),
+            key: getMatching(key),
+            properties: properties
+        };
+        // 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, definitions, mode, trafficTypeName, TRACK_FN_LABEL);
+        var result = eventTracker.track(eventData, size);
+        if (thenable(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
+    };
+}

package/esm/sdkFactory/index.js

@@ -2,16 +2,10 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 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 { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
 import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
@@ -19,19 +13,10 @@ import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCal
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
-    var log = settings.log, impressionsMode = settings.sync.impressionsMode, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // initialization
-    var hasInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (hasInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
     var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -42,54 +27,33 @@ 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 fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+    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);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
-    var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-    var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-    var strategy = impressionsMode === OPTIMIZED ?
-        strategyOptimizedFactory(observer, storage.impressionCounts) :
-        impressionsMode === DEBUG ?
-            strategyDebugFactory(observer) :
-            noneStrategy;
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
-    var syncManager = syncManagerFactory && syncManagerFactory(ctx);
-    ctx.syncManager = syncManager;
-    var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-    ctx.signalListener = signalListener;
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackCalculator: fallbackCalculator };
+    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() {
-        if (hasInit)
-            return;
-        hasInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        validateAndTrackApiKey(log, settings.core.authorizationKey);
-        readiness.init();
-        uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
+        Object.keys(clients).map(function (key) { return clients[key].init(); });
     }
     log.info(NEW_FACTORY, [settings.version]);
     // @ts-ignore
@@ -105,7 +69,6 @@ export function sdkFactory(params) {
         Logger: createLoggerAPI(log),
         settings: settings,
         destroy: function () {
-            hasInit = false;
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
     }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());

package/esm/sdkManager/index.js

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
+import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 function collectTreatments(splitObject) {
@@ -50,18 +50,18 @@ export function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag object corresponding to the given feature flag name if valid
          */
         split: function (featureFlagName) {
-            var splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
+            var splitName = validateDefinition(log, featureFlagName, SPLIT_FN_LABEL);
             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) {
-                    validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+                    validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+            validateDefinitionExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**
@@ -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,23 +13,24 @@ 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 () {
-            var url = urls.sdk + "/version";
+            var url = "".concat(urls.sdk, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         getEventsAPIHealthCheck: function () {
-            var url = urls.events + "/version";
+            var url = "".concat(urls.events, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth?s=" + settings.sync.flagSpecVersion;
+            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
             if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
                 var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
                 if (queryParams)
@@ -38,7 +39,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
-            var url = urls.sdk + "/splitChanges?s=" + settings.sync.flagSpecVersion + "&since=" + since + (rbSince ? '&rbSince=' + rbSince : '') + (filterQueryString || '') + (till ? '&till=' + till : '');
+            var url = "".concat(urls.sdk, "/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)
@@ -46,8 +47,13 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
                 throw err;
             });
         },
+        // @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 (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
+        },
         fetchSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
+            var url = "".concat(urls.sdk, "/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
         fetchMemberships: function (userMatchingKey, noCache, till) {
@@ -57,7 +63,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
              *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
+            var url = "".concat(urls.sdk, "/memberships/").concat(encodeURIComponent(userMatchingKey)).concat(till ? '?till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
         },
         /**
@@ -67,7 +73,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postEventsBulk: function (body, headers) {
-            var url = urls.events + "/events/bulk";
+            var url = "".concat(urls.events, "/events/bulk");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
         },
         /**
@@ -77,7 +83,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postTestImpressionsBulk: function (body, headers) {
-            var url = urls.events + "/testImpressions/bulk";
+            var url = "".concat(urls.events, "/testImpressions/bulk");
             return splitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
@@ -92,7 +98,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postTestImpressionsCount: function (body, headers) {
-            var url = urls.events + "/testImpressions/count";
+            var url = "".concat(urls.events, "/testImpressions/count");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
         /**
@@ -102,7 +108,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postUniqueKeysBulkCs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/cs";
+            var url = "".concat(urls.telemetry, "/v1/keys/cs");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
         },
         /**
@@ -112,16 +118,20 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postUniqueKeysBulkSs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/ss";
+            var url = "".concat(urls.telemetry, "/v1/keys/ss");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
         },
         postMetricsConfig: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/config";
+            var url = "".concat(urls.telemetry, "/v1/metrics/config");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         },
         postMetricsUsage: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/usage";
+            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/services/splitHttpClient.js

@@ -21,7 +21,7 @@ export function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
+        'Authorization': "Bearer ".concat(authorizationKey),
         'SplitSDKVersion': version
     };
     if (ip)

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

@@ -10,34 +10,34 @@ var KeyBuilder = /** @class */ (function () {
         this.prefix = prefix;
     }
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
-        return this.prefix + ".trafficType." + trafficType;
+        return "".concat(this.prefix, ".trafficType.").concat(trafficType);
     };
-    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return this.prefix + ".flagSet." + flagSet;
+    KeyBuilder.prototype.buildSetKey = function (set) {
+        return "".concat(this.prefix, ".flagSet.").concat(set);
     };
-    KeyBuilder.prototype.buildSplitKey = function (splitName) {
-        return this.prefix + ".split." + splitName;
+    KeyBuilder.prototype.buildDefinitionKey = function (definitionName) {
+        return "".concat(this.prefix, ".split.").concat(definitionName);
     };
-    KeyBuilder.prototype.buildSplitsTillKey = function () {
-        return this.prefix + ".splits.till";
+    KeyBuilder.prototype.buildDefinitionsTillKey = function () {
+        return "".concat(this.prefix, ".splits.till");
     };
-    KeyBuilder.prototype.buildSplitKeyPrefix = function () {
-        return this.prefix + ".split.";
+    KeyBuilder.prototype.buildDefinitionKeyPrefix = function () {
+        return "".concat(this.prefix, ".split.");
     };
     KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {
-        return this.prefix + ".rbsegment." + rbsegmentName;
+        return "".concat(this.prefix, ".rbsegment.").concat(rbsegmentName);
     };
     KeyBuilder.prototype.buildRBSegmentsTillKey = function () {
-        return this.prefix + ".rbsegments.till";
+        return "".concat(this.prefix, ".rbsegments.till");
     };
     KeyBuilder.prototype.buildRBSegmentKeyPrefix = function () {
-        return this.prefix + ".rbsegment.";
+        return "".concat(this.prefix, ".rbsegment.");
     };
     KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName;
+        return "".concat(this.prefix, ".segment.").concat(segmentName);
     };
     KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName + ".till";
+        return "".concat(this.prefix, ".segment.").concat(segmentName, ".till");
     };
     KeyBuilder.prototype.extractKey = function (builtKey) {
         var s = builtKey.match(everythingAtTheEnd);
@@ -49,7 +49,7 @@ var KeyBuilder = /** @class */ (function () {
         }
     };
     KeyBuilder.prototype.buildHashKey = function () {
-        return this.prefix + ".hash";
+        return "".concat(this.prefix, ".hash");
     };
     return KeyBuilder;
 }());
@@ -59,5 +59,5 @@ export { KeyBuilder };
  * The hash is in hexadecimal format (8 characters max, 32 bits).
  */
 export function getStorageHash(settings) {
-    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString + "::" + settings.sync.flagSpecVersion).toString(16);
+    return hash("".concat(settings.core.authorizationKey, "::").concat(settings.sync.__splitFiltersValidation.queryString, "::").concat(settings.sync.flagSpecVersion)).toString(16);
 }