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

package/cjs/sdkFactory/index.js

@@ -16,7 +16,7 @@ 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, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, serviceApiFactory = params.serviceApiFactory, 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.
@@ -30,35 +30,31 @@ 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 = (0, 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 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, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
-    var syncManager = syncManagerFactory && syncManagerFactory(ctx);
-    ctx.syncManager = syncManager;
-    // @TODO: move into platform, and call inside sdkClientFactory (if it's used only there)
-    var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-    ctx.signalListener = signalListener;
+    // serviceApi is used by SyncManager and Browser signal listener
+    var serviceApi = serviceApiFactory && serviceApiFactory(settings, platform, telemetryTracker);
+    var ctx = { clients: clients, serviceApi: serviceApi, 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() {
         Object.keys(clients).map(function (key) { return clients[key].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,80 @@
+"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;
+}
+function noCachedCredentialError() {
+    return new Error(constants_1.LOG_PREFIX_SYNC_AUTH + 'stopped without a cached credential');
+}
+/**
+ * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
+ * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
+ */
+function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
+    var urls = settings.urls, log = settings.log;
+    var fetchAuth = (0, AuthClient_1.fetchAuthFactory)(function () {
+        var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
+        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_2.TOKEN), false, true);
+    });
+    var backoff = new Backoff_1.Backoff(fetchCredential);
+    var cachedCredential;
+    var inFlightPromise;
+    var stopped = false;
+    function fetchCredential() {
+        return fetchAuth().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 unnecessary retries after stop(): fall back to any cached credential, or reject
+            // (never resolve with `undefined`, which callers would otherwise send as an unauthenticated request).
+            if (stopped)
+                return cachedCredential || Promise.reject(noCachedCredentialError());
+            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);
+            }
+            // Reuse any fetch already in flight (e.g. one started just before stop()), instead of firing a redundant one.
+            if (inFlightPromise)
+                return inFlightPromise;
+            // No cached credential to fall back to and stopped: reject so callers don't send an unauthenticated request.
+            if (stopped && !cachedCredential) {
+                return Promise.reject(noCachedCredentialError());
+            }
+            if (cachedCredential)
+                log.debug(constants_1.LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
+            // If stopped, this is a last, bounded refetch: fetchCredential()'s catch short-circuits (no backoff retry)
+            // once stopped, so it's a single attempt that falls back to the stale cached credential on failure.
+            return inFlightPromise = fetchCredential();
+        },
+        invalidate: function () {
+            cachedCredential = undefined;
+        },
+        stop: function () {
+            stopped = true;
+            // Keep any in-flight fetch and already-cached credential usable (e.g. by a final flush on destroy).
+            // If a retry is only pending (not actively in flight), settle it immediately instead of waiting out the
+            // backoff delay: with the cached credential if there is one, or rejected otherwise.
+            backoff.reset(cachedCredential ? { value: cachedCredential } : { error: noCachedCredentialError() });
+        }
+    };
+}
+exports.authProviderFactory = authProviderFactory;

package/cjs/services/decorateHeaders.js

@@ -15,7 +15,8 @@ var FORBIDDEN_HEADERS = new Set([
     'content-encoding',
     'accept',
     'keep-alive',
-    'x-fastly-debug'
+    'x-fastly-debug',
+    'x-harness-fme-sdk-version'
 ]);
 function decorateHeaders(settings, headers) {
     var _a;

package/cjs/services/secureSplitHttpClient.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureSplitHttpClientFactory = void 0;
+var tslib_1 = require("tslib");
+/**
+ * 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 splitHttpClient - `splitHttpClientFactory` to use for making requests
+ * @param authProvider - `authProviderFactory` to use for authentication
+ */
+function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? 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) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
+    }
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt) {
+        if (newVersionHeader === void 0) { newVersionHeader = true; }
+        if (useJwt === void 0) { useJwt = true; }
+        return authProvider.credential().then(function (credential) {
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
+                .catch(function (error) {
+                if (error.statusCode === 401) {
+                    // retry once for 401, in case the token has just expired
+                    authProvider.invalidate();
+                    return authProvider.credential().then(function (newCredential) {
+                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
+                    });
+                }
+                throw error;
+            });
+        });
+    };
+    httpClient.stop = function () { return authProvider.stop(); };
+    return httpClient;
+}
+exports.secureSplitHttpClientFactory = secureSplitHttpClientFactory;

