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

package/esm/sdkFactory/index.js

@@ -4,7 +4,7 @@ import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
@@ -13,7 +13,7 @@ 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, 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.
@@ -27,35 +27,31 @@ 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 = 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 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, 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/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,76 @@
+import { fetchAuthFactory } from './fetchAuth';
+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;
+}
+function noCachedCredentialError() {
+    return new Error(LOG_PREFIX_SYNC_AUTH + 'stopped without a cached credential');
+}
+/**
+ * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
+ * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
+ */
+export function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
+    var urls = settings.urls, log = settings.log;
+    var fetchAuth = fetchAuthFactory(function () {
+        var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
+        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
+    });
+    var backoff = new Backoff(fetchCredential);
+    var cachedCredential;
+    var inFlightPromise;
+    var stopped = false;
+    function fetchCredential() {
+        return fetchAuth().then(function (credential) {
+            log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
+            cachedCredential = credential;
+            inFlightPromise = undefined;
+            backoff.reset();
+            return credential;
+        }).catch(function (error) {
+            // Avoid 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(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);
+            }
+            // Reuse any fetch already in flight (e.g. one started just before stop()), instead of firing a redundant one.
+            if (inFlightPromise)
+                return inFlightPromise;
+            // No cached credential to fall back to and stopped: reject so callers don't send an unauthenticated request.
+            if (stopped && !cachedCredential) {
+                return Promise.reject(noCachedCredentialError());
+            }
+            if (cachedCredential)
+                log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
+            // 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() });
+        }
+    };
+}

package/esm/services/decorateHeaders.js

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

package/esm/{sync/streaming/AuthClient/index.js → services/fetchAuth.js}

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

package/esm/services/secureSplitHttpClient.js

@@ -0,0 +1,32 @@
+import { __assign } from "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
+ */
+export function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
+    }
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, 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;
+}

package/esm/services/serviceApi.js

@@ -0,0 +1,143 @@
+import { splitHttpClientFactory } from './splitHttpClient';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { authProviderFactory } from './authProvider';
+import { secureSplitHttpClientFactory } from './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
+ */
+export 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 = 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 = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+    var secureSplitHttpClient = 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(SPLITS))
+                .catch(function (err) {
+                if (err.statusCode === 414)
+                    settings.log.error(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(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(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(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: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
+            }, telemetryTracker.trackHttp(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(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(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(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(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(TELEMETRY), true);
+        },
+        stop: function () {
+            secureSplitHttpClient.stop();
+        }
+    };
+}

package/esm/services/splitApi.js

@@ -2,12 +2,14 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { fetchAuthFactory } from './fetchAuth';
 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
@@ -19,6 +21,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = splitHttpClientFactory(settings, platform);
     return {
+        fetchAuth: 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(TOKEN));
+        }),
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/version");
@@ -28,15 +39,6 @@ export 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(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(SPLITS))
@@ -122,6 +124,18 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         postMetricsUsage: function (body, headers) {
             var url = "".concat(urls.telemetry, "/v1/metrics/usage");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
+        },
+        // 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/esm/services/splitHttpClient.js

@@ -21,19 +21,17 @@ export 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'] = 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 = objectAssign({
-            headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
+            headers: decorateHeaders(settings, objectAssign(newVersionHeader ? { 'X-Harness-FME-SDK-Version': version } : { 'SplitSDKVersion': version }, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

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();
+}