@splitsoftware/splitio-commons 1.6.2-rc.3 → 1.6.2-rc.6

package/src/readiness/types.ts

@@ -1,4 +1,4 @@
-import { IEventEmitter, IStatusInterface, Event } from '../types';
+import { IEventEmitter, IStatusInterface } from '../types';
 
 /** Splits data emitter */
 
@@ -28,8 +28,15 @@ export interface ISegmentsEventEmitter extends IEventEmitter {
 
 /** Readiness emitter */
 
+export type SDK_READY_TIMED_OUT = 'init::timeout'
+export type SDK_READY = 'init::ready'
+export type SDK_READY_FROM_CACHE = 'init::cache-ready'
+export type SDK_UPDATE = 'state::update'
+export type SDK_DESTROY = 'state::destroy'
+export type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_CACHE | SDK_UPDATE | SDK_DESTROY
+
 export interface IReadinessEventEmitter extends IEventEmitter {
-  emit(event: Event, ...args: any[]): boolean
+  emit(event: IReadinessEvent, ...args: any[]): boolean
 }
 
 /** Readiness manager */

package/src/sdkClient/client.ts

@@ -6,18 +6,18 @@ import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTy
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
-import { SplitKey, Attributes,ImpressionDTO, Treatment, TreatmentWithConfig, Properties, EventData, IClientSS, IAsyncClientSS } from '../types';
+import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncClientSS {
+export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
 
-  function getTreatment(key: SplitKey, splitName: string, attributes: Attributes | undefined, withConfig = false) {
+  function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
@@ -34,16 +34,16 @@ export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncCli
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
 
-  function getTreatmentWithConfig(key: SplitKey, splitName: string, attributes: Attributes | undefined) {
+  function getTreatmentWithConfig(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined) {
     return getTreatment(key, splitName, attributes, true);
   }
 
-  function getTreatments(key: SplitKey, splitNames: string[], attributes: Attributes | undefined, withConfig = false) {
+  function getTreatments(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
-      const treatments: Record<string, Treatment | TreatmentWithConfig> = {};
+      const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       Object.keys(evaluationResults).forEach(splitName => {
         treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
       });
@@ -58,7 +58,7 @@ export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncCli
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
-  function getTreatmentsWithConfig(key: SplitKey, splitNames: string[], attributes: Attributes | undefined) {
+  function getTreatmentsWithConfig(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined) {
     return getTreatments(key, splitNames, attributes, true);
   }
 
@@ -66,12 +66,12 @@ export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncCli
   function processEvaluation(
     evaluation: IEvaluationResult,
     splitName: string,
-    key: SplitKey,
-    attributes: Attributes | undefined,
+    key: SplitIO.SplitKey,
+    attributes: SplitIO.Attributes | undefined,
     withConfig: boolean,
     invokingMethodName: string,
     queue: ImpressionDTO[]
-  ): Treatment | TreatmentWithConfig {
+  ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
     const isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
@@ -107,12 +107,12 @@ export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncCli
     return treatment;
   }
 
-  function track(key: SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: Properties, size = 1024) {
+  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: EventData = {
+    const eventData: SplitIO.EventData = {
       eventTypeId,
       trafficTypeName,
       value,
@@ -144,5 +144,5 @@ export function clientFactory(params: ISdkFactoryContext): IClientSS | IAsyncCli
     getTreatmentsWithConfig,
     track,
     isClientSide: false
-  } as any;
+  } as SplitIO.IClient | SplitIO.IAsyncClient;
 }

package/src/sdkClient/clientAttributesDecoration.ts

@@ -1,13 +1,13 @@
 import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
 import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import { Attributes, IAsyncClientSS, IClientSS, Properties, SplitKey } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
  */
-export function clientAttributesDecoration(log: ILogger, client: IClientSS | IAsyncClientSS) {
+export function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
 
   const attributeStorage = new AttributesCacheInMemory();
 
@@ -18,27 +18,27 @@ export function clientAttributesDecoration(log: ILogger, client: IClientSS | IAs
   const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
   const clientTrack = client.track;
 
-  function getTreatment(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
     return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
     return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
   }
 
-  function getTreatments(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
     return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
     return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
   }
 
-  function track(maybeKey: SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: Properties) {
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
   }
 
-  function combineAttributes(maybeAttributes: Attributes | undefined): Attributes | undefined{
+  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
     const storedAttributes = attributeStorage.getAll();
     if (Object.keys(storedAttributes).length > 0) {
       return objectAssign({}, storedAttributes, maybeAttributes);

package/src/sdkClient/clientCS.ts

@@ -1,5 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IClientSS, IClientWithKeyLegacy, ILogger, SplitKey } from '../types';
+import { ILogger } from '../logger/types';
+import { SplitIO } from '../types';
 import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
@@ -10,7 +11,7 @@ import { clientAttributesDecoration } from './clientAttributesDecoration';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(log: ILogger, client: IClientSS, key: SplitKey, trafficType?: string): IClientWithKeyLegacy {
+export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
 
   let clientCS = clientAttributesDecoration(log, client);
 
@@ -25,5 +26,5 @@ export function clientCSDecorator(log: ILogger, client: IClientSS, key: SplitKey
     track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
 
     isClientSide: true
-  }) as any;
+  }) as SplitIO.ICsClient;
 }

package/src/sdkClient/clientInputValidation.ts

@@ -15,14 +15,14 @@ import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
-import { ISettings, SplitKey, Treatments, TreatmentsWithConfig, Properties, Attributes, IClientSS, IAsyncClientSS } from '../types';
+import { ISettings, SplitIO } from '../types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
 
 /**
  * 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(settings: ISettings, client: IClientSS | IAsyncClientSS, readinessManager: IReadinessManager): IClientSS | IAsyncClientSS {
+export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
 
   const log = settings.log;
   const isSync = isStorageSync(settings);
@@ -30,7 +30,7 @@ export function clientInputValidationDecorator(settings: ISettings, client: ICli
   /**
    * Avoid repeating this validations code
    */
-  function validateEvaluationParams(maybeKey: SplitKey, maybeSplitOrSplits: string | string[], maybeAttributes: Attributes | undefined, methodName: string) {
+  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeSplitOrSplits: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
     const multi = startsWith(methodName, 'getTreatments');
     const key = validateKey(log, maybeKey, methodName);
     const splitOrSplits = multi ? validateSplits(log, maybeSplitOrSplits, methodName) : validateSplit(log, maybeSplitOrSplits, methodName);
@@ -53,53 +53,53 @@ export function clientInputValidationDecorator(settings: ISettings, client: ICli
     return isSync ? value : Promise.resolve(value);
   }
 
-  function getTreatment(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
 
     if (params.valid) {
-      return client.getTreatment(params.key as SplitKey, params.splitOrSplits as string, params.attributes as Attributes | undefined);
+      return client.getTreatment(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
     } else {
       return wrapResult(CONTROL);
     }
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitKey, maybeSplit: string, maybeAttributes?: Attributes) {
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
 
     if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitKey, params.splitOrSplits as string, params.attributes as Attributes | undefined);
+      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
     } else {
       return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
     }
   }
 
-  function getTreatments(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
 
     if (params.valid) {
-      return client.getTreatments(params.key as SplitKey, params.splitOrSplits as string[], params.attributes as Attributes | undefined);
+      return client.getTreatments(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
     } else {
-      const res: Treatments = {};
+      const res: SplitIO.Treatments = {};
       if (params.splitOrSplits) (params.splitOrSplits as string[]).forEach((split: string) => res[split] = CONTROL);
 
       return wrapResult(res);
     }
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitKey, maybeSplits: string[], maybeAttributes?: Attributes) {
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
     const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
 
     if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitKey, params.splitOrSplits as string[], params.attributes as Attributes | undefined);
+      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
     } else {
-      const res: TreatmentsWithConfig = {};
+      const res: SplitIO.TreatmentsWithConfig = {};
       if (params.splitOrSplits) (params.splitOrSplits as string[]).forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
 
       return wrapResult(res);
     }
   }
 
-  function track(maybeKey: SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: Properties) {
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     const key = validateKey(log, maybeKey, 'track');
     const tt = validateTrafficType(log, maybeTT, 'track');
     const event = validateEvent(log, maybeEvent, 'track');
@@ -120,5 +120,5 @@ export function clientInputValidationDecorator(settings: ISettings, client: ICli
     getTreatments,
     getTreatmentsWithConfig,
     track
-  } as IClientSS | IAsyncClientSS;
+  } as TClient;
 }

package/src/sdkClient/sdkClient.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IBasicClient, IStatusInterface } from '../types';
+import { IStatusInterface, SplitIO } from '../types';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
@@ -8,7 +8,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): IBasicClient {
+export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
 
   return objectAssign(

package/src/sdkClient/sdkClientMethod.ts

@@ -1,4 +1,4 @@
-import { IBasicClient } from '../types';
+import { SplitIO } from '../types';
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
@@ -6,7 +6,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export function sdkClientMethodFactory(params: ISdkFactoryContext): () => IBasicClient {
+export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);
 

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { IClientSS, IClientWithKey, SplitKey } from '../types';
+import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
@@ -9,7 +9,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitKey) {
+function buildInstanceId(key: SplitIO.SplitKey) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
 }
@@ -20,23 +20,23 @@ const method = 'Client instantiation';
  * Factory of client method for the client-side API variant where TT is ignored and thus
  * clients don't have a binded TT for the track method.
  */
-export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey) => IClientWithKey {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as IClientSS,
-    key!
+    sdkClientFactory(params) as SplitIO.IClient,
+    key
   );
 
-  const parsedDefaultKey = keyParser(key!);
+  const parsedDefaultKey = keyParser(key);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, IClientWithKey> = {};
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitKey) {
+  return function client(key?: SplitIO.SplitKey) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -76,7 +76,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as IClientSS,
+        }), true) as SplitIO.IClient,
         validKey
       );
 

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { IClientSS, IClientWithKeyLegacy, SplitKey } from '../types';
+import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
 import { getMatching, keyParser } from '../utils/key';
