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

package/src/services/authProvider.ts

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

package/src/services/decorateHeaders.ts

@@ -14,7 +14,8 @@ const FORBIDDEN_HEADERS = new Set([
   'content-encoding',
   'accept',
   'keep-alive',
-  'x-fastly-debug'
+  'x-fastly-debug',
+  'x-harness-fme-sdk-version'
 ]);
 
 export function decorateHeaders(settings: ISettings, headers: Record<string, string>) {

package/src/services/secureSplitHttpClient.ts

@@ -19,7 +19,7 @@ export function secureSplitHttpClientFactory(settings: ISettings, platform: Pick
   const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
 
   function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker: ((error?: NetworkError) => void) | undefined, logErrorsAsInfo: boolean | undefined, token: string): Promise<IResponse> {
-    return splitHttpClient(url, { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } }, latencyTracker, logErrorsAsInfo);
+    return splitHttpClient(url, { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } }, latencyTracker, logErrorsAsInfo, true);
   }
 
   const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean): Promise<IResponse> {

package/src/services/serviceApi.ts

@@ -0,0 +1,166 @@
+import { IPlatform } from '../sdkFactory/types';
+import { ISettings } from '../types';
+import { splitHttpClientFactory } from './splitHttpClient';
+import { ISecureSplitHttpClient, IServiceApi } from './types';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { ITelemetryTracker } from '../trackers/types';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+
+const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
+
+function userKeyToQueryParam(userKey: string) {
+  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: ISettings,
+  platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
+  telemetryTracker: ITelemetryTracker,
+  secureSplitHttpClientFactory?: (settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker) => ISecureSplitHttpClient,
+): IServiceApi {
+
+  const urls = settings.urls;
+  const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
+  const SplitSDKImpressionsMode = settings.sync.impressionsMode;
+  const splitHttpClient = splitHttpClientFactory(settings, platform);
+  const secureSplitHttpClient = secureSplitHttpClientFactory!(settings, platform, telemetryTracker);
+
+  return {
+    // @TODO throw errors if health check requests fail, to log them in the Synchronizer
+    getSdkAPIHealthCheck() {
+      const url = `${urls.sdk}/api/version`;
+      return splitHttpClient(url).then(() => true).catch(() => false);
+    },
+
+    getEventsAPIHealthCheck() {
+      const url = `${urls.events}/api/version`;
+      return splitHttpClient(url).then(() => true).catch(() => false);
+    },
+
+    fetchAuth(userMatchingKeys?: string[]) {
+      let url = `${urls.auth}/api/v2/auth?s=${settings.sync.flagSpecVersion}`;
+      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
+        if (queryParams) url += '&' + queryParams;
+      }
+      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+    },
+
+    fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
+      const url = `${urls.sdk}/api/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
+        .catch((err) => {
+          if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);
+          throw err;
+        });
+    },
+
+    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/api/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
+    },
+
+    // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
+    fetchConfigs(since: number, noCache?: boolean, till?: number) {
+      const url = `${urls.configs}/api/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+    },
+
+    fetchConfigsSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.configs}/api/v1/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
+      return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+    },
+
+    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
+      /**
+       * 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'
+       */
+      const url = `${urls.sdk}/api/memberships/${encodeURIComponent(userMatchingKey)}${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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.events}/api/events/bulk`;
+      return splitHttpClient(url, { method: 'POST', body, 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.events}/api/testImpressions/bulk`;
+      return splitHttpClient(url, {
+        // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
+        method: 'POST', body, headers: objectAssign({ 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.events}/api/testImpressions/count`;
+      return splitHttpClient(url, { method: 'POST', body, 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/api/v1/keys/cs`;
+      return splitHttpClient(url, { method: 'POST', body, 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/api/v1/keys/ss`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+    },
+
+    postMetricsConfig(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/api/v1/metrics/config`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
+    },
+
+    postMetricsUsage(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/api/v1/metrics/usage`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
+    },
+
+    stop() {
+      secureSplitHttpClient.stop();
+    }
+  };
+}

package/src/services/splitApi.ts

@@ -1,7 +1,7 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
-import { ISecureSplitHttpClient, ISplitApi } from './types';
+import { IServiceApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
@@ -13,8 +13,9 @@ function userKeyToQueryParam(userKey: string) {
   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
@@ -23,15 +24,13 @@ function userKeyToQueryParam(userKey: string) {
 export function splitApiFactory(
   settings: ISettings,
   platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
-  telemetryTracker: ITelemetryTracker,
-  secureSplitHttpClientFactory?: (settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker) => ISecureSplitHttpClient,
-): ISplitApi {
+  telemetryTracker: ITelemetryTracker
+): IServiceApi {
 
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const secureSplitHttpClient = secureSplitHttpClientFactory ? secureSplitHttpClientFactory(settings, platform, telemetryTracker) : undefined;
 
   return {
     // @TODO throw errors if health check requests fail, to log them in the Synchronizer
@@ -68,17 +67,6 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
-    fetchConfigs(since: number, noCache?: boolean, till?: number) {
-      const url = `${urls.configs}/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
-      return (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
-    },
-
-    fetchConfigsSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
-      const url = `${urls.configs}/v1/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
-      return (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
-    },
-
     fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
       /**
        * URI encoding of user keys in order to:
@@ -158,8 +146,21 @@ export function splitApiFactory(
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
+
+    // Not used. Just here to satisfy the IServiceApi interface.
+
+    fetchConfigs(since: number, noCache?: boolean, till?: number) {
+      const url = `${urls.configs}/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+    },
+
+    fetchConfigsSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.configs}/v1/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+    },
+
     stop() {
-      if (secureSplitHttpClient) secureSplitHttpClient.stop();
+      // no-op
     }
   };
 }

package/src/services/splitHttpClient.ts

@@ -27,17 +27,20 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
   const commonHeaders: Record<string, string> = {
     'Accept': 'application/json',
     'Content-Type': 'application/json',
-    'Authorization': `Bearer ${authorizationKey}`,
-    'SplitSDKVersion': version
+    'Authorization': `Bearer ${authorizationKey}`
   };
 
   if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
   if (hostname) commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
 
-  return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
+  return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo?: boolean, newVersionHeader?: boolean): Promise<IResponse> {
 
     const 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/src/services/types.ts

@@ -31,7 +31,7 @@ export type IFetch = (url: string, options?: IRequestOptions) => Promise<IRespon
 // IFetch specialization
 export type IHealthCheckAPI = () => Promise<boolean>
 
-export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>
+export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean) => Promise<IResponse>
 
 export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
 
@@ -57,7 +57,7 @@ export type IPostMetricsConfig = (body: string, headers?: Record<string, string>
 
 export type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export interface ISplitApi {
+export interface IServiceApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
 	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth

package/src/storages/types.ts

@@ -195,7 +195,7 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface IDefinitionsCacheBase {
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): MaybeThenable<boolean>,
   get(name: string): MaybeThenable<IDefinition | null>,
   getMany(names: string[]): MaybeThenable<Record<string, IDefinition | null>>, // `fetchMany` in spec
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
@@ -212,7 +212,7 @@ export interface IDefinitionsCacheBase {
 }
 
 export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): boolean,
   get(name: string): IDefinition | null,
   getMany(names: string[]): Record<string, IDefinition | null>,
   getChangeNumber(): number,
@@ -226,7 +226,7 @@ export interface IDefinitionsCacheSync extends IDefinitionsCacheBase {
 }
 
 export interface IDefinitionsCacheAsync extends IDefinitionsCacheBase {
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
+  update(toUpsert: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean>,
   get(name: string): Promise<IDefinition | null>,
   getMany(names: string[]): Promise<Record<string, IDefinition | null>>,
   getChangeNumber(): Promise<number>,

package/src/sync/polling/fetchers/splitChangesFetcher.ts

@@ -55,7 +55,7 @@ function partitionByStatus<T extends { status?: string; name: string }>(items: T
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
 export function splitChangesFetcherFactory(params: ISdkFactoryContextSync): IDefinitionChangesFetcher {
 
-  const { splitApi: { fetchSplitChanges }, settings, storage } = params;
+  const { serviceApi: { fetchSplitChanges }, settings, storage } = params;
   const log = settings.log;
   const PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
   let lastProxyCheckTimestamp: number | undefined;

package/src/sync/polling/pollingManagerCS.ts

@@ -21,7 +21,7 @@ export function pollingManagerCSFactory(
   definitionChangesFetcher: IDefinitionChangesFetcher
 ): IPollingManagerCS {
 
-  const { splitApi, storage, readiness, settings } = params;
+  const { serviceApi, storage, readiness, settings } = params;
   const log = settings.log;
 
   const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, true);
@@ -59,7 +59,7 @@ export function pollingManagerCSFactory(
   });
 
   function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
+    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
     // smart ready
     function smartReady(metadata: SdkUpdateMetadata) {

package/src/sync/polling/updaters/definitionChangesUpdater.ts

@@ -57,7 +57,7 @@ export function parseSegments(ruleEntity: IDefinition | IRBSegment, matcherType:
 }
 
 interface IDefinitionMutations<T extends IDefinition | IRBSegment> {
-  added: T[],
+  updated: T[],
   removed: string[],
   names: string[]
 }
@@ -91,7 +91,7 @@ function matchFilters(definition: IDefinition, filters: ISplitFiltersValidation)
 export function computeMutation<T extends IDefinition | IRBSegment>(update: { updated: T[], removed: string[] }, segments: Set<string>, filters?: ISplitFiltersValidation): IDefinitionMutations<T> {
   return update.updated.reduce((accum, ruleEntity) => {
     if (!filters || matchFilters(ruleEntity as IDefinition, filters)) {
-      accum.added.push(ruleEntity);
+      accum.updated.push(ruleEntity);
 
       parseSegments(ruleEntity).forEach((segmentName: string) => {
         segments.add(segmentName);
@@ -101,7 +101,7 @@ export function computeMutation<T extends IDefinition | IRBSegment>(update: { up
     }
     accum.names.push(ruleEntity.name);
     return accum;
-  }, { added: [], removed: update.removed, names: update.removed.slice() } as IDefinitionMutations<T>);
+  }, { updated: [], removed: update.removed, names: update.removed.slice() } as IDefinitionMutations<T>);
 }
 
 function convertInstantUpdateToDefinitionChanges(instantUpdate: InstantUpdate) {
@@ -180,17 +180,17 @@ export function definitionChangesUpdaterFactory(
           let updatedDefinitions: string[] = [];
           let ffUpdate: MaybeThenable<boolean> = false;
           if (definitionChanges.d) {
-            const { added, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
+            const { updated, removed, names } = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation);
             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);
           }
 
           let rbsUpdate: MaybeThenable<boolean> = false;
           if (definitionChanges.rbs) {
-            const { added, removed } = computeMutation(definitionChanges.rbs, usedSegments);
-            log.debug(SYNC_UPDATE, ['rule-based segments', added.length, removed.length]);
-            rbsUpdate = rbSegments.update(added, removed, definitionChanges.rbs.till);
+            const { updated, removed } = computeMutation(definitionChanges.rbs, usedSegments);
+            log.debug(SYNC_UPDATE, ['rule-based segments', updated.length, removed.length]);
+            rbsUpdate = rbSegments.update(updated, removed, definitionChanges.rbs.till);
           }
 
           return Promise.all([ffUpdate, rbsUpdate,

package/src/sync/streaming/AuthClient/index.ts

@@ -8,7 +8,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: IFetchAuth): IAuthenticate {
 

package/src/sync/streaming/pushManager.ts

@@ -30,7 +30,7 @@ export function pushManagerFactory(
   pollingManager: IPollingManager,
 ): IPushManager | undefined {
 
-  const { settings, storage, splitApi, readiness, platform, telemetryTracker } = params;
+  const { settings, storage, serviceApi, readiness, platform, telemetryTracker } = params;
 
   // `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.
@@ -45,7 +45,7 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(splitApi.fetchAuth);
+  const authenticate = authenticateFactory(serviceApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;

package/src/sync/submitters/eventsSubmitter.ts

@@ -9,7 +9,7 @@ export function eventsSubmitterFactory(params: ISdkFactoryContextSync) {
 
   const {
     settings: { log, scheduler: { eventsPushRate }, startup: { eventsFirstPushWindow } },
-    splitApi: { postEventsBulk },
+    serviceApi: { postEventsBulk },
     storage: { events },
   } = params;
 

package/src/sync/submitters/impressionCountsSubmitter.ts

@@ -35,7 +35,7 @@ export function impressionCountsSubmitterFactory(params: ISdkFactoryContextSync)
 
   const {
     settings: { log },
-    splitApi: { postTestImpressionsCount },
+    serviceApi: { postTestImpressionsCount },
     storage: { impressionCounts }
   } = params;
 

package/src/sync/submitters/impressionsSubmitter.ts

@@ -41,7 +41,7 @@ export function impressionsSubmitterFactory(params: ISdkFactoryContextSync) {
 
   const {
     settings: { log, scheduler: { impressionsRefreshRate }, core: { labelsEnabled } },
-    splitApi: { postTestImpressionsBulk },
+    serviceApi: { postTestImpressionsBulk },
     storage: { impressions },
     entityType
   } = params;

package/src/sync/submitters/telemetrySubmitter.ts

@@ -119,12 +119,12 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, serviceApi, readiness } = params;
   const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
     submitterFactory(
-      log, splitApi.postMetricsUsage,
+      log, serviceApi.postMetricsUsage,
       telemetry,
       telemetryRefreshRate, undefined, 0, true
     ),
@@ -140,7 +140,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
 
     // Post config data when the SDK is ready and if the telemetry submitter was started
     if (submitter.isRunning()) {
-      const postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+      const postMetricsConfigTask = submitterFactory(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
       postMetricsConfigTask.execute();
     }
   });

package/src/sync/submitters/uniqueKeysSubmitter.ts

@@ -11,7 +11,7 @@ export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
 
   const {
     settings: { log, core: { key } },
-    splitApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
+    serviceApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
     storage: { uniqueKeys }
   } = params;
 

package/src/sync/syncManagerOnline.ts

@@ -28,7 +28,7 @@ export function syncManagerOnlineFactory(
   pollingManagerFactory?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher, segmentChangesFetcher: ISegmentChangesFetcher) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
   definitionFetcherFactory = splitChangesFetcherFactory,
-  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.splitApi.fetchSegmentChanges)
+  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges)
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**

package/src/utils/settingsValidation/index.ts

@@ -59,7 +59,7 @@ export const 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.

package/types/splitio.d.ts

@@ -213,7 +213,7 @@ interface IServerSideSharedSettings {
    */
   startup?: {
     /**
-     * Time in seconds used before emitting the SDK_READY_TIMED_OUT event.
+     * Time in seconds before emitting the `SDK_READY_TIMED_OUT` event.
      *
      * @defaultValue `15`
      */
@@ -373,7 +373,7 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
    */
   startup?: {
     /**
-     * Time in seconds used before emitting the SDK_READY_TIMED_OUT event.
+     * Time in seconds before emitting the `SDK_READY_TIMED_OUT` event.
      *
      * @defaultValue `10`
      */
@@ -1439,7 +1439,7 @@ declare namespace SplitIO {
      */
     startup?: {
       /**
-       * Time in seconds used before emitting the SDK_READY_TIMED_OUT event.
+       * Time in seconds before emitting the `SDK_READY_TIMED_OUT` event.
        *
        * @defaultValue `10`
        */
@@ -2341,8 +2341,8 @@ declare namespace SplitIO {
      */
     logLevel?: LogLevel;
     /**
-     * Time in seconds used before emitting the SDK_READY_TIMED_OUT event.
-     * A value of -1 disables the timeout and thus the event is never emitted.
+     * Time in seconds before emitting the `SDK_READY_TIMED_OUT` event.
+     * A value of `-1` disables the timeout and thus the event is never emitted.
      *
      * @defaultValue `10`
      */
@@ -2354,19 +2354,19 @@ declare namespace SplitIO {
       /**
        * String property to override the base URL where the SDK will get JWT authentication credentials.
        *
-       * @defaultValue `'https://auth.split.io/api'`
+       * @defaultValue `'https://auth.split.io'`
        */
       auth?: string;
       /**
        * String property to override the base URL where the SDK will get rollout plan related data, like configs and segments definitions.
        *
-       * @defaultValue `'https://configs.split.io/api'`
+       * @defaultValue `'https://configs.split.io'`
        */
       configs?: string;
       /**
        * String property to override the base URL where the SDK will post event-related information like impressions.
        *
-       * @defaultValue `'https://events.split.io/api'`
+       * @defaultValue `'https://events.split.io'`
        */
       events?: string;
     };