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

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/client.ts

@@ -1,17 +1,17 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
-import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
+import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
 import { ImpressionDecorated } from '../trackers/types';
+import { trackMethodFactory } from './trackMethod';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
@@ -23,7 +23,7 @@ function treatmentsNotReady(featureFlagNames: string[]) {
   return evaluations;
 }
 
-function stringify(options?: SplitIO.EvaluationOptions) {
+export function stringify(options?: SplitIO.EvaluationOptions) {
   if (options && options.properties) {
     try {
       return JSON.stringify(options.properties);
@@ -35,7 +35,7 @@ function stringify(options?: SplitIO.EvaluationOptions) {
  * Creator of base client with getTreatments and track methods.
  */
 export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker, fallbackTreatmentsCalculator } = params;
+  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, telemetryTracker, fallbackCalculator } = params;
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
 
@@ -147,16 +147,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
-      const fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+      const fallbackTreatment = fallbackCalculator(featureFlagName, label);
       treatment = fallbackTreatment.treatment;
       label = fallbackTreatment.label;
       config = fallbackTreatment.config;
     }
 
-    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-
-    if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      log.info(IMPRESSION_QUEUEING);
+    if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+      log.info(IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
       queue.push({
         imp: {
           feature: featureFlagName,
@@ -175,42 +173,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     if (withConfig) {
       return {
         treatment,
-        config
+        config: config as string | null
       };
     }
 
     return treatment;
   }
 
-  function track(key: SplitIO.SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: SplitIO.Properties, size = 1024) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
-
-    const matchingKey = getMatching(key);
-    const timestamp = Date.now();
-    const eventData: SplitIO.EventData = {
-      eventTypeId,
-      trafficTypeName,
-      value,
-      timestamp,
-      key: matchingKey,
-      properties
-    };
-
-    // 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.
-    validateTrafficTypeExistence(log, readinessManager, storage.splits, 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;
-    }
-  }
+  const track = trackMethodFactory(params);
 
   return {
     getTreatment,

package/src/sdkClient/clientInputValidation.ts

@@ -1,31 +1,27 @@
 import {
   validateAttributes,
-  validateEvent,
-  validateEventValue,
-  validateEventProperties,
   validateKey,
-  validateSplit,
-  validateSplits,
-  validateTrafficType,
+  validateDefinition,
+  validateDefinitions,
   validateIfNotDestroyed,
   validateIfReadyFromCache,
   validateEvaluationOptions
 } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
+import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG } from '../utils/constants';
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
-import { IFallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
+import { IFallbackCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager, fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator): TClient {
+export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager, fallbackCalculator: IFallbackCalculator): TClient {
 
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
@@ -39,14 +35,14 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
       validateFlagSets(log, methodName, maybeNameOrNames as string[], settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
       startsWith(methodName, GET_TREATMENTS) ?
-        validateSplits(log, maybeNameOrNames, methodName) :
-        validateSplit(log, maybeNameOrNames, methodName);
+        validateDefinitions(log, maybeNameOrNames, methodName) :
+        validateDefinition(log, maybeNameOrNames, methodName);
 
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
     const options = validateEvaluationOptions(log, maybeOptions, methodName);
 
-    validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
+    validateIfReadyFromCache(log, readinessManager, methodName);
 
     const valid = isNotDestroyed && key && nameOrNames && attributes !== false;
 
@@ -59,17 +55,20 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     };
   }
 
-  function evaluateFallBackTreatment(featureFlagName: string, withConfig: boolean): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const { treatment, config } = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
+  function evaluateFallBackTreatment(featureFlagName: string | false | string[], withConfig: boolean) {
+    if (Array.isArray(featureFlagName)) {
+      const res: SplitIO.Treatments = {};
+      featureFlagName.forEach((split: string) => res[split] = evaluateFallBackTreatment(split, withConfig) as SplitIO.Treatment);
+      return res;
+    }
+
+    const { treatment, config } = fallbackCalculator(featureFlagName as string);
 
-    if (withConfig) {
-      return {
+    return withConfig ?
+      {
         treatment,
         config
-      };
-    }
-
-    return treatment;
+      } : treatment;
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
@@ -79,104 +78,65 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, false);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, false));
   }
 
   function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, true);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, true));
   }
 
   function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.Treatments = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach((split: string) => res[split] = evaluateFallBackTreatment(split, false) as SplitIO.Treatment);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], false));
   }
 
   function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.TreatmentsWithConfig = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach(split => res[split] = evaluateFallBackTreatment(split, true) as SplitIO.TreatmentWithConfig);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], true));
   }
 
   function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
-    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
-    const tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
-    const event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
-    const eventValue = 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 && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-      return client.track(key, tt, event, eventValue, properties, size);
-    } else {
-      return isAsync ? Promise.resolve(false) : false;
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   return {
@@ -188,6 +148,6 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatmentsWithConfigByFlagSets,
     getTreatmentsByFlagSet,
     getTreatmentsWithConfigByFlagSet,
-    track
+    track: client.track,
   } as TClient;
 }

package/src/sdkClient/sdkClient.ts

@@ -1,39 +1,16 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import SplitIO from '../../types/splitio';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-
-const COOLDOWN_TIME_IN_MILLIS = 1000;
+import { sdkLifecycleFactory } from './sdkLifecycle';
 
 /**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
-
-  let lastActionTime = 0;
-
-  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();
-    }
-  }
+  const { sdkReadinessManager, settings } = params;
 
-  function __flush() {
-    return syncManager ? syncManager.flush() : Promise.resolve();
-  }
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -44,35 +21,9 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
       settings,
       clientFactory(params),
       sdkReadinessManager.readinessManager,
-      params.fallbackTreatmentsCalculator
+      params.fallbackCalculator
     ),
 
-    // Sdk destroy
-    {
-      flush() {
-        // @TODO define cooldown time
-        return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-      },
-      destroy() {
-        // 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();
-          uniqueKeysTracker.stop();
-        }
-
-        // Stop background jobs
-        syncManager && syncManager.stop();
-
-        return __flush().then(() => {
-          // Cleanup storage
-          return storage.destroy();
-        });
-      }
-    }
+    sdkLifecycleFactory(params, isSharedClient)
   );
 }