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

package/cjs/sdkClient/sdkLifecycle.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkLifecycleFactory = void 0;
+var apiKey_1 = require("../utils/inputValidation/apiKey");
+var COOLDOWN_TIME_IN_MILLIS = 1000;
+/**
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
+ */
+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, splitApi = params.splitApi;
+    var hasInit = false;
+    var lastActionTime = 0;
+    var signalListener = platform.SignalListener && new platform.SignalListener(params);
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
+    return {
+        init: function () {
+            if (hasInit)
+                return;
+            hasInit = true;
+            if (!isSharedClient) {
+                (0, apiKey_1.validateAndTrackApiKey)(settings.log, settings.core.authorizationKey);
+                sdkReadinessManager.readinessManager.init();
+                impressionsTracker.start();
+                syncManager && syncManager.start();
+                signalListener && signalListener.start();
+            }
+        },
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
+        destroy: function () {
+            hasInit = false;
+            // Mark the SDK as destroyed immediately
+            sdkReadinessManager.readinessManager.destroy();
+            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+            if (!isSharedClient) {
+                (0, apiKey_1.releaseApiKey)(settings.core.authorizationKey);
+                telemetryTracker.sessionLength();
+                signalListener && signalListener.stop();
+                impressionsTracker.stop();
+            }
+            // Stop background jobs
+            syncManager && syncManager.stop();
+            splitApi && splitApi.stop();
+            return __flush().then(function () {
+                // Cleanup storage
+                return storage.destroy();
+            });
+        }
+    };
+}
+exports.sdkLifecycleFactory = sdkLifecycleFactory;

package/cjs/sdkClient/trackMethod.js

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

package/cjs/sdkFactory/index.js

@@ -5,16 +5,10 @@ var sdkReadinessManager_1 = require("../readiness/sdkReadinessManager");
 var impressionsTracker_1 = require("../trackers/impressionsTracker");
 var eventTracker_1 = require("../trackers/eventTracker");
 var telemetryTracker_1 = require("../trackers/telemetryTracker");
-var apiKey_1 = require("../utils/inputValidation/apiKey");
 var sdkLogger_1 = require("../logger/sdkLogger");
 var constants_1 = require("../logger/constants");
 var constants_2 = require("../readiness/constants");
 var objectAssign_1 = require("../utils/lang/objectAssign");
-var strategyDebug_1 = require("../trackers/strategy/strategyDebug");
-var strategyOptimized_1 = require("../trackers/strategy/strategyOptimized");
-var strategyNone_1 = require("../trackers/strategy/strategyNone");
-var uniqueKeysTracker_1 = require("../trackers/uniqueKeysTracker");
-var constants_3 = require("../utils/constants");
 var setRolloutPlan_1 = require("../storages/setRolloutPlan");
 var key_1 = require("../utils/key");
 var fallbackTreatmentsCalculator_1 = require("../evaluator/fallbackTreatmentsCalculator");
@@ -22,19 +16,10 @@ var fallbackTreatmentsCalculator_1 = require("../evaluator/fallbackTreatmentsCal
  * Modular SDK factory
  */
 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 = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -45,54 +30,33 @@ function sdkFactory(params) {
                 readiness.timeout();
                 return;
             }
-            readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
+            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED);
         }
     });
