@splitsoftware/splitio-commons 1.2.1-rc.8 → 1.3.1-rc.0

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,5 +1,4 @@
 import { clientCSDecorator } from './clientCS';
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
@@ -8,6 +7,7 @@ import { ISyncManagerCS } from '../sync/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 function buildInstanceId(key: SplitIO.SplitKey) {
   // @ts-ignore
@@ -20,18 +20,13 @@ 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: ISdkClientFactoryParams): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
-  // Keeping similar behaviour as in the isomorphic JS SDK: if settings key is invalid,
-  // `false` value is used as binded key of the default client, but trafficType is ignored
-  // @TODO handle as a non-recoverable error
-  const validKey = validateKey(log, key, method);
-
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
-    validKey
+    sdkClientFactory(params) as SplitIO.IClient,
+    key
   );
 
   const parsedDefaultKey = keyParser(key);
@@ -81,8 +76,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-          sharedClient: true
-        })) as SplitIO.IClient,
+        }), true) as SplitIO.IClient,
         validKey
       );
 

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -1,5 +1,4 @@
 import { clientCSDecorator } from './clientCS';
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
@@ -9,6 +8,7 @@ import { ISyncManagerCS } from '../sync/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
   // @ts-ignore
@@ -22,23 +22,14 @@ 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: ISdkClientFactoryParams): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
-  // Keeping the behaviour as in the isomorphic JS SDK: if settings key or TT are invalid,
-  // `false` value is used as binded key/TT of the default client, which leads to several issues.
-  // @TODO update when supporting non-recoverable errors
-  const validKey = validateKey(log, key, method);
-  let validTrafficType;
-  if (trafficType !== undefined) {
-    validTrafficType = validateTrafficType(log, trafficType, method);
-  }
-
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
-    validKey,
-    validTrafficType
+    sdkClientFactory(params) as SplitIO.IClient,
+    key,
+    trafficType
   );
 
   const parsedDefaultKey = keyParser(key);
@@ -95,8 +86,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-          sharedClient: true
-        })) as SplitIO.IClient,
+        }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
       );

package/src/sdkFactory/index.ts

@@ -81,7 +81,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
 
   // Sdk client and manager
-  const clientMethod = sdkClientMethodFactory({ eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener });
+  const ctx = { eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener };
+  const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
 
   syncManager && syncManager.start();
@@ -104,5 +105,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(settings.log),
 
     settings,
-  }, extraProps && extraProps(settings, syncManager));
+  }, extraProps && extraProps(ctx));
 }

package/src/sdkFactory/types.ts

