@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

package/src/dtos/types.ts

@@ -30,10 +30,6 @@ export interface IInSegmentMatcherData {
   segmentName: string
 }
 
-export interface IInLargeSegmentMatcherData {
-  largeSegmentName: string
-}
-
 export interface IDependencyMatcherData {
   split: string,
   treatments: string[]
@@ -47,7 +43,6 @@ interface ISplitMatcherBase {
     attribute: string | null
   }
   userDefinedSegmentMatcherData?: null | IInSegmentMatcherData
-  userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData
   whitelistMatcherData?: null | IWhitelistMatcherData
   unaryNumericMatcherData?: null | IUnaryNumericMatcherData
   betweenMatcherData?: null | IBetweenMatcherData
@@ -66,11 +61,6 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
   userDefinedSegmentMatcherData: IInSegmentMatcherData
 }
 
-interface IInLargeSegmentMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_LARGE_SEGMENT',
-  userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData
-}
-
 interface IWhitelistMatcher extends ISplitMatcherBase {
   matcherType: 'WHITELIST',
   whitelistMatcherData: IWhitelistMatcherData
@@ -175,8 +165,7 @@ interface IInListSemverMatcher extends ISplitMatcherBase {
 export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
   IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
-  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher |
-  IInLargeSegmentMatcher
+  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher
 
 /** Split object */
 export interface ISplitPartition {
@@ -229,17 +218,14 @@ export interface ISegmentChangesResponse {
   till: number
 }
 
-export interface IMySegmentsResponse {
-  cn?: number,
-  k?: {
-    n: string
-  }[]
+export interface IMySegmentsResponseItem {
+  id: string,
+  name: string
 }
 
-/** Interface of the parsed JSON response of `/memberships/{userKey}` */
-export interface IMembershipsResponse {
-  ms?: IMySegmentsResponse,
-  ls?: IMySegmentsResponse
+/** Interface of the parsed JSON response of `/mySegments/{userKey}` */
+export interface IMySegmentsResponse {
+  mySegments: IMySegmentsResponseItem[]
 }
 
 /** Metadata internal type for storages */

package/src/evaluator/matchers/index.ts

@@ -1,6 +1,5 @@
 import { allMatcherContext } from './all';
 import { segmentMatcherContext } from './segment';
-import { largeSegmentMatcherContext } from './large_segment';
 import { whitelistMatcherContext } from './whitelist';
 import { equalToMatcherContext } from './eq';
 import { greaterThanEqualMatcherContext } from './gte';
@@ -49,7 +48,6 @@ const matchers = [
   lessThanEqualToSemverMatcherContext, // LESS_THAN_OR_EQUAL_TO_SEMVER: 20
   betweenSemverMatcherContext, // BETWEEN_SEMVER: 21
   inListSemverMatcherContext, // IN_LIST_SEMVER: 22
-  largeSegmentMatcherContext, // IN_LARGE_SEGMENT: 23
 ];
 
 /**

package/src/evaluator/matchers/matcherTypes.ts

@@ -22,7 +22,6 @@ export const matcherTypes: Record<string, number> = {
   LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
   BETWEEN_SEMVER: 21,
   IN_LIST_SEMVER: 22,
-  IN_LARGE_SEGMENT: 23,
 };
 
 export const matcherDataTypes = {

package/src/evaluator/matchers/segment.ts

@@ -1,18 +1,11 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { thenable } from '../../utils/promise/thenable';
 
 export function segmentMatcherContext(segmentName: string, storage: { segments: ISegmentsCacheBase }) {
 
   return function segmentMatcher(key: string): MaybeThenable<boolean> {
     const isInSegment = storage.segments.isInSegment(segmentName, key);
 
-    if (thenable(isInSegment)) {
-      isInSegment.then(result => {
-        return result;
-      });
-    }
-
     return isInSegment;
   };
 }

package/src/evaluator/matchersTransform/index.ts

@@ -4,7 +4,7 @@ import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
 import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
+import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
 /**
@@ -18,7 +18,6 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       negate,
       keySelector,
       userDefinedSegmentMatcherData,
-      userDefinedLargeSegmentMatcherData,
       whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */
       unaryNumericMatcherData,
       betweenMatcherData,
@@ -36,8 +35,6 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
 
     if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
-    } else if (type === matcherTypes.IN_LARGE_SEGMENT) {
-      value = segmentTransform(userDefinedLargeSegmentMatcherData as IInLargeSegmentMatcherData);
     } else if (type === matcherTypes.EQUAL_TO) {
       value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;

package/src/evaluator/matchersTransform/segment.ts

@@ -1,10 +1,8 @@
-import { IInSegmentMatcherData, IInLargeSegmentMatcherData } from '../../dtos/types';
+import { IInSegmentMatcherData } from '../../dtos/types';
 
 /**
  * Extract segment name as a plain string.
  */
-export function segmentTransform(segment?: IInSegmentMatcherData | IInLargeSegmentMatcherData) {
-  return segment ?
-    (segment as IInSegmentMatcherData).segmentName || (segment as IInLargeSegmentMatcherData).largeSegmentName :
-    undefined;
+export function segmentTransform(segment?: IInSegmentMatcherData) {
+  return segment ? segment.segmentName : undefined;
 }

package/src/logger/constants.ts

@@ -79,7 +79,7 @@ export const WARN_SPLITS_FILTER_IGNORED = 219;
 export const WARN_SPLITS_FILTER_INVALID = 220;
 export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
-export const STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
+export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export const WARN_INVALID_FLAGSET = 225;
 export const WARN_LOWERCASE_FLAGSET = 226;

package/src/logger/messages/info.ts

@@ -23,7 +23,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
+  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/src/logger/messages/warn.ts

@@ -32,7 +32,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
   [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
 
-  [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
+  [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
   [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
   [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
   [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],

package/src/readiness/readinessManager.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } from '../types';
 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';
 
@@ -10,7 +10,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+  // - `/mySegments` 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, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
@@ -33,11 +33,9 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISe
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  settings: ISettings,
+  readyTimeout = 0,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
-  const readyTimeout = settings.startup.readyTimeout;
-
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
@@ -55,15 +53,19 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
 
-  function timeout() { // eslint-disable-next-line no-use-before-define
-    if (hasTimedout || isReady) return;
+  function timeout() {
+    if (hasTimedout) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
+  let readyTimeoutId: ReturnType<typeof setTimeout>;
+  if (readyTimeout > 0) {
+    readyTimeoutId = setTimeout(timeout, readyTimeout);
+  }
+
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -116,9 +118,9 @@ export function readinessManagerFactory(
     segments,
     gate,
 
-    shared() {
+    shared(readyTimeout = 0) {
       refCount++;
-      return readinessManagerFactory(EventEmitter, settings, splits);
+      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -128,12 +130,6 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
-    init() {
-      if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
-      }
-    },
-
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/sdkReadinessManager.ts

@@ -2,8 +2,9 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } from '../types';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
+import { ILogger } from '../logger/types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';
@@ -17,11 +18,10 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
 export function sdkReadinessManagerFactory(
+  log: ILogger,
   EventEmitter: new () => IEventEmitter,
-  settings: ISettings,
-  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
-
-  const log = settings.log;
+  readyTimeout = 0,
+  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared() {
-      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
+    shared(readyTimeout = 0) {
+      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
     },
 
     incInternalReadyCbCount() {

package/src/readiness/types.ts

@@ -59,10 +59,9 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
-  init(): void,
 
   /** for client-side */
-  shared(): IReadinessManager,
+  shared(readyTimeout?: number): IReadinessManager,
 }
 
 /** SDK readiness manager */
@@ -78,5 +77,5 @@ export interface ISdkReadinessManager {
   incInternalReadyCbCount(): void
 
   /** for client-side */
-  shared(): ISdkReadinessManager
+  shared(readyTimeout?: number): ISdkReadinessManager
 }

package/src/sdkClient/sdkClient.ts

@@ -66,11 +66,11 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
         syncManager && syncManager.stop();
 
         return __flush().then(() => {
-          // For main client, cleanup event listeners and scheduled jobs
-          if (!isSharedClient) {
-            signalListener && signalListener.stop();
-            uniqueKeysTracker && uniqueKeysTracker.stop();
-          }
+          // Cleanup event listeners
+          signalListener && signalListener.stop();
+
+          // @TODO stop only if last client is destroyed
+          if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkClient/sdkClientMethod.ts

@@ -4,15 +4,12 @@ import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
- * Factory of client method for server-side SDKs
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
 export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);
 
-  // Only one client in server-side without bound key
-  params.clients[''] = clientInstance;
-
   return function client() {
     if (arguments.length > 0) {
       throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/src/sdkClient/sdkClientMethodCS.ts

@@ -8,14 +8,18 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { buildInstanceId } from './identity';
+
+function buildInstanceId(key: SplitIO.SplitKey) {
+  // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
+}
 
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log }, whenInit } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -27,7 +31,8 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  clients[defaultInstanceId] = mainClientInstance;
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  clientInstances[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey) {
     if (key === undefined) {
@@ -43,10 +48,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
     const instanceId = buildInstanceId(validKey);
 
-    if (!clients[instanceId]) {
+    if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();
@@ -65,26 +70,24 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clients[instanceId] = clientCSDecorator(
+      clientInstances[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
+          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey
       );
 
-      whenInit(() => {
-        sharedSdkReadiness.readinessManager.init();
-        sharedSyncManager && sharedSyncManager.start();
-      });
+      sharedSyncManager && sharedSyncManager.start();
 
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clients[instanceId] as SplitIO.ICsClient;
+    return clientInstances[instanceId];
   };
 }

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -9,7 +9,11 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { buildInstanceId } from './identity';
+
+function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
+  // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
+}
 
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
@@ -17,7 +21,7 @@ import { buildInstanceId } from './identity';
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log }, whenInit } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -30,7 +34,8 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  clients[defaultInstanceId] = mainClientInstance;
+  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  clientInstances[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey, trafficType?: string) {
     if (key === undefined) {
@@ -53,10 +58,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     }
     const instanceId = buildInstanceId(validKey, validTrafficType);
 
-    if (!clients[instanceId]) {
+    if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();
@@ -75,27 +80,25 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clients[instanceId] = clientCSDecorator(
+      clientInstances[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
+          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
       );
 
-      whenInit(() => {
-        sharedSdkReadiness.readinessManager.init();
-        sharedSyncManager && sharedSyncManager.start();
-      });
+      sharedSyncManager && sharedSyncManager.start();
 
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clients[instanceId] as SplitIO.ICsClient;
+    return clientInstances[instanceId];
   };
 }

package/src/sdkFactory/index.ts

@@ -3,11 +3,11 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IBasicClient, SplitIO } from '../types';
+import { SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -23,22 +23,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, isPure } = params;
+    filterAdapterFactory } = params;
   const { log, sync: { impressionsMode } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // initialization
-  let isInit = false;
-  const initCallbacks: (() => void)[] = [];
+  // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+  validateAndTrackApiKey(log, settings.core.authorizationKey);
 
-  function whenInit(cb: () => void) {
-    if (isInit) cb();
-    else initCallbacks.push(cb);
-  }
-
-  const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
+  const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
   const storage = storageFactory({
@@ -52,12 +46,9 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb: () => {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-    }
   });
+  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
@@ -76,13 +67,13 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, whenInit };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -94,24 +85,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-
-  function init() {
-    if (isInit) return;
-    isInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    storage.init && storage.init();
-    uniqueKeysTracker && uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
-  }
-
-  if (!isPure) init();
+  syncManager && syncManager.start();
+  signalListener && signalListener.start();
 
   log.info(NEW_FACTORY);
 
@@ -130,9 +105,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(log),
 
     settings,
-
-    destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
-    }
-  }, extraProps && extraProps(ctx), isPure && { init });
+  }, extraProps && extraProps(ctx));
 }

package/src/sdkFactory/types.ts

@@ -8,7 +8,7 @@ import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter, IBasicClient } from '../types';
+import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
@@ -49,8 +49,6 @@ export interface ISdkFactoryContext {
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
-  clients: Record<string, IBasicClient>,
-  whenInit(cb: () => void): void
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
@@ -69,8 +67,6 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
-  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
-  isPure?: boolean,
 
   // The settings must be already validated
   settings: ISettings,

package/src/services/decorateHeaders.ts

@@ -31,3 +31,8 @@ export function decorateHeaders(settings: ISettings, headers: Record<string, str
   }
   return headers;
 }
+
+export function removeNonISO88591(input: string) {
+  // eslint-disable-next-line no-control-regex
+  return input.replace(/[^\x00-\xFF]/g, '');
+}