@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.1

package/esm/sync/streaming/pushManager.js

@@ -8,10 +8,10 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -45,10 +45,10 @@ export function pushManagerFactory(params, pollingManager) {
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
-    // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
+    // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
-    // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+    // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
@@ -195,77 +195,76 @@ export function pushManagerFactory(params, pollingManager) {
         }
         splitsUpdateWorker.put(parsedData);
     });
-    if (userKey) {
-        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-            var userKeyHash = channel.split('_')[2];
-            var userKey = userKeyHashes[userKeyHash];
-            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-            }
-        });
-        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-            switch (parsedData.u) {
-                case UpdateStrategy.BoundedFetchRequest: {
-                    var bitmap_1;
-                    try {
-                        bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
-                        break;
-                    }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        if (isInBitmap(bitmap_1, hash64.hex)) {
-                            worker.put(parsedData.changeNumber); // fetch mySegments
-                        }
-                    });
-                    return;
+    function handleMySegmentsUpdate(parsedData) {
+        switch (parsedData.u) {
+            case UpdateStrategy.BoundedFetchRequest: {
+                var bitmap_1;
+                try {
+                    bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
-                case UpdateStrategy.KeyList: {
-                    var keyList = void 0, added_1, removed_1;
-                    try {
-                        keyList = parseKeyList(parsedData.d, parsedData.c);
-                        added_1 = new _Set(keyList.a);
-                        removed_1 = new _Set(keyList.r);
-                    }
-                    catch (e) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
-                        break;
-                    }
-                    forOwn(clients, function (_a) {
-                        var hash64 = _a.hash64, worker = _a.worker;
-                        var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
-                        if (add !== undefined) {
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
-                        }
-                    });
-                    return;
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['BoundedFetchRequest', e]);
+                    break;
                 }
-                case UpdateStrategy.SegmentRemoval:
-                    if (!parsedData.segmentName) {
-                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
-                        break;
+                forOwn(clients, function (_a, matchingKey) {
+                    var hash64 = _a.hash64, worker = _a.worker;
+                    if (isInBitmap(bitmap_1, hash64.hex)) {
+                        worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
                     }
-                    forOwn(clients, function (_a) {
-                        var worker = _a.worker;
-                        return worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
-                            add: false
+                });
+                return;
+            }
+            case UpdateStrategy.KeyList: {
+                var keyList = void 0, added_1, removed_1;
+                try {
+                    keyList = parseKeyList(parsedData.d, parsedData.c);
+                    added_1 = new _Set(keyList.a);
+                    removed_1 = new _Set(keyList.r);
+                }
+                catch (e) {
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);
+                    break;
+                }
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var hash64 = _a.hash64, worker = _a.worker;
+                    var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
+                    if (add !== undefined) {
+                        worker.put(parsedData, {
+                            added: add ? [parsedData.n[0]] : [],
+                            removed: add ? [] : [parsedData.n[0]]
                         });
-                    });
-                    return;
+                    }
+                });
+                return;
             }
-            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-            forOwn(clients, function (_a) {
-                var worker = _a.worker;
-                worker.put(parsedData.changeNumber);
-            });
+            case UpdateStrategy.SegmentRemoval:
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+                    break;
+                }
+                forOwn(clients, function (_a) {
+                    var worker = _a.worker;
+                    worker.put(parsedData, {
+                        added: [],
+                        removed: parsedData.n
+                    });
+                });
+                return;
+        }
+        // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+        forOwn(clients, function (_a, matchingKey) {
+            var worker = _a.worker;
+            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
         });
     }
+    if (userKey) {
+        pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
+    }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
@@ -300,7 +299,10 @@ export function pushManagerFactory(params, pollingManager) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
+                clients[userKey] = {
+                    hash64: hash64(userKey),
+                    worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
+                };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/esm/utils/constants/index.js

@@ -60,7 +60,7 @@ export var EVENTS = 'ev';
 export var TELEMETRY = 'te';
 export var TOKEN = 'to';
 export var SEGMENT = 'se';
-export var MY_SEGMENT = 'ms';
+export var MEMBERSHIPS = 'ms';
 export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
@@ -86,6 +86,7 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAG_SPEC_VERSION = '1.1';
+export var FLAG_SPEC_VERSION = '1.2';
 // Matcher types
 export var IN_SEGMENT = 'IN_SEGMENT';
+export var IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/esm/utils/settingsValidation/index.js