@@ -2,13 +2,23 @@ import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISdkClientFactoryParams } from '../sdkClient/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
+import { IImpressionsTracker, IEventTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
+export interface ISdkFactoryContext {
+  storage: IStorageSync | IStorageAsync,
+  sdkReadinessManager: ISdkReadinessManager,
+  settings: ISettings
+  impressionsTracker: IImpressionsTracker,
+  eventTracker: IEventTracker,
+  signalListener?: ISignalListener
+  syncManager?: ISyncManager,
+}
+
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -53,7 +63,7 @@ export interface ISdkFactoryParams {
 
   // 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: ISdkClientFactoryParams) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  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.
@@ -70,5 +80,5 @@ export interface ISdkFactoryParams {
   impressionsObserverFactory?: () => IImpressionObserver
 
   // Optional function to assign additional properties to the factory instance
-  extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object
+  extraProps?: (params: ISdkFactoryContext) => object
 }

package/src/services/splitHttpClient.ts

@@ -14,24 +14,26 @@ const messageNoFetch = 'Global fetch API is not available.';
  */
 export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'version' | 'runtime' | 'core'>, getFetch?: () => (IFetch | undefined), getOptions?: () => object): ISplitHttpClient {
 
-  const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
+  const log = settings.log;
   const options = getOptions && getOptions();
   const fetch = getFetch && getFetch();
 
   // if fetch is not available, log Error
   if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
 
-  const headers: Record<string, string> = {
-    'Accept': 'application/json',
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${authorizationKey}`,
-    'SplitSDKVersion': version
-  };
+  return function httpClient(url: string, reqOpts: IRequestOptions = {}, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
+    const { core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
 
-  return function httpClient(url: string, reqOpts: IRequestOptions = {}, logErrorsAsInfo: boolean = false): Promise<IResponse> {
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${authorizationKey}`,
+      'SplitSDKVersion': version
+    };
+
+    if (ip) headers['SplitSDKMachineIP'] = ip;
+    if (hostname) headers['SplitSDKMachineName'] = hostname;
 
     const request = objectAssign({
       headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,

package/src/storages/inRedis/RedisAdapter.ts

@@ -164,6 +164,12 @@ export class RedisAdapter extends ioredis {
     } else { // If it IS the string URL, that'll be the first param for ioredis.
       result.unshift(options.url);
     }
+    if (options.connectionTimeout) {
+      merge(opts, { connectTimeout: options.connectionTimeout });
+    }
+    if (options.tls) {
+      merge(opts, { tls: options.tls });
+    }
 
     return result;
   }
@@ -171,9 +177,9 @@ export class RedisAdapter extends ioredis {
   /**
    * Parses the options into what we care about.
    */
-  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }: Record<string, any>) {
+  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>) {
     const parsedOptions = {
-      connectionTimeout, operationTimeout, url, host, port, db, pass
+      connectionTimeout, operationTimeout, url, host, port, db, pass, tls
     };
 
     return merge({}, DEFAULT_OPTIONS, parsedOptions);

package/src/sync/syncManagerOnline.ts

@@ -6,7 +6,7 @@ import { IPushManager } from './streaming/types';
 import { IPollingManager, IPollingManagerCS } from './polling/types';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
-import { isConsentGranted } from '../utils/consent';
+import { isConsentGranted } from '../consent';
 
 /**
  * Online SyncManager factory.

package/src/trackers/impressionsTracker.ts

@@ -28,7 +28,7 @@ export function impressionsTrackerFactory(
   countsCache?: IImpressionCountsCacheSync
 ): IImpressionsTracker {
 
-  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
+  const { log, impressionListener, runtime: { ip, hostname } } = settings;
 
   return {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
@@ -74,9 +74,9 @@ export function impressionsTrackerFactory(
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
             impression: objectAssign({}, impressions[i]),
             attributes,
-            ip: ip as string,
-            hostname: hostname as string,
-            sdkLanguageVersion: version
+            ip,
+            hostname,
+            sdkLanguageVersion: settings.version
           };
 
           // Wrap in a timeout because we don't want it to be blocking.

package/src/types.ts

@@ -398,7 +398,7 @@ interface IBasicClient extends IStatusInterface {
 
   // Whether the client implements the client-side API, i.e, with bound key, (true), or the server-side API (false).
   // Exposed for internal purposes only. Not considered part of the public API, and might be renamed eventually.
-  isBrowserClient: boolean
+  isClientSide: boolean
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -535,8 +535,8 @@ export namespace SplitIO {
   export type ImpressionData = {
     impression: ImpressionDTO,
     attributes?: SplitIO.Attributes,
-    ip: string,
-    hostname: string,
+    ip: string| false,
+    hostname: string | false,
     sdkLanguageVersion: string
   };
   /**

package/src/utils/inputValidation/attributes.ts

@@ -6,7 +6,7 @@ import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
   // Attributes are optional
-  if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+  if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
     return maybeAttrs;
 
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
@@ -23,5 +23,4 @@ export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<str
   });
 
   return result;
-
 }

package/src/utils/lang/index.ts

@@ -151,10 +151,14 @@ export function isNaNNumber(val: any): boolean {
 }
 
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
-export function isObject(obj: any): boolean {
-  return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+export function isObject(obj: any) {
+  return obj !== null && typeof obj === 'object' && (
+    obj.constructor === Object ||
+    (obj.constructor != null && obj.constructor.name === 'Object')
+  );
 }
 
 /**

package/src/utils/lang/maps.ts

@@ -79,4 +79,18 @@ interface IMapConstructor {
   readonly prototype: IMap<any, any>;
 }
 
-export const _Map: IMapConstructor = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor(): IMapConstructor {
+  // eslint-disable-next-line compat/compat
+  if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+    return Map;
+  }
+  return MapPoly;
+}
+
+export const _Map = __getMapConstructor();

package/src/utils/settingsValidation/index.ts

@@ -5,6 +5,8 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
+import { validateKey } from '../inputValidation/key';
+import { validateTrafficType } from '../inputValidation/trafficType';
 
 const base = {
   // Define which kind of object you want to retrieve from SplitFactory
@@ -129,9 +131,25 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (storage) withDefaults.storage = storage(withDefaults);
 
-  // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-  if (withDefaults.mode === LOCALHOST_MODE && withDefaults.core.key === undefined) {
-    withDefaults.core.key = 'localhost_key';
+  // Validate key and TT (for client-side)
+  if (validationParams.acceptKey) {
+    const maybeKey = withDefaults.core.key;
+    // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
+    if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
+      withDefaults.core.key = 'localhost_key';
+    } else {
+      // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+      // `false` value is used as binded key/TT of the default client, which leads to some issues.
+      // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+      withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+    }
+
+    if (validationParams.acceptTT) {
+      const maybeTT = withDefaults.core.trafficType;
+      if (maybeTT !== undefined) { // @ts-ignore
+        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+      }
+    }
   }
 
   // Current ip/hostname information

package/src/utils/settingsValidation/types.ts

@@ -10,7 +10,11 @@ export interface ISettingsValidationParams {
    * Version and startup properties are required, because they are not defined in the base settings.
    */
   defaults: Partial<ISettings> & { version: string } & { startup: ISettings['startup'] },
-  /** Function to define runtime values (`settings.runtime`) */
+  /** If true, validates core.key */
+  acceptKey?: boolean,
+  /** If true, validates core.trafficType */
+  acceptTT?: boolean,
+  /** Define runtime values (`settings.runtime`) */
   runtime: (settings: ISettings) => ISettings['runtime'],
   /** Storage validator (`settings.storage`) */
   storage?: (settings: ISettings) => ISettings['storage'],

package/types/consent/index.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function isConsentGranted(settings: ISettings): boolean;

package/types/consent/sdkUserConsent.d.ts

@@ -0,0 +1,13 @@
+import { ISdkFactoryContext } from '../sdkFactory/types';
+/**
+ * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
+ */
+export declare function createUserConsentAPI(params: ISdkFactoryContext): {
+    setStatus(consent: unknown): boolean;
+    getStatus(): import("../types").ConsentStatus | undefined;
+    Status: {
+        GRANTED: string;
+        DECLINED: string;
+        UNKNOWN: string;
+    };
+};

package/types/evaluator/types.d.ts

@@ -5,7 +5,7 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export interface IDependencyMatcherValue {
     key: SplitIO.SplitKey;
-    attributes: SplitIO.Attributes;
+    attributes?: SplitIO.Attributes;
 }
 export interface IMatcherDto {
     type: number;
@@ -23,6 +23,6 @@ export interface IEvaluation {
 export declare type IEvaluationResult = IEvaluation & {
     treatment: string;
 };
-export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
+export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
 export declare type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
 export declare type IMatcher = (...args: any) => MaybeThenable<boolean>;

package/types/evaluator/value/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;

package/types/logger/constants.d.ts

@@ -69,6 +69,7 @@ export declare const EVENTS_TRACKER_SUCCESS = 120;
 export declare const IMPRESSIONS_TRACKER_SUCCESS = 121;
 export declare const USER_CONSENT_UPDATED = 122;
 export declare const USER_CONSENT_NOT_UPDATED = 123;
+export declare const USER_CONSENT_INITIAL = 124;
 export declare const ENGINE_VALUE_INVALID = 200;
 export declare const ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export declare const CLIENT_NO_LISTENER = 202;

package/types/sdkClient/client.d.ts

@@ -1,6 +1,6 @@
-import { IClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-export declare function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClient.d.ts

@@ -1,6 +1,6 @@
 import { SplitIO } from '../types';
-import { ISdkClientFactoryParams } from './types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export declare function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethod.d.ts

@@ -1,6 +1,6 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export declare function sdkClientMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IClient | SplitIO.IAsyncClient;
+export declare function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient;

package/types/sdkClient/sdkClientMethodCS.d.ts

@@ -1,7 +1,7 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * 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 declare function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey) => SplitIO.ICsClient;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient;

package/types/sdkClient/sdkClientMethodCSWithTT.d.ts

@@ -1,8 +1,8 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * 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 declare function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient;
+export declare function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient;

package/types/sdkFactory/types.d.ts

@@ -2,12 +2,21 @@ import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISdkClientFactoryParams } from '../sdkClient/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
+import { IImpressionsTracker, IEventTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
+export interface ISdkFactoryContext {
+    storage: IStorageSync | IStorageAsync;
+    sdkReadinessManager: ISdkReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+    signalListener?: ISignalListener;
+    syncManager?: ISyncManager;
+}
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -28,7 +37,7 @@ export interface ISdkFactoryParams {
     splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;
     syncManagerFactory?: (params: ISyncManagerFactoryParams) => ISyncManager;
     sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
-    sdkClientMethodFactory: (params: ISdkClientFactoryParams) => ({
+    sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
@@ -38,5 +47,5 @@ export interface ISdkFactoryParams {
     serviceApi: ISplitApi | undefined) => ISignalListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
     impressionsObserverFactory?: () => IImpressionObserver;
-    extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object;
+    extraProps?: (params: ISdkFactoryContext) => object;
 }

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
 import { TelemetryCacheSync } from '../types';
 export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     private timeUntilReady?;
@@ -17,16 +17,14 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): Record<OperationType, number | undefined>;
+    getLastSynchronization(): LastSync;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): Record<OperationType, {
-        [statusCode: string]: number;
-    }>;
-    recordSyncError(resource: OperationType, status: number): void;
+    popHttpErrors(): HttpErrors;
+    recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): Record<OperationType, number[]>;
-    recordSyncLatency(resource: OperationType, latencyMs: number): void;
+    popHttpLatencies(): HttpLatencies;
+    recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
     recordAuthRejections(): void;
@@ -43,9 +41,9 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): Record<Method, number>;
+    popExceptions(): MethodExceptions;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): Record<Method, number[]>;
+    popLatencies(): MethodLatencies;
     recordLatency(method: Method, latencyMs: number): void;
 }

package/types/storages/inRedis/RedisAdapter.d.ts

@@ -20,5 +20,5 @@ export declare class RedisAdapter extends ioredis {
     /**
      * Parses the options into what we care about.
      */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }: Record<string, any>): object;
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -0,0 +1,21 @@
+import { ILogger } from '../../logger/types';
+import { Method, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { TelemetryCacheAsync } from '../types';
+import { Redis } from 'ioredis';
+export declare class TelemetryCacheInRedis implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly redis;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param redis  Redis client.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    recordLatency(method: Method, latencyMs: number): Promise<number>;
+    recordException(method: Method): Promise<number>;
+    popExceptions(): Promise<MethodExceptions>;
+    popLatencies(): Promise<MethodLatencies>;
+}

package/types/storages/pluggable/TelemetryCachePluggable.d.ts

@@ -1,2 +1,20 @@
-export declare class TelemetryCachePluggable {
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, TelemetryCacheAsync } from '../types';
+export declare class TelemetryCachePluggable implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly wrapper;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
+    recordLatency(method: Method, latencyMs: number): Promise<number>;
+    recordException(method: Method): Promise<number>;
+    popExceptions(): void;
+    popLatencies(): void;
 }