package/cjs/services/serviceApi.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceApiFactory = void 0;
+var splitHttpClient_1 = require("./splitHttpClient");
+var objectAssign_1 = require("../utils/lang/objectAssign");
+var constants_1 = require("../utils/constants");
+var constants_2 = require("../logger/constants");
+var authProvider_1 = require("./authProvider");
+var secureSplitHttpClient_1 = require("./secureSplitHttpClient");
+var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
+/**
+ * Factory of ServiceApi objects, which group the collection of HTTP endpoints used by the SDKs
+ *
+ * @param settings - validated settings object
+ * @param platform - object containing environment-specific dependencies
+ * @param telemetryTracker - telemetry tracker
+ */
+function serviceApiFactory(settings, platform, telemetryTracker) {
+    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);
+    // Shared authProvider so that the SSE authentication (via `fetchAuth`,
+    // used by `pushManager`) and every authenticated HTTP request to the Configs
+    // API reuse the same cached credential instead of each fetching their own.
+    var authProvider = (0, authProvider_1.authProviderFactory)(settings, splitHttpClient, telemetryTracker);
+    var secureSplitHttpClient = (0, secureSplitHttpClient_1.secureSplitHttpClientFactory)(splitHttpClient, authProvider);
+    var initialAuth = true;
+    return {
+        fetchAuth: function () {
+            // Guard condition to avoid invalidating the cached credential on the first pushManager authentication
+            if (initialAuth)
+                initialAuth = false;
+            else
+                authProvider.invalidate();
+            return authProvider.credential();
+        },
+        // @TODO throw errors if health check requests fail, to log them in the Synchronizer
+        getSdkAPIHealthCheck: function () {
+            var url = "".concat(urls.sdk, "/api/version");
+            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
+        },
+        getEventsAPIHealthCheck: function () {
+            var url = "".concat(urls.events, "/api/version");
+            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
+        },
+        fetchSplitChanges: function (since, noCache, till, rbSince) {
+            var url = "".concat(urls.sdk, "/api/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)
+                    settings.log.error(constants_2.ERROR_TOO_MANY_SETS);
+                throw err;
+            });
+        },
+        fetchSegmentChanges: function (since, segmentName, noCache, till) {
+            var url = "".concat(urls.sdk, "/api/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SEGMENT));
+        },
+        // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
+        fetchConfigs: function (since, noCache, till, rbSince) {
+            var url = "".concat(urls.configs, "/api/v1/configs?since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
+            return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+        },
+        fetchConfigsSegmentChanges: function (since, segmentName, noCache, till) {
+            var url = "".concat(urls.configs, "/api/v1/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
+            return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+        },
+        fetchMemberships: function (userMatchingKey, noCache, till) {
+            /**
+             * URI encoding of user keys in order to:
+             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
+             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+             *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
+             */
+            var url = "".concat(urls.sdk, "/api/memberships/").concat(encodeURIComponent(userMatchingKey)).concat(till ? '?till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MEMBERSHIPS));
+        },
+        /**
+         * Post events.
+         *
+         * @param body -  Events bulk payload
+         * @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 = "".concat(urls.events, "/api/events/bulk");
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.EVENTS), false, false, false);
+        },
+        /**
+         * Post impressions.
+         *
+         * @param body -  Impressions bulk payload
+         * @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 = "".concat(urls.events, "/api/testImpressions/bulk");
+            return secureSplitHttpClient(url, {
+                // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
+                method: 'POST',
+                body: body,
+                headers: (0, objectAssign_1.objectAssign)({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
+            }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS), false, false, false);
+        },
+        /**
+         * Post impressions counts.
+         *
+         * @param body -  Impressions counts payload
+         * @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 = "".concat(urls.events, "/api/testImpressions/count");
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT), false, false, false);
+        },
+        /**
+         * Post unique keys for client side.
+         *
+         * @param body -  unique keys payload
+         * @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 = "".concat(urls.telemetry, "/api/v1/keys/cs");
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
+        },
+        /**
+         * Post unique keys for server side.
+         *
+         * @param body -  unique keys payload
+         * @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 = "".concat(urls.telemetry, "/api/v1/keys/ss");
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
+        },
+        postMetricsConfig: function (body, headers) {
+            var url = "".concat(urls.telemetry, "/api/v1/metrics/config");
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
+        },
+        postMetricsUsage: function (body, headers) {
+            var url = "".concat(urls.telemetry, "/api/v1/metrics/usage");
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
+        },
+        stop: function () {
+            secureSplitHttpClient.stop();
+        }
+    };
+}
+exports.serviceApiFactory = serviceApiFactory;

package/cjs/services/splitApi.js

@@ -5,12 +5,14 @@ var splitHttpClient_1 = require("./splitHttpClient");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
+var AuthClient_1 = require("../sync/streaming/AuthClient");
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
 }
+// @TODO remove when migrating to the new `urls` defaults.
 /**
- * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
+ * Factory of ServiceApi objects, which group the collection of Split HTTP endpoints used by the SDK
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
@@ -22,6 +24,15 @@ function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform);
     return {
+        fetchAuth: (0, AuthClient_1.fetchAuthFactory)(function (userMatchingKeys) {
+            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)
+                    url += '&' + queryParams;
+            }
+            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
+        }),
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/version");
@@ -31,15 +42,6 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = "".concat(urls.events, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
-        fetchAuth: function (userMatchingKeys) {
-            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)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
-        },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
             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))
@@ -125,6 +127,18 @@ 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(constants_1.TELEMETRY), true);
+        },
+        // Not used. Just here to satisfy the IServiceApi interface.
+        fetchConfigs: function (since, noCache, till, rbSince) {
+            var url = "".concat(urls.configs, "/v1/configs?since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+        },
+        fetchConfigsSegmentChanges: function (since, segmentName, noCache, till) {
+            var url = "".concat(urls.configs, "/v1/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+        },
+        stop: function () {
+            // no-op
         }
     };
 }

package/cjs/services/splitHttpClient.js

@@ -24,19 +24,17 @@ function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer ".concat(authorizationKey),
-        'SplitSDKVersion': version
+        'Authorization': "Bearer ".concat(authorizationKey)
     };
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
         commonHeaders['SplitSDKMachineName'] = (0, decorateHeaders_1.removeNonISO88591)(hostname);
-    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
+    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo, newVersionHeader) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
-        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = (0, objectAssign_1.objectAssign)({
-            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)({}, commonHeaders, reqOpts.headers || {})),
+            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)(newVersionHeader ? { 'X-Harness-FME-SDK-Version': version } : { 'SplitSDKVersion': version }, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

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;

package/cjs/storages/KeyBuilder.js

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

@@ -9,7 +9,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;
     }
     /**
@@ -26,19 +26,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 (0, lang_1.startsWith)(key, "".concat(this.prefix, ".split."));
     };
     KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
         return (0, lang_1.startsWith)(key, "".concat(this.prefix, ".rbsegment."));
     };
-    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
+    KeyBuilderCS.prototype.buildDefinitionsWithSegmentCountKey = function () {
         return "".concat(this.prefix, ".splits.usingSegments");
     };
     KeyBuilderCS.prototype.buildLastClear = function () {