@@ -183,9 +183,10 @@ export function settingsValidation(config, validationParams) {
     var splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
     sync.splitFilters = splitFiltersValidation.validFilters;
     sync.__splitFiltersValidation = splitFiltersValidation;
+    // ensure a valid flag spec version
     sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
-    withDefaults.userConsent = consent(withDefaults);
+    withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
     return withDefaults;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.17.0",
+  "version": "1.17.1-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

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

package/src/evaluator/matchers/index.ts

@@ -1,5 +1,6 @@
 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';
@@ -48,6 +49,7 @@ 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/large_segment.ts

@@ -0,0 +1,18 @@
+import { MaybeThenable } from '../../dtos/types';
+import { ISegmentsCacheBase } from '../../storages/types';
+import { thenable } from '../../utils/promise/thenable';
+
+export function largeSegmentMatcherContext(largeSegmentName: string, storage: { largeSegments?: ISegmentsCacheBase }) {
+
+  return function largeSegmentMatcher(key: string): MaybeThenable<boolean> {
+    const isInLargeSegment = storage.largeSegments ? storage.largeSegments.isInSegment(largeSegmentName, key) : false;
+
+    if (thenable(isInLargeSegment)) {
+      isInLargeSegment.then(result => {
+        return result;
+      });
+    }
+
+    return isInLargeSegment;
+  };
+}

package/src/evaluator/matchers/matcherTypes.ts

@@ -22,6 +22,7 @@ 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/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, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
+import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
 /**
@@ -18,6 +18,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       negate,
       keySelector,
       userDefinedSegmentMatcherData,
+      userDefinedLargeSegmentMatcherData,
       whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */
       unaryNumericMatcherData,
       betweenMatcherData,
@@ -35,6 +36,8 @@ 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,8 +1,10 @@
-import { IInSegmentMatcherData } from '../../dtos/types';
+import { IInSegmentMatcherData, IInLargeSegmentMatcherData } from '../../dtos/types';
 
 /**
  * Extract segment name as a plain string.
  */
-export function segmentTransform(segment?: IInSegmentMatcherData) {
-  return segment ? segment.segmentName : undefined;
+export function segmentTransform(segment?: IInSegmentMatcherData | IInLargeSegmentMatcherData) {
+  return segment ?
+    (segment as IInSegmentMatcherData).segmentName || (segment as IInLargeSegmentMatcherData).largeSegmentName :
+    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_MY_SEGMENTS_UPDATE_V2 = 223;
+export const STREAMING_PARSING_MEMBERSHIPS_UPDATE = 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 reseting timer.'],
+  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting 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_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
+  [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships 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 } from '../types';
+import { IEventEmitter, ISettings } 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:
-  // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
   splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
@@ -33,9 +33,11 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISe
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  readyTimeout = 0,
+  settings: ISettings,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
+  const readyTimeout = settings.startup.readyTimeout;
+
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
@@ -118,9 +120,9 @@ export function readinessManagerFactory(
     segments,
     gate,
 
-    shared(readyTimeout = 0) {
+    shared() {
       refCount++;
-      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
+      return readinessManagerFactory(EventEmitter, settings, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked

package/src/readiness/sdkReadinessManager.ts

@@ -2,9 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } 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';
@@ -18,10 +17,11 @@ 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,
-  readyTimeout = 0,
-  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
+  settings: ISettings,
+  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
+
+  const log = settings.log;
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared(readyTimeout = 0) {
-      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+    shared() {
+      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
     },
 
     incInternalReadyCbCount() {

package/src/readiness/types.ts

@@ -61,7 +61,7 @@ export interface IReadinessManager {
   destroy(): void,
 
   /** for client-side */
-  shared(readyTimeout?: number): IReadinessManager,
+  shared(): IReadinessManager,
 }
 
 /** SDK readiness manager */
@@ -77,5 +77,5 @@ export interface ISdkReadinessManager {
   incInternalReadyCbCount(): void
 
   /** for client-side */
-  shared(readyTimeout?: number): ISdkReadinessManager
+  shared(): ISdkReadinessManager
 }

package/src/sdkClient/identity.ts

@@ -0,0 +1,5 @@
+import { SplitIO } from '../types';
+
+export function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) { // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType ? trafficType : ''}`;
+}

package/src/sdkClient/sdkClient.ts

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

package/src/sdkClient/sdkClientMethod.ts

@@ -4,12 +4,15 @@ import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
- * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ * Factory of client method for server-side SDKs
  */
 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,18 +8,14 @@ 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';
-
-function buildInstanceId(key: SplitIO.SplitKey) {
-  // @ts-ignore
-  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
-}
+import { buildInstanceId } from './identity';
 
 /**
  * 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 { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -31,8 +27,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
-  clientInstances[defaultInstanceId] = mainClientInstance;
+  clients[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey) {
     if (key === undefined) {
@@ -48,10 +43,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
     const instanceId = buildInstanceId(validKey);
 
-    if (!clientInstances[instanceId]) {
+    if (!clients[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
+      const sharedSdkReadiness = sdkReadinessManager.shared();
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();
@@ -70,13 +65,12 @@ 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.
-      clientInstances[instanceId] = clientCSDecorator(
+      clients[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
       );
@@ -88,6 +82,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clientInstances[instanceId];
+    return clients[instanceId] as SplitIO.ICsClient;
   };
 }