@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/src/sdkClient/sdkLifecycle.ts

@@ -0,0 +1,79 @@
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
+import { ISdkFactoryContext } from '../sdkFactory/types';
+
+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;
+
+  let hasInit = false;
+  let lastActionTime = 0;
+
+  const signalListener = platform.SignalListener && new platform.SignalListener(params);
+
+  function __cooldown(func: Function, time: number) {
+    const now = Date.now();
+    //get the actual time elapsed in ms
+    const timeElapsed = now - lastActionTime;
+    //check if the time elapsed is less than desired cooldown
+    if (timeElapsed < time) {
+      //if yes, return message with remaining time in seconds
+      settings.log.warn(`Flush cooldown, remaining time ${(time - timeElapsed) / 1000} seconds`);
+      return Promise.resolve();
+    } else {
+      //Do the requested action and re-assign the lastActionTime
+      lastActionTime = now;
+      return func();
+    }
+  }
+
+  function __flush() {
+    return syncManager ? syncManager.flush() : Promise.resolve();
+  }
+
+  return {
+    init() {
+      if (hasInit) return;
+      hasInit = true;
+
+      if (!isSharedClient) {
+        validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
+        sdkReadinessManager.readinessManager.init();
+        impressionsTracker.start();
+        syncManager && syncManager.start();
+        signalListener && signalListener.start();
+      }
+    },
+
+    flush() {
+      // @TODO define cooldown time
+      return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+    },
+
+    destroy() {
+      hasInit = false;
+      // Mark the SDK as destroyed immediately
+      sdkReadinessManager.readinessManager.destroy();
+
+      // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+      if (!isSharedClient) {
+        releaseApiKey(settings.core.authorizationKey);
+        telemetryTracker.sessionLength();
+        signalListener && signalListener.stop();
+        impressionsTracker.stop();
+      }
+
+      // Stop background jobs
+      syncManager && syncManager.stop();
+      splitApi && splitApi.stop();
+
+      return __flush().then(() => {
+        // Cleanup storage
+        return storage.destroy();
+      });
+    }
+  };
+}

package/src/sdkClient/trackMethod.ts

@@ -0,0 +1,59 @@
+import { thenable } from '../utils/promise/thenable';
+import { getMatching } from '../utils/key';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateKey, validateTrafficType, validateEvent, validateEventValue, validateEventProperties, validateIfNotDestroyed } from '../utils/inputValidation';
+import { TRACK, TRACK_FN_LABEL } from '../utils/constants';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+import SplitIO from '../../types/splitio';
+import { ISdkFactoryContext } from '../sdkFactory/types';
+
+/**
+ * Creates a standalone `track` function with input validation.
+ * 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: { definitions }, telemetryTracker, eventTracker, sdkReadinessManager: { readinessManager } } = params;
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
+
+  return function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    // Input validation
+    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+    const trafficTypeName = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+    const eventTypeId = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+    const value = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+    const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
+    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
+
+    if (!(isNotDestroyed && key && trafficTypeName && eventTypeId && value !== false && properties !== false)) {
+      return isAsync ? Promise.resolve(false) : false;
+    }
+
+    // Core logic
+    const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+
+    const eventData: SplitIO.EventData = {
+      eventTypeId,
+      trafficTypeName,
+      value,
+      timestamp: Date.now(),
+      key: getMatching(key),
+      properties: properties as SplitIO.Properties | undefined
+    };
+
+    // 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, definitions, mode, trafficTypeName, TRACK_FN_LABEL);
+
+    const result = eventTracker.track(eventData, size);
+
+    if (thenable(result)) {
+      return result.then((result) => {
+        stopTelemetryTracker();
+        return result;
+      });
+    } else {
+      stopTelemetryTracker();
+      return result;
+    }
+  };
+}

package/src/sdkFactory/index.ts

@@ -4,16 +4,10 @@ import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import SplitIO from '../../types/splitio';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 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 { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { IStorageSync } from '../storages/types';
 import { getMatching } from '../utils/key';
@@ -24,24 +18,13 @@ 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, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, lazyInit } = params;
-  const { log, sync: { impressionsMode }, initialRolloutPlan, core: { key } } = settings;
+  const { settings, platform, storageFactory, splitApiFactory, extraProps, syncManagerFactory,
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory, lazyInit } = params;
+  const { log, initialRolloutPlan, core: { key } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // initialization
-  let hasInit = false;
-  const initCallbacks: (() => void)[] = [];
-
-  function whenInit(cb: () => void) {
-    if (hasInit) cb();
-    else initCallbacks.push(cb);
-  }
-
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
 
@@ -53,67 +36,41 @@ 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);
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+  const fallbackCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   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> = {};
+  const clients: Record<string, SplitIO.IBasicClient & { init: () => void }> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-
-  const noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-  const strategy = impressionsMode === OPTIMIZED ?
-    strategyOptimizedFactory(observer, storage.impressionCounts) :
-    impressionsMode === DEBUG ?
-      strategyDebugFactory(observer) :
-      noneStrategy;
-
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+  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);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackTreatmentsCalculator };
-
-  const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
-  ctx.syncManager = syncManager;
-
-  const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-  ctx.signalListener = signalListener;
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackCalculator };
+  ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
 
   // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
-  const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
+  const managerInstance = sdkManagerFactory(settings, storage.definitions, sdkReadinessManager);
 
 
   function init() {
-    if (hasInit) return;
-    hasInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
+    Object.keys(clients).map(key => clients[key].init());
   }
 
   log.info(NEW_FACTORY, [settings.version]);
@@ -135,7 +92,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     settings,
 
     destroy() {
-      hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());

package/src/sdkFactory/types.ts

@@ -3,12 +3,12 @@ import { ISignalListener } from '../listeners/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import type { sdkManagerFactory } from '../sdkManager';
 import type { splitApiFactory } from '../services/splitApi';
-import type { IFallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
+import type { IFallbackCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter } from '../trackers/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 
@@ -35,9 +35,17 @@ export interface IPlatform {
   /**
    * Function used to track latencies for telemetry.
    */