-    var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.fallbackTreatments);
+    var fallbackCalculator = (0, fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator)(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
-        if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
+        if (storage.definitions.getChangeNumber() > -1)
+            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
     }
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
-    var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-    var noneStrategy = (0, strategyNone_1.strategyNoneFactory)(storage.impressionCounts, uniqueKeysTracker);
-    var strategy = impressionsMode === constants_3.OPTIMIZED ?
-        (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts) :
-        impressionsMode === constants_3.DEBUG ?
-            (0, strategyDebug_1.strategyDebugFactory)(observer) :
-            noneStrategy;
-    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(params, storage, integrationsManager);
+    var eventTracker = (0, eventTracker_1.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.
-        (0, apiKey_1.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(constants_1.NEW_FACTORY, [settings.version]);
     // @ts-ignore
@@ -108,7 +72,6 @@ function sdkFactory(params) {
         Logger: (0, sdkLogger_1.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/cjs/sdkManager/index.js

@@ -53,18 +53,18 @@ function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag object corresponding to the given feature flag name if valid
          */
         split: function (featureFlagName) {
-            var splitName = (0, inputValidation_1.validateSplit)(log, featureFlagName, constants_1.SPLIT_FN_LABEL);
+            var splitName = (0, inputValidation_1.validateDefinition)(log, featureFlagName, constants_1.SPLIT_FN_LABEL);
             if (!(0, inputValidation_1.validateIfOperational)(log, readinessManager, constants_1.SPLIT_FN_LABEL) || !splitName) {
                 return isAsync ? Promise.resolve(null) : null;
             }
-            var split = splits.getSplit(splitName);
+            var split = splits.get(splitName);
             if ((0, thenable_1.thenable)(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, result, constants_1.SPLIT_FN_LABEL);
+                    (0, inputValidation_1.validateDefinitionExistence)(log, readinessManager, splitName, result, constants_1.SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, split, constants_1.SPLIT_FN_LABEL);
+            (0, inputValidation_1.validateDefinitionExistence)(log, readinessManager, splitName, split, constants_1.SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**
@@ -86,7 +86,7 @@ function sdkManagerFactory(settings, splits, _a) {
             if (!(0, inputValidation_1.validateIfOperational)(log, readinessManager, constants_1.NAMES_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
-            var splitNames = splits.getSplitNames();
+            var splitNames = splits.getNames();
             return (0, thenable_1.thenable)(splitNames) ?
                 splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage
                 splitNames;

package/cjs/services/authProvider.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authProviderFactory = void 0;
+var AuthClient_1 = require("../sync/streaming/AuthClient");
+var Backoff_1 = require("../utils/Backoff");
+var constants_1 = require("../logger/constants");
+var constants_2 = require("../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.
+ */
+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(constants_2.TOKEN));
+    }
+    var authenticate = (0, AuthClient_1.authenticateFactory)(fetchAuth);
+    var backoff = new Backoff_1.Backoff(fetchCredential);
+    var cachedCredential;
+    var inFlightPromise;
+    var stopped = false;
+    function fetchCredential() {
+        return authenticate().then(function (credential) {
+            log.info(constants_1.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(constants_1.LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
+                inFlightPromise = undefined;
+                throw error;
+            }
+            log.warn(constants_1.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(constants_1.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();
+        }
+    };
+}
+exports.authProviderFactory = authProviderFactory;

package/cjs/services/secureSplitHttpClient.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureSplitHttpClientFactory = void 0;
+var tslib_1 = require("tslib");
+var splitHttpClient_1 = require("./splitHttpClient");
+var authProvider_1 = require("./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
+ */
+function secureSplitHttpClientFactory(settings, platform, telemetryTracker) {
+    var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform);
+    var authProvider = (0, authProvider_1.authProviderFactory)(settings, splitHttpClient, telemetryTracker);
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
+        return splitHttpClient(url, tslib_1.__assign(tslib_1.__assign({}, options), { headers: tslib_1.__assign(tslib_1.__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;
+}
+exports.secureSplitHttpClientFactory = secureSplitHttpClientFactory;

package/cjs/services/splitApi.js

@@ -16,23 +16,24 @@ function userKeyToQueryParam(userKey) {
  * @param platform - object containing environment-specific dependencies
  * @param telemetryTracker - telemetry tracker
  */
-function splitApiFactory(settings, platform, telemetryTracker) {
+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 = (0, splitHttpClient_1.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)
@@ -41,7 +42,7 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.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(constants_1.SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)
@@ -49,8 +50,13 @@ 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(constants_1.SEGMENT));
         },
         fetchMemberships: function (userMatchingKey, noCache, till) {
@@ -60,7 +66,7 @@ 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(constants_1.MEMBERSHIPS));
         },
         /**
@@ -70,7 +76,7 @@ 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(constants_1.EVENTS));
         },
         /**
@@ -80,7 +86,7 @@ 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',
@@ -95,7 +101,7 @@ 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(constants_1.IMPRESSIONS_COUNT));
         },
         /**
@@ -105,7 +111,7 @@ 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(constants_1.TELEMETRY));
         },
         /**
@@ -115,16 +121,20 @@ 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(constants_1.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(constants_1.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(constants_1.TELEMETRY), true);
+        },
+        stop: function () {
+            if (secureSplitHttpClient)
+                secureSplitHttpClient.stop();
         }
     };
 }

package/cjs/services/splitHttpClient.js

@@ -24,7 +24,7 @@ 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/cjs/storages/AbstractDefinitionsCacheAsync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDefinitionsCacheAsync = void 0;
+var objectAssign_1 = require("../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 = (0, objectAssign_1.objectAssign)({}, definition);
+                newDefinition.killed = true;
+                newDefinition.defaultTreatment = defaultTreatment;
+                newDefinition.changeNumber = changeNumber;
+                return _this.add(newDefinition);
+            }
+            return false;
+        }).catch(function () { return false; });
+    };
+    return AbstractDefinitionsCacheAsync;
+}());
+exports.AbstractDefinitionsCacheAsync = AbstractDefinitionsCacheAsync;

package/cjs/storages/AbstractDefinitionsCacheSync.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usesSegmentsSync = exports.usesSegments = exports.AbstractDefinitionsCacheSync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
+var constants_1 = require("../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 = (0, objectAssign_1.objectAssign)({}, definition);
+            newDefinition.killed = true;
+            newDefinition.defaultTreatment = defaultTreatment;
+            newDefinition.changeNumber = changeNumber;
+            return this.add(newDefinition);
+        }
+        return false;
+    };
+    return AbstractDefinitionsCacheSync;
+}());
+exports.AbstractDefinitionsCacheSync = 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
+ */
+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 === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
+                return true;
+        }
+    }
+    var excluded = ruleEntity.excluded;
+    if (excluded && excluded.segments && excluded.segments.length > 0)
+        return true;
+    return false;
+}
+exports.usesSegments = usesSegments;
+function usesSegmentsSync(storage) {
+    return storage.definitions.usesSegments() || storage.rbSegments.usesSegments();
+}
+exports.usesSegmentsSync = usesSegmentsSync;