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

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/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/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.4",
+  "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/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.

package/src/services/authProvider.ts

@@ -28,7 +28,7 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
   const { urls, log } = settings;
 
   function fetchAuth() {
-    let url = `${urls.auth}/v3/auth?capabilities=config`;
+    let url = `${urls.auth}/api/v3/auth?capabilities=config`;
     return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
   }