@@ -10,7 +10,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitKey, trafficType?: string) {
+function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
 }
@@ -22,24 +22,24 @@ const method = 'Client instantiation';
  * where clients can have a binded TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
-export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey, trafficType?: string) => IClientWithKeyLegacy {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as IClientSS,
-    key!,
+    sdkClientFactory(params) as SplitIO.IClient,
+    key,
     trafficType
   );
 
-  const parsedDefaultKey = keyParser(key!);
+  const parsedDefaultKey = keyParser(key);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, IClientWithKeyLegacy> = {};
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitKey, trafficType?: string) {
+  return function client(key?: SplitIO.SplitKey, trafficType?: string) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -86,7 +86,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as IClientSS,
+        }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
       );

package/src/sdkFactory/index.ts

@@ -4,7 +4,7 @@ import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { IStorageFactoryParams } from '../storages/types';
-import { IBasicSDK } from '../types';
+import { SplitIO } from '../types';
 import { getMatching } from '../utils/key';
 import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
@@ -17,7 +17,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * Modular SDK factory
  */
-export function sdkFactory(params: ISdkFactoryParams): IBasicSDK<any, any> {
+export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.ISDK | SplitIO.IAsyncSDK {
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
@@ -41,7 +41,6 @@ export function sdkFactory(params: ISdkFactoryParams): IBasicSDK<any, any> {
 
     // ATM, only used by InLocalStorage
     matchingKey: getMatching(settings.core.key),
-    // @ts-ignore
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
     // ATM, only used by PluggableStorage
@@ -61,13 +60,13 @@ export function sdkFactory(params: ISdkFactoryParams): IBasicSDK<any, any> {
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
+  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
   // trackers
   const observer = impressionsObserverFactory && impressionsObserverFactory();
   const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);

package/src/sdkFactory/types.ts

@@ -1,13 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { IAsyncClientSS, IAsyncManager, IClientSS, IClientWithKey, ILogger, IManager, SplitKey } from '../types';
+import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
-import { ISettings, IEventEmitter } from '../types';
+import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
@@ -90,11 +90,11 @@ export interface ISdkFactoryParams {
     log: ILogger,
     splits: ISplitsCacheSync | ISplitsCacheAsync,
     sdkReadinessManager: ISdkReadinessManager
-  ) => IManager | IAsyncManager,
+  ) => SplitIO.IManager | SplitIO.IAsyncManager,
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): IClientWithKey; (key: SplitKey, trafficType?: string | undefined): IClientWithKey; } | (() => IClientSS) | (() => IAsyncClientSS))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.

package/src/sdkManager/index.ts

@@ -5,8 +5,8 @@ import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validate
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
-import { IAsyncManager, IManager, SplitView } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 
 function collectTreatments(splitObject: ISplit) {
   const conditions = splitObject.conditions;
@@ -18,16 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitView | null {
-  let splitObject: ISplit | null;
-
-  try {
-    // @ts-expect-error
-    splitObject = JSON.parse(json);
-  } catch (e) {
-    return null;
-  }
-
+function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -40,10 +31,10 @@ function objectToView(json: string | null): SplitView | null {
   };
 }
 
-function objectsToViews(jsons: string[]) {
-  let views: SplitView[] = [];
+function objectsToViews(splitObjects: ISplit[]) {
+  let views: SplitIO.SplitView[] = [];
 
-  jsons.forEach(split => {
+  splitObjects.forEach(split => {
     const view = objectToView(split);
     if (view) views.push(view);
   });
@@ -55,7 +46,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   log: ILogger,
   splits: TSplitCache,
   { readinessManager, sdkStatus }: ISdkReadinessManager
-): TSplitCache extends ISplitsCacheAsync ? IAsyncManager : IManager {
+): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
   const SPLIT_FN_LABEL = 'split';
 
   return objectAssign(

package/src/services/splitApi.ts

@@ -25,7 +25,6 @@ export function splitApiFactory(
 ): ISplitApi {
 
   const urls = settings.urls;
-  // @ts-ignore
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -7,14 +8,15 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  abstract addSplit(name: string, split: string): Promise<boolean>
-  abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>
+  // Implement addSplits and removeSplits here and others like AbstractSplitsCacheSync, to reuse code between redis and pluggable implementations
+  abstract addSplit(name: string, split: ISplit): Promise<boolean>
+  abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>
   abstract removeSplits(names: string[]): Promise<boolean[] | void>
-  abstract getSplit(name: string): Promise<string | null>
-  abstract getSplits(names: string[]): Promise<Record<string, string | null>>
+  abstract getSplit(name: string): Promise<ISplit | null>
+  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
   abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<string[]>
+  abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
@@ -47,16 +49,13 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
     return this.getSplit(name).then(split => {
 
-      if (split) {
-        const parsedSplit: ISplit = JSON.parse(split);
-        if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-          parsedSplit.killed = true;
-          parsedSplit.defaultTreatment = defaultTreatment;
-          parsedSplit.changeNumber = changeNumber;
-          const newSplit = JSON.stringify(parsedSplit);
+      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+        const newSplit = objectAssign({}, split);
+        newSplit.killed = true;
+        newSplit.defaultTreatment = defaultTreatment;
+        newSplit.changeNumber = changeNumber;
 
-          return this.addSplit(name, newSplit);
-        }
+        return this.addSplit(name, newSplit);
       }
       return false;
     }).catch(() => false);