-  now?: () => number
+  now?: () => number,
+  /**
+   * Optional signal listener constructor. Used to listen and handle runtime environment states, like server shutdown, app paused or resumed.
+   */
+  // eslint-disable-next-line no-use-before-define
+  SignalListener?: new (params: ISdkFactoryContext) => ISignalListener, // Used by BrowserSignalListener
 }
 
+// Definition type
+export type EntityType = 'config' | 'flag';
+
 export interface ISdkFactoryContext {
   platform: IPlatform,
   sdkReadinessManager: ISdkReadinessManager,
@@ -47,12 +55,11 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker: IUniqueKeysTracker,
-  signalListener?: ISignalListener
-  splitApi?: ISplitApi
+  splitApi?: ISplitApi,
   syncManager?: ISyncManager,
   clients: Record<string, SplitIO.IBasicClient>,
-  fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator
+  fallbackCalculator: IFallbackCalculator,
+  entityType?: EntityType
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
@@ -98,21 +105,17 @@ export interface ISdkFactoryParams {
 
   // Sdk client method factory.
   // It Allows to distinguish SDK clients with the client-side API (`IBrowserSDK` and `IBrowserAsyncSDK`) or server-side API (`ISDK` and `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.IBrowserClient; (key: SplitIO.SplitKey): SplitIO.IBrowserClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => (
+    { (): SplitIO.IBrowserClient & { init(): void }; (key: SplitIO.SplitKey): SplitIO.IBrowserClient & { init(): void }; } |
+    (() => SplitIO.IClient & { init(): void }) |
+    (() => SplitIO.IAsyncClient & { init(): void })
+  )
 
   // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver
 
   filterAdapterFactory?: () => IFilterAdapter
 
-  // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
-  // Pass only if `syncManager` (used by NodeSignalListener) and `splitApi` (used by Browser listener) are passed.
-  SignalListener?: new (
-    syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
-    settings: ISettings, // Used by BrowserSignalListener
-    storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
-    serviceApi: ISplitApi | undefined) => ISignalListener, // Used by BrowserSignalListener
-
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 

package/src/sdkManager/index.ts

@@ -1,16 +1,16 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
-import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
+import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
+import { IDefinitionsCacheAsync, IDefinitionsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISplit } from '../dtos/types';
+import { IDefinition } from '../dtos/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 
-function collectTreatments(splitObject: ISplit) {
+function collectTreatments(splitObject: IDefinition) {
   const conditions = splitObject.conditions;
   // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
   let allTreatmentsCondition = find(conditions, (cond) => cond.conditionType === 'ROLLOUT');
@@ -20,7 +20,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions!.map(v => v.treatment) : [];
 }
 
-function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
+function objectToView(splitObject: IDefinition | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -29,7 +29,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     killed: splitObject.killed,
     changeNumber: splitObject.changeNumber || 0,
     treatments: collectTreatments(splitObject),
-    configs: splitObject.configurations || {},
+    configs: splitObject.configurations as SplitIO.SplitView['configs'] || {},
     sets: splitObject.sets || [],
     defaultTreatment: splitObject.defaultTreatment,
     impressionsDisabled: splitObject.impressionsDisabled === true,
@@ -37,7 +37,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(splitObjects: ISplit[]) {
+function objectsToViews(splitObjects: IDefinition[]) {
   let views: SplitIO.SplitView[] = [];
 
   splitObjects.forEach(split => {
@@ -48,11 +48,11 @@ function objectsToViews(splitObjects: ISplit[]) {
   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);
@@ -65,21 +65,21 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag object corresponding to the given feature flag name if valid
        */
       split(featureFlagName: string) {
-        const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
+        const splitName = validateDefinition(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           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
-            validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+            validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
             return objectToView(result);
           });
         }
 
-        validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+        validateDefinitionExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
 
         return objectToView(split);
       },
@@ -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,6 +63,12 @@ export function splitApiFactory(
         });
     },
 
+    // @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 (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));
@@ -143,6 +151,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,9 +33,11 @@ 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 IFetchSplitChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
+export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
@@ -59,7 +61,8 @@ export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
 	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
-	fetchSplitChanges: IFetchSplitChanges
+	fetchSplitChanges: IFetchDefinitionChanges
+	fetchConfigs: IFetchDefinitionChanges
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk
@@ -69,6 +72,8 @@ export interface ISplitApi {
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig
 	postMetricsUsage: IPostMetricsUsage
+	// lifecycle
+	stop(): void
 }
 
 // Minimal version of EventSource API used by the SDK