@splitsoftware/splitio-commons 3.0.0-rc.3 → 3.0.0-rc.5

package/esm/sdkFactory/index.js

@@ -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, 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.
@@ -45,9 +45,9 @@ export function sdkFactory(params) {
     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, fallbackCalculator: fallbackCalculator };
+    // 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);

package/esm/services/authProvider.js

@@ -13,8 +13,8 @@ function isExpired(credential) {
 export function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
     var urls = settings.urls, log = settings.log;
     function fetchAuth() {
-        var url = "".concat(urls.auth, "/v3/auth?capabilities=config");
-        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+        var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config");
+        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
     }
     var authenticate = authenticateFactory(fetchAuth);
     var backoff = new Backoff(fetchCredential);

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/services/secureSplitHttpClient.js

@@ -13,7 +13,7 @@ export function secureSplitHttpClientFactory(settings, platform, telemetryTracke
     var splitHttpClient = splitHttpClientFactory(settings, platform);
     var authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
     function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo);
+        return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
     }
     var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
         return authProvider.credential().then(function (credential) {

package/esm/services/serviceApi.js

@@ -0,0 +1,141 @@
+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';
+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.
+}
+/**
+ * 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
+ * @param secureSplitHttpClientFactory - factory of SecureSplitHttpClient objects
+ */
+export function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
+    var urls = settings.urls;
+    var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
+    var SplitSDKImpressionsMode = settings.sync.impressionsMode;
+    var splitHttpClient = splitHttpClientFactory(settings, platform);
+    var secureSplitHttpClient = secureSplitHttpClientFactory(settings, platform, telemetryTracker);
+    return {
+        // @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; });
+        },
+        fetchAuth: function (userMatchingKeys) {
+            var url = "".concat(urls.auth, "/api/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, "/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) {
+            var url = "".concat(urls.configs, "/api/v1/configs?since=").concat(since).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 splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
+        },
+        /**
+         * 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 splitHttpClient(url, {
+                // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
+                method: 'POST',
+                body: body,
+                headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
+            }, telemetryTracker.trackHttp(IMPRESSIONS));
+        },
+        /**
+         * 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 splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
+        },
+        /**
+         * 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 splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
+        /**
+         * 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 splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
+        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

@@ -6,19 +6,19 @@ 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
  * @param telemetryTracker - telemetry tracker
  */
-export function splitApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
+export function splitApiFactory(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);
-    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 () {
@@ -51,15 +51,6 @@ export function splitApiFactory(settings, platform, telemetryTracker, secureSpli
             var url = "".concat(urls.sdk, "/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) {
-            var url = "".concat(urls.configs, "/v1/configs?since=").concat(since).concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return (secureSplitHttpClient || 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 (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
-        },
         fetchMemberships: function (userMatchingKey, noCache, till) {
             /**
              * URI encoding of user keys in order to:
@@ -133,9 +124,17 @@ export function splitApiFactory(settings, platform, telemetryTracker, secureSpli
             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) {
+            var url = "".concat(urls.configs, "/v1/configs?since=").concat(since).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 () {
-            if (secureSplitHttpClient)
-                secureSplitHttpClient.stop();
+            // 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/sync/polling/fetchers/splitChangesFetcher.js

@@ -21,7 +21,7 @@ function partitionByStatus(items, till, since) {
  */
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
 export function splitChangesFetcherFactory(params) {
-    var fetchSplitChanges = params.splitApi.fetchSplitChanges, settings = params.settings, storage = params.storage;
+    var fetchSplitChanges = params.serviceApi.fetchSplitChanges, settings = params.settings, storage = params.storage;
     var log = settings.log;
     var PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
     var lastProxyCheckTimestamp;

package/esm/sync/polling/pollingManagerCS.js

@@ -10,7 +10,7 @@ import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(params, definitionChangesFetcher) {
-    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+    var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, true);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
@@ -44,7 +44,7 @@ export function pollingManagerCSFactory(params, definitionChangesFetcher) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady(metadata) {
             if (!readiness.isReady() && !usesSegmentsSync(storage))

package/esm/sync/polling/updaters/definitionChangesUpdater.js

@@ -69,7 +69,7 @@ function matchFilters(definition, filters) {
 export function computeMutation(update, segments, filters) {
     return update.updated.reduce(function (accum, ruleEntity) {
         if (!filters || matchFilters(ruleEntity, filters)) {
-            accum.added.push(ruleEntity);
+            accum.updated.push(ruleEntity);
             parseSegments(ruleEntity).forEach(function (segmentName) {
                 segments.add(segmentName);
             });
@@ -79,7 +79,7 @@ export function computeMutation(update, segments, filters) {
         }
         accum.names.push(ruleEntity.name);
         return accum;
-    }, { added: [], removed: update.removed, names: update.removed.slice() });
+    }, { updated: [], removed: update.removed, names: update.removed.slice() });
 }
 function convertInstantUpdateToDefinitionChanges(instantUpdate) {
     var payload = instantUpdate.payload, changeNumber = instantUpdate.changeNumber;
@@ -143,16 +143,16 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                 var updatedDefinitions = [];
                 var ffUpdate = false;
                 if (definitionChanges.d) {
-                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
+                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), updated = _a.updated, removed = _a.removed, names = _a.names;
                     updatedDefinitions = names;
-                    log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, added.length, removed.length]);
-                    ffUpdate = definitions.update(added, removed, definitionChanges.d.till);
+                    log.debug(SYNC_UPDATE, [definitionChangesFetcher.type, updated.length, removed.length]);
+                    ffUpdate = definitions.update(updated, removed, definitionChanges.d.till);
                 }
                 var rbsUpdate = false;
                 if (definitionChanges.rbs) {
-                    var _b = computeMutation(definitionChanges.rbs, usedSegments), added = _b.added, removed = _b.removed;
-                    log.debug(SYNC_UPDATE, ['rule-based segments', added.length, removed.length]);
-                    rbsUpdate = rbSegments.update(added, removed, definitionChanges.rbs.till);
+                    var _b = computeMutation(definitionChanges.rbs, usedSegments), updated = _b.updated, removed = _b.removed;
+                    log.debug(SYNC_UPDATE, ['rule-based segments', updated.length, removed.length]);
+                    rbsUpdate = rbSegments.update(updated, removed, definitionChanges.rbs.till);
                 }
                 return Promise.all([ffUpdate, rbsUpdate,
                     // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted

package/esm/sync/streaming/AuthClient/index.js

@@ -5,7 +5,7 @@ import { hash } from '../../../utils/murmur3/murmur3';
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth - `SplitAPI.fetchAuth` endpoint
+ * @param fetchAuth - `ServiceApi.fetchAuth` endpoint
  */
 export function authenticateFactory(fetchAuth) {
     /**

package/esm/sync/streaming/pushManager.js

@@ -20,7 +20,7 @@ import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
     var userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
@@ -34,7 +34,7 @@ export function pushManagerFactory(params, pollingManager) {
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(splitApi.fetchAuth);
+    var authenticate = authenticateFactory(serviceApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);

package/esm/sync/submitters/eventsSubmitter.js

@@ -4,7 +4,7 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
  * Submitter that periodically posts tracked events
  */
 export function eventsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.splitApi.postEventsBulk, events = params.storage.events;
+    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.serviceApi.postEventsBulk, events = params.storage.events;
     // don't retry events.
     var submitter = submitterFactory(log, postEventsBulk, events, eventsPushRate);
     // Set a timer for the first push window of events.

package/esm/sync/submitters/impressionCountsSubmitter.js

@@ -25,7 +25,7 @@ var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
  * Submitter that periodically posts impression counts
  */
 export function impressionCountsSubmitterFactory(params) {
-    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
+    var log = params.settings.log, postTestImpressionsCount = params.serviceApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
     // retry impressions counts only once.
     return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, fromImpressionCountsCollector, 1);
 }

package/esm/sync/submitters/impressionsSubmitter.js

@@ -31,7 +31,7 @@ export function fromImpressionsCollector(sendLabels, entityType, data) {
  * Submitter that periodically posts impressions data
  */
 export function impressionsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions, entityType = params.entityType;
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.serviceApi.postTestImpressionsBulk, impressions = params.storage.impressions, entityType = params.entityType;
     // retry impressions only once.
     var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
     // register impressions submitter to be executed when impressions cache is full

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,9 +102,9 @@ export function telemetrySubmitterFactory(params) {
     var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, serviceApi = params.serviceApi, readiness = params.readiness;
     var stopTimer = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, serviceApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
@@ -112,7 +112,7 @@ export function telemetrySubmitterFactory(params) {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started
         if (submitter.isRunning()) {
-            var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+            var postMetricsConfigTask = submitterFactory(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
             postMetricsConfigTask.execute();
         }
     });

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -5,7 +5,7 @@ var UNIQUE_KEYS_RATE = 900000; // 15 minutes
  * Submitter that periodically posts impression counts
  */
 export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.serviceApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
     var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE);

package/esm/sync/syncManagerOnline.js

@@ -18,7 +18,7 @@ import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesF
  */
 export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
     if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.splitApi.fetchSegmentChanges); }; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
     /**
      * SyncManager factory for modular SDK
      */

package/esm/utils/settingsValidation/index.js

@@ -53,7 +53,7 @@ export var base = {
         // Telemetry Server
         telemetry: 'https://telemetry.split.io/api',
         // Configs Server
-        configs: 'https://configs.split.io/api',
+        configs: 'https://configs.split.io',
     },
     // Defines which kind of storage we should instantiate.
     storage: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.0.0-rc.3",
+  "version": "3.0.0-rc.5",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/listeners/browser.ts

@@ -3,7 +3,7 @@ import { ISignalListener } from './types';
 import { IRecorderCacheSync, IStorageSync } from '../storages/types';
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
-import { IResponse, ISplitApi } from '../services/types';
+import { IResponse, IServiceApi } from '../services/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { ImpressionsPayload } from '../sync/submitters/types';
@@ -25,14 +25,14 @@ export class BrowserSignalListener implements ISignalListener {
   private syncManager: ISyncManager | undefined;
   private settings: ISettings;
   private storage: IStorageSync;
-  private serviceApi: ISplitApi;
+  private serviceApi: IServiceApi;
   private fromImpressionsCollector: (data: SplitIO.ImpressionDTO[]) => ImpressionsPayload;
 
-  constructor({ syncManager, settings, storage, splitApi, entityType }: ISdkFactoryContextSync) {
+  constructor({ syncManager, settings, storage, serviceApi, entityType }: ISdkFactoryContextSync) {
     this.syncManager = syncManager;
     this.settings = settings;
     this.storage = storage;
-    this.serviceApi = splitApi;
+    this.serviceApi = serviceApi;
     this.flushData = this.flushData.bind(this);
     this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
     this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled, entityType);

package/src/logger/messages/debug.ts

@@ -22,7 +22,7 @@ export const codesDebug: [number, string][] = codesInfo.concat([
   // synchronizer
   [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
   [c.SYNC_FETCH, c.LOG_PREFIX_SYNC + 'Spin up %s updates using since = %s and rbSince = %s.'],
-  [c.SYNC_UPDATE, c.LOG_PREFIX_SYNC + 'New %s: %s. Removed: %s.'],
+  [c.SYNC_UPDATE, c.LOG_PREFIX_SYNC + 'Updated %s: %s. Removed: %s.'],
   [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
   [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + 'Starting %s. Running each %s millis'],
   [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + 'Running %s'],

package/src/presets/serverSide.ts

@@ -1,4 +1,4 @@
-import { splitApiFactory } from '../services/splitApi';
+import { serviceApiFactory } from '../services/serviceApi';
 import { syncManagerOnlineFactory } from '../sync/syncManagerOnline';
 import { pushManagerFactory } from '../sync/streaming/pushManager';
 import { pollingManagerSSFactory } from '../sync/polling/pollingManagerSS';
@@ -11,7 +11,7 @@ const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFact
 
 export const serverSideModules = {
   storageFactory: InMemoryStorageFactory,
-  splitApiFactory,
+  serviceApiFactory,
   syncManagerFactory: syncManagerOnlineSSFactory,
   sdkManagerFactory,
   sdkClientMethodFactory,

package/src/sdkClient/sdkLifecycle.ts

@@ -7,7 +7,7 @@ const COOLDOWN_TIME_IN_MILLIS = 1000;
  * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?: boolean): { init(): void; flush(): Promise<void>; destroy(): Promise<void> } {
-  const { sdkReadinessManager, syncManager, storage, settings, telemetryTracker, impressionsTracker, platform, splitApi } = params;
+  const { sdkReadinessManager, syncManager, storage, settings, telemetryTracker, impressionsTracker, platform, serviceApi } = params;
 
   let hasInit = false;
   let lastActionTime = 0;
@@ -68,7 +68,7 @@ export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?:
 
       // Stop background jobs
       syncManager && syncManager.stop();
-      splitApi && splitApi.stop();
+      serviceApi && serviceApi.stop();
 
       return __flush().then(() => {
         // Cleanup storage

package/src/sdkFactory/index.ts

@@ -18,7 +18,7 @@ import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCal
  */
 export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IAsyncSDK | SplitIO.IBrowserSDK | SplitIO.IBrowserAsyncSDK {
 
-  const { settings, platform, storageFactory, splitApiFactory, extraProps, syncManagerFactory,
+  const { settings, platform, storageFactory, serviceApiFactory, extraProps, syncManagerFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory, lazyInit } = params;
   const { log, initialRolloutPlan, core: { key } } = settings;
 
@@ -58,10 +58,10 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
   const impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
-  // splitApi is used by SyncManager and Browser signal listener
-  const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
+  // serviceApi is used by SyncManager and Browser signal listener
+  const serviceApi = serviceApiFactory && serviceApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackCalculator };
+  const ctx: ISdkFactoryContext = { clients, serviceApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackCalculator };
   ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
 
   // SDK client and manager

package/src/sdkFactory/types.ts

@@ -2,9 +2,9 @@ import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/
 import { ISignalListener } from '../listeners/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import type { sdkManagerFactory } from '../sdkManager';
-import type { splitApiFactory } from '../services/splitApi';
+import { serviceApiFactory } from '../services/serviceApi';
 import type { IFallbackCalculator } from '../evaluator/fallbackTreatmentsCalculator';
-import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
+import { IFetch, IServiceApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
@@ -55,7 +55,7 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  splitApi?: ISplitApi,
+  serviceApi?: IServiceApi,
   syncManager?: ISyncManager,
   clients: Record<string, SplitIO.IBasicClient>,
   fallbackCalculator: IFallbackCalculator,
@@ -64,13 +64,13 @@ export interface ISdkFactoryContext {
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
   storage: IStorageSync,
-  splitApi: ISplitApi
+  serviceApi: IServiceApi
   syncManager: ISyncManager,
 }
 
 export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
   storage: IStorageAsync,
-  splitApi: undefined,
+  serviceApi: undefined,
   syncManager: undefined
 }
 
@@ -91,9 +91,9 @@ export interface ISdkFactoryParams {
   // sync SDK (`IBrowserSDK` and `ISDK`) with `IStorageSync`, and async SDK (`IBrowserAsyncSDK` and `IAsyncSDK`) with `IStorageAsync`
   storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync,
 
-  // Factory of Split Api (HTTP Client Service).
+  // Factory of ServiceApi (HTTP Client Service).
   // It is not required when providing an asynchronous storage or offline SyncManager
-  splitApiFactory?: typeof splitApiFactory,
+  serviceApiFactory?: typeof serviceApiFactory,
 
   // SyncManager factory.
   // Not required when providing an asynchronous storage (consumer mode), but required in standalone mode to avoid SDK timeout.