@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.2

package/src/logger/messages/warn.ts

@@ -15,7 +15,6 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s'],
   // client status
   [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
-  [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
   // input validation
   [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
   [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],

package/src/readiness/constants.ts

@@ -1,6 +1,6 @@
-// Splits events:
-export const SDK_SPLITS_ARRIVED = 'state::splits-arrived';
-export const SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
+// Definitions events:
+export const SDK_DEFINITIONS_ARRIVED = 'state::splits-arrived';
+export const SDK_DEFINITIONS_CACHE_LOADED = 'state::splits-cache-loaded';
 
 // Segments events:
 export const SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';

package/src/readiness/readinessManager.ts

@@ -1,13 +1,13 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ISettings } from '../types';
 import SplitIO, { SdkReadyMetadata } from '../../types/splitio';
-import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
+import { SDK_DEFINITIONS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
+import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, IDefinitionsEventEmitter } from './types';
 
-function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
-  const splitsEventEmitter = objectAssign(new EventEmitter(), {
-    splitsArrived: false,
-    splitsCacheLoaded: false,
+function definitionsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): IDefinitionsEventEmitter {
+  const definitionsEventEmitter = objectAssign(new EventEmitter(), {
+    definitionsArrived: false,
+    definitionsCacheLoaded: false,
     hasInit: false,
     initCallbacks: []
   });
@@ -15,10 +15,10 @@ function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
   // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (metadata: SplitIO.SdkUpdateMetadata, isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
-  splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
+  definitionsEventEmitter.on(SDK_DEFINITIONS_ARRIVED, (metadata: SplitIO.SdkUpdateMetadata, isSplitKill: boolean) => { if (!isSplitKill) definitionsEventEmitter.definitionsArrived = true; });
+  definitionsEventEmitter.once(SDK_DEFINITIONS_CACHE_LOADED, () => { definitionsEventEmitter.definitionsCacheLoaded = true; });
 
-  return splitsEventEmitter;
+  return definitionsEventEmitter;
 }
 
 function segmentsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISegmentsEventEmitter {
@@ -37,7 +37,7 @@ function segmentsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitt
 export function readinessManagerFactory(
   EventEmitter: new () => SplitIO.IEventEmitter,
   settings: ISettings,
-  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter),
+  definitions: IDefinitionsEventEmitter = definitionsEventEmitterFactory(EventEmitter),
   isShared?: boolean
 ): IReadinessManager {
 
@@ -59,8 +59,8 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
-  if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
-  else splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
+  if (definitions.definitionsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
+  else definitions.once(SDK_DEFINITIONS_CACHE_LOADED, checkIsReadyFromCache);
 
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
@@ -75,7 +75,7 @@ export function readinessManagerFactory(
 
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
-  splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
+  definitions.on(SDK_DEFINITIONS_ARRIVED, checkIsReadyOrUpdate);
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
@@ -85,8 +85,8 @@ export function readinessManagerFactory(
     if (readyTimeout > 0 && !isReady) readyTimeoutId = setTimeout(timeout, readyTimeout);
   }
 
-  splits.initCallbacks.push(__init);
-  if (splits.hasInit) __init();
+  definitions.initCallbacks.push(__init);
+  if (definitions.hasInit) __init();
 
   function checkIsReadyFromCache(cacheMetadata: SdkReadyMetadata) {
     metadataReady = cacheMetadata;
@@ -114,7 +114,7 @@ export function readinessManagerFactory(
         setTimeout(() => { throw e; }, 0);
       }
     } else {
-      if (splits.splitsArrived && segments.segmentsArrived) {
+      if (definitions.definitionsArrived && segments.segmentsArrived) {
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
@@ -137,12 +137,12 @@ export function readinessManagerFactory(
   }
 
   return {
-    splits,
+    definitions,
     segments,
     gate,
 
     shared() {
-      return readinessManagerFactory(EventEmitter, settings, splits, true);
+      return readinessManagerFactory(EventEmitter, settings, definitions, true);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -153,9 +153,9 @@ export function readinessManagerFactory(
     setDestroyed() { isDestroyed = true; },
 
     init() {
-      if (splits.hasInit) return;
-      splits.hasInit = true;
-      splits.initCallbacks.forEach(cb => cb());
+      if (definitions.hasInit) return;
+      definitions.hasInit = true;
+      definitions.initCallbacks.forEach(cb => cb());
     },
 
     destroy() {
@@ -163,7 +163,7 @@ export function readinessManagerFactory(
       syncLastUpdate();
       clearTimeout(readyTimeoutId);
 
-      if (!isShared) splits.hasInit = false;
+      if (!isShared) definitions.hasInit = false;
     },
 
     isReady() { return isReady; },

package/src/readiness/sdkReadinessManager.ts

@@ -5,10 +5,9 @@ import { ISdkReadinessManager } from './types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
+import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';
-const REMOVE_LISTENER_EVENT = 'removeListener';
 const TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 
 /**
@@ -25,19 +24,10 @@ export function sdkReadinessManagerFactory(
 
   const log = settings.log;
 
-  /** Ready callback warning */
-  let internalReadyCbCount = 0;
-  let readyCbCount = 0;
-  readinessManager.gate.on(REMOVE_LISTENER_EVENT, (event: any) => {
-    if (event === SDK_READY) readyCbCount--;
-  });
-
   readinessManager.gate.on(NEW_LISTENER_EVENT, (event: any) => {
     if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
       if (readinessManager.isReady()) {
         log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
-      } else if (event === SDK_READY) {
-        readyCbCount++;
       }
     } else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
       log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
@@ -61,7 +51,6 @@ export function sdkReadinessManagerFactory(
       readinessManager.gate.once(SDK_READY, () => {
         log.info(CLIENT_READY);
 
-        if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(CLIENT_NO_LISTENER);
         resolve();
       });
       readinessManager.gate.once(SDK_READY_TIMED_OUT, (message: string) => {
@@ -91,10 +80,6 @@ export function sdkReadinessManagerFactory(
       return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
     },
 
-    incInternalReadyCbCount() {
-      internalReadyCbCount++;
-    },
-
     sdkStatus: objectAssign(
       // Expose Event Emitter functionality
       Object.create(readinessManager.gate),

package/src/readiness/types.ts

@@ -16,17 +16,17 @@ export interface IReadinessEventEmitter extends SplitIO.IEventEmitter {
 
 /** Splits data emitter */
 
-type SDK_SPLITS_ARRIVED = 'state::splits-arrived'
-type SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded'
-type ISplitsEvent = SDK_SPLITS_ARRIVED | SDK_SPLITS_CACHE_LOADED
+type SDK_DEFINITIONS_ARRIVED = 'state::splits-arrived'
+type SDK_DEFINITIONS_CACHE_LOADED = 'state::splits-cache-loaded'
+type IDefinitionsEvent = SDK_DEFINITIONS_ARRIVED | SDK_DEFINITIONS_CACHE_LOADED
 
-export interface ISplitsEventEmitter extends SplitIO.IEventEmitter {
-  emit(event: ISplitsEvent, ...args: any[]): boolean
-  on(event: ISplitsEvent, listener: (...args: any[]) => void): this;
+export interface IDefinitionsEventEmitter extends SplitIO.IEventEmitter {
+  emit(event: IDefinitionsEvent, ...args: any[]): boolean
+  on(event: IDefinitionsEvent, listener: (...args: any[]) => void): this;
   on(event: SDK_UPDATE, listener: (metadata: SplitIO.SdkUpdateMetadata) => void): this;
-  once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
-  splitsArrived: boolean
-  splitsCacheLoaded: boolean
+  once(event: IDefinitionsEvent, listener: (...args: any[]) => void): this;
+  definitionsArrived: boolean
+  definitionsCacheLoaded: boolean
   hasInit: boolean,
   initCallbacks: (() => void)[]
 }
@@ -48,7 +48,7 @@ export interface ISegmentsEventEmitter extends SplitIO.IEventEmitter {
 
 export interface IReadinessManager {
   /** Event emitters */
-  splits: ISplitsEventEmitter,
+  definitions: IDefinitionsEventEmitter,
   segments: ISegmentsEventEmitter,
   gate: IReadinessEventEmitter,
 
@@ -77,12 +77,6 @@ export interface ISdkReadinessManager {
   readinessManager: IReadinessManager
   sdkStatus: SplitIO.IStatusInterface
 
-  /**
-   * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
-   * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
-   */
-  incInternalReadyCbCount(): void
-
   /** for client-side */
   shared(): ISdkReadinessManager
 }

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 } = params;
+  const { sdkReadinessManager, syncManager, storage, settings, telemetryTracker, impressionsTracker, platform, splitApi } = params;
 
   let hasInit = false;
   let lastActionTime = 0;
@@ -68,6 +68,7 @@ export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?:
 
       // Stop background jobs
       syncManager && syncManager.stop();
+      splitApi && splitApi.stop();
 
       return __flush().then(() => {
         // Cleanup storage

package/src/sdkClient/trackMethod.ts

@@ -12,7 +12,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
  * Reusable by FF SDK client, Configs SDK, and thin-client SDK.
  */
 export function trackMethodFactory(params: Pick<ISdkFactoryContext, 'settings' | 'eventTracker' | 'telemetryTracker' | 'storage' | 'sdkReadinessManager'>, warnTTExistence = true) {
-  const { settings, storage: { splits }, telemetryTracker, eventTracker, sdkReadinessManager: { readinessManager } } = params;
+  const { settings, storage: { definitions }, telemetryTracker, eventTracker, sdkReadinessManager: { readinessManager } } = params;
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
 
@@ -42,7 +42,7 @@ export function trackMethodFactory(params: Pick<ISdkFactoryContext, 'settings' |
     };
 
     // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-    if (warnTTExistence) validateTrafficTypeExistence(log, readinessManager, splits, mode, trafficTypeName, TRACK_FN_LABEL);
+    if (warnTTExistence) validateTrafficTypeExistence(log, readinessManager, definitions, mode, trafficTypeName, TRACK_FN_LABEL);
 
     const result = eventTracker.track(eventData, size);
 

package/src/sdkFactory/index.ts

@@ -6,7 +6,7 @@ import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import SplitIO from '../../types/splitio';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { IStorageSync } from '../storages/types';
@@ -36,11 +36,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
         readiness.timeout();
         return;
       }
-      readiness.splits.emit(SDK_SPLITS_ARRIVED);
+      readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
     onReadyFromCacheCb() {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+      readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED);
     }
   });
 
@@ -48,7 +48,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
-    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
+    if ((storage as IStorageSync).definitions.getChangeNumber() > -1) readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
   }
 
   const clients: Record<string, SplitIO.IBasicClient & { init: () => void }> = {};
@@ -66,7 +66,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
-  const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
+  const managerInstance = sdkManagerFactory(settings, storage.definitions, sdkReadinessManager);
 
 
   function init() {

package/src/sdkManager/index.ts

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
 import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
-import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
+import { IDefinitionsCacheAsync, IDefinitionsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { IDefinition } from '../dtos/types';
 import { ISettings } from '../types';
@@ -48,11 +48,11 @@ function objectsToViews(splitObjects: IDefinition[]) {
   return views;
 }
 
-export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(
+export function sdkManagerFactory<TDefinitionsCache extends IDefinitionsCacheSync | IDefinitionsCacheAsync>(
   settings: Pick<ISettings, 'log' | 'mode'>,
-  splits: TSplitCache,
+  splits: TDefinitionsCache,
   { readinessManager, sdkStatus }: ISdkReadinessManager,
-): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
+): TDefinitionsCache extends IDefinitionsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
 
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
@@ -70,7 +70,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
           return isAsync ? Promise.resolve(null) : null;
         }
 
-        const split = splits.getSplit(splitName);
+        const split = splits.get(splitName);
 
         if (thenable(split)) {
           return split.catch(() => null).then(result => { // handle possible rejections when using pluggable storage
@@ -103,7 +103,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
         if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
           return isAsync ? Promise.resolve([]) : [];
         }
-        const splitNames = splits.getSplitNames();
+        const splitNames = splits.getNames();
 
         return thenable(splitNames) ?
           splitNames.catch(() => []) : // handle possible rejections when using pluggable storage

package/src/services/authProvider.ts

@@ -0,0 +1,86 @@
+import { ISplitHttpClient, NetworkError } from './types';
+import { IJwtCredentialV3 } from '../sync/streaming/AuthClient/types';
+import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { Backoff } from '../utils/Backoff';
+import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
+import { ISettings } from '../types';
+import { TOKEN } from '../utils/constants';
+import { ITelemetryTracker } from '../trackers/types';
+
+const SKEW_SECONDS = 30;
+
+function isExpired(credential: IJwtCredentialV3): boolean {
+  return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
+}
+
+export interface IAuthProvider {
+  credential(): Promise<IJwtCredentialV3>;
+  invalidate(): void;
+  stop(): void;
+}
+
+/**
+ * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
+ * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
+ */
+export function authProviderFactory(settings: ISettings, splitHttpClient: ISplitHttpClient, telemetryTracker: ITelemetryTracker): IAuthProvider {
+
+  const { urls, log } = settings;
+
+  function fetchAuth() {
+    let url = `${urls.auth}/v3/auth?capabilities=config`;
+    return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+  }
+
+  const authenticate = authenticateFactory(fetchAuth);
+  const backoff = new Backoff(fetchCredential);
+
+  let cachedCredential: IJwtCredentialV3 | undefined;
+  let inFlightPromise: Promise<IJwtCredentialV3> | undefined;
+  let stopped = false;
+
+  function fetchCredential(): Promise<IJwtCredentialV3> {
+    return authenticate().then((credential: IJwtCredentialV3) => {
+      log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
+      cachedCredential = credential;
+      inFlightPromise = undefined;
+      backoff.reset();
+      return credential;
+    }).catch((error: NetworkError) => {
+      // Avoid rejected promises and unnecessary retries after stop()
+      if (stopped) return cachedCredential!;
+
+      if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
+        log.error(LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
+        inFlightPromise = undefined;
+        throw error;
+      }
+
+      log.warn(LOG_PREFIX_SYNC_AUTH + 'credential fetch failed (attempt ' + (backoff.attempts + 1) + '). Error: ' + error.message);
+      return backoff.scheduleCallAsync();
+    });
+  }
+
+  return {
+    credential(): Promise<IJwtCredentialV3> {
+      if (cachedCredential && !isExpired(cachedCredential)) {
+        return Promise.resolve(cachedCredential);
+      }
+
+      if (cachedCredential) log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
+
+      return inFlightPromise || (inFlightPromise = fetchCredential());
+    },
+
+    invalidate() {
+      cachedCredential = undefined;
+    },
+
+    stop() {
+      stopped = true;
+      cachedCredential = undefined;
+      inFlightPromise = undefined;
+      backoff.reset();
+    }
+  };
+}

package/src/services/secureSplitHttpClient.ts

@@ -0,0 +1,44 @@
+import { IRequestOptions, IResponse, ISecureSplitHttpClient, NetworkError } from './types';
+import { ISettings } from '../types';
+import { IPlatform } from '../sdkFactory/types';
+import { splitHttpClientFactory } from './splitHttpClient';
+import { authProviderFactory } from './authProvider';
+import { ITelemetryTracker } from '../trackers/types';
+
+/**
+ * Factory of Secure HTTP client, which authenticates requests using a JWT token.
+ * On 401 responses, invalidates the cached credential and retries once with a fresh token.
+ *
+ * @param settings - SDK settings
+ * @param platform - object containing environment-specific dependencies
+ * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
+ */
+export function secureSplitHttpClientFactory(settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISecureSplitHttpClient {
+
+  const splitHttpClient = splitHttpClientFactory(settings, platform);
+  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);
+  }
+
+  const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean): Promise<IResponse> {
+    return authProvider.credential().then(credential => {
+      return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+        .catch((error: NetworkError) => {
+          if (error.statusCode === 401) {
+            // retry once for 401, in case the token has just expired
+            authProvider.invalidate();
+            return authProvider.credential().then(newCredential => {
+              return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+            });
+          }
+          throw error;
+        });
+    });
+  };
+
+  httpClient.stop = () => authProvider.stop();
+
+  return httpClient;
+}

package/src/services/splitApi.ts

@@ -1,7 +1,7 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
-import { ISplitApi } from './types';
+import { ISecureSplitHttpClient, ISplitApi } 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';
@@ -23,13 +23,15 @@ function userKeyToQueryParam(userKey: string) {
 export function splitApiFactory(
   settings: ISettings,
   platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
-  telemetryTracker: ITelemetryTracker
+  telemetryTracker: ITelemetryTracker,
+  secureSplitHttpClientFactory?: (settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker) => ISecureSplitHttpClient,
 ): ISplitApi {
 
   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
@@ -61,15 +63,20 @@ export function splitApiFactory(
         });
     },
 
+    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/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.sdk}/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+      const url = `${urls.configs}/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      return (secureSplitHttpClient || splitHttpClient)(url, noCache ? noCacheHeaderOptions : undefined);
     },
 
-    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
-      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
+    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) {
@@ -149,6 +156,10 @@ export function splitApiFactory(
     postMetricsUsage(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/usage`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
+    },
+
+    stop() {
+      if (secureSplitHttpClient) secureSplitHttpClient.stop();
     }
   };
 }

package/src/services/types.ts

@@ -33,6 +33,8 @@ export type IHealthCheckAPI = () => Promise<boolean>
 
 export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>
 
+export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
+
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
@@ -60,8 +62,9 @@ export interface ISplitApi {
 	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchDefinitionChanges
-	fetchConfigs: IFetchDefinitionChanges
 	fetchSegmentChanges: IFetchSegmentChanges
+	fetchConfigs: IFetchDefinitionChanges
+	fetchConfigsSegmentChanges: IFetchSegmentChanges
 	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
@@ -70,6 +73,8 @@ export interface ISplitApi {
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig
 	postMetricsUsage: IPostMetricsUsage
+	// lifecycle
+	stop(): void
 }
 
 // Minimal version of EventSource API used by the SDK

package/src/storages/AbstractDefinitionsCacheAsync.ts

@@ -0,0 +1,63 @@
+import { IDefinitionsCacheAsync } from './types';
+import { IDefinition } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
+
+/**
+ * This class provides a skeletal implementation of the IDefinitionsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+export abstract class AbstractDefinitionsCacheAsync implements IDefinitionsCacheAsync {
+
+  protected abstract add(definition: IDefinition): Promise<boolean>
+  protected abstract remove(name: string): Promise<boolean>
+  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
+
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(addedFF => this.add(addedFF))),
+      Promise.all(toRemove.map(removedFF => this.remove(removedFF)))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
+  abstract get(name: string): Promise<IDefinition | null>
+  abstract getMany(names: string[]): Promise<Record<string, IDefinition | null>>
+  abstract getChangeNumber(): Promise<number>
+  abstract getAll(): Promise<IDefinition[]>
+  abstract getNames(): Promise<string[]>
+  abstract getNamesBySets(sets: string[]): Promise<Set<string>[]>
+  abstract trafficTypeExists(trafficType: string): Promise<boolean>
+  abstract clear(): Promise<boolean | void>
+
+  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+  // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
+  usesSegments(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  /**
+   * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
+   * Used for SPLIT_KILL push notifications.
+   *
+   * @returns a promise that is resolved once the definition kill operation is performed. The fulfillment value is a boolean: `true` if the operation succeeded updating the definition or `false` if no definition is updated,
+   * for instance, if the `changeNumber` is old, or if the definition is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+   * The promise will never be rejected.
+   */
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
+    return this.get(name).then(definition => {
+
+      if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
+        const newDefinition = objectAssign({}, definition);
+        newDefinition.killed = true;
+        newDefinition.defaultTreatment = defaultTreatment;
+        newDefinition.changeNumber = changeNumber;
+
+        return this.add(newDefinition);
+      }
+      return false;
+    }).catch(() => false);
+  }
+
+}