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

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 { 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 { 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 { UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { 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 membership update events to the corresponding MySegmentsUpdateWorker
+    // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_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 membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+    // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 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,76 +195,77 @@ export function pushManagerFactory(params, pollingManager) {
         }
         splitsUpdateWorker.put(parsedData);
     });
-    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_MEMBERSHIPS_UPDATE, ['BoundedFetchRequest', e]);
-                    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));
-                    }
-                });
-                return;
+    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);
             }
-            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;
+        });
+        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;
                 }
-                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]]
-                        });
+                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);
                     }
-                });
-                return;
-            }
-            case UpdateStrategy.SegmentRemoval:
-                if (!parsedData.n || !parsedData.n.length) {
-                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
-                    break;
+                    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;
                 }
-                forOwn(clients, function (_a) {
-                    var worker = _a.worker;
-                    worker.put(parsedData, {
-                        added: [],
-                        removed: parsedData.n
+                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) {
+                        var worker = _a.worker;
+                        return worker.put(parsedData.changeNumber, {
+                            name: parsedData.segmentName,
+                            add: false
+                        });
                     });
-                });
-                return;
-        }
-        // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-        forOwn(clients, function (_a, matchingKey) {
-            var worker = _a.worker;
-            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
+                    return;
+            }
+            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+            forOwn(clients, function (_a) {
+                var worker = _a.worker;
+                worker.put(parsedData.changeNumber);
+            });
         });
     }
-    if (userKey) {
-        pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
-        pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
-    }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
@@ -299,10 +300,7 @@ export function pushManagerFactory(params, pollingManager) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = {
-                    hash64: hash64(userKey),
-                    worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
-                };
+                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(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/sync/syncManagerOnline.js

@@ -115,32 +115,33 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                if (running) {
-                    if (syncEnabled) {
-                        if (pushManager) {
-                            if (pollingManager.isRunning()) {
-                                // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments())
-                                    mySegmentsSyncTask.start();
+                return {
+                    isRunning: mySegmentsSyncTask.isRunning,
+                    start: function () {
+                        if (syncEnabled) {
+                            if (pushManager) {
+                                if (pollingManager.isRunning()) {
+                                    // if doing polling, we must start the periodic fetch of data
+                                    if (storage.splits.usesSegments())
+                                        mySegmentsSyncTask.start();
+                                }
+                                else {
+                                    // if not polling, we must execute the sync task for the initial fetch
+                                    // of segments since `syncAll` was already executed when starting the main client
+                                    mySegmentsSyncTask.execute();
+                                }
+                                pushManager.add(matchingKey, mySegmentsSyncTask);
                             }
                             else {
-                                // if not polling, we must execute the sync task for the initial fetch
-                                // of segments since `syncAll` was already executed when starting the main client
-                                mySegmentsSyncTask.execute();
+                                if (storage.splits.usesSegments())
+                                    mySegmentsSyncTask.start();
                             }
-                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (storage.splits.usesSegments())
-                                mySegmentsSyncTask.start();
+                            if (!readinessManager.isReady())
+                                mySegmentsSyncTask.execute();
                         }
-                    }
-                    else {
-                        if (!readinessManager.isReady())
-                            mySegmentsSyncTask.execute();
-                    }
-                }
-                return {
+                    },
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
                         var mySegmentsSyncTask = pollingManager.get(matchingKey);

package/esm/sync/syncTask.js

@@ -66,8 +66,8 @@ export function syncTaskFactory(log, task, period, taskName) {
             }
         },
         stop: function () {
-            running = false;
-            if (timeoutID) {
+            if (running) {
+                running = false;
                 log.debug(SYNC_TASK_STOP, [taskName]);
                 clearTimeout(timeoutID);
                 timeoutID = undefined;

package/esm/trackers/eventTracker.js

@@ -9,7 +9,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -19,17 +19,15 @@ export function eventTrackerFactory(settings, eventsCache, whenInit, integration
         if (tracked) {
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                whenInit(function () {
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // copy of event, to avoid unexpected behaviour if modified by integrations
-                        var eventDataCopy = objectAssign({}, eventData);
-                        if (properties)
-                            eventDataCopy.properties = objectAssign({}, properties);
-                        // integrationsManager does not throw errors (they are internally handled by each integration module)
-                        integrationsManager.handleEvent(eventDataCopy);
-                    });
-                });
+                // Wrap in a timeout because we don't want it to be blocking.
+                setTimeout(function () {
+                    // copy of event, to avoid unexpected behaviour if modified by integrations
+                    var eventDataCopy = objectAssign({}, eventData);
+                    if (properties)
+                        eventDataCopy.properties = objectAssign({}, properties);
+                    // integrationsManager does not throw errors (they are internally handled by each integration module)
+                    integrationsManager.handleEvent(eventDataCopy);
+                }, 0);
             }
         }
         else {

package/esm/trackers/impressionsTracker.js

@@ -11,7 +11,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -50,21 +50,19 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    whenInit(function () {
-                        // Wrap in a timeout because we don't want it to be blocking.
-                        setTimeout(function () {
-                            // integrationsManager.handleImpression does not throw errors
-                            if (integrationsManager)
-                                integrationsManager.handleImpression(impressionData);
-                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (impressionListener)
-                                    impressionListener.logImpression(impressionData);
-                            }
-                            catch (err) {
-                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                            }
-                        });
-                    });
+                    // Wrap in a timeout because we don't want it to be blocking.
+                    setTimeout(function () {
+                        // integrationsManager.handleImpression does not throw errors
+                        if (integrationsManager)
+                            integrationsManager.handleImpression(impressionData);
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                            if (impressionListener)
+                                impressionListener.logImpression(impressionData);
+                        }
+                        catch (err) {
+                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+                        }
+                    }, 0);
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/esm/trackers/uniqueKeysTracker.js

@@ -16,6 +16,9 @@ var noopFilterAdapter = {
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -24,11 +27,6 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
-        start: function () {
-            if (filterAdapter.refreshRate) {
-                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-            }
-        },
         stop: function () {
             clearInterval(intervalId);
         }

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 MEMBERSHIPS = 'ms';
+export var MY_SEGMENT = 'ms';
 export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
@@ -86,7 +86,6 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAG_SPEC_VERSION = '1.2';
+export var FLAG_SPEC_VERSION = '1.1';
 // Matcher types
 export var IN_SEGMENT = 'IN_SEGMENT';
-export var IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/esm/utils/settingsValidation/index.js

@@ -183,10 +183,9 @@ 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 ? consent(withDefaults) : undefined;
+    withDefaults.userConsent = consent(withDefaults);
     return withDefaults;
 }

package/package.json

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

package/src/consent/sdkUserConsent.ts

@@ -15,7 +15,7 @@ const ConsentStatus = {
  * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
  */
 export function createUserConsentAPI(params: ISdkFactoryContext) {
-  const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts } } = params;
+  const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts, uniqueKeys } } = params;
 
   if (!isConsentGranted(settings)) log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
 
@@ -41,7 +41,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
           if (impressions.clear) impressions.clear(); // @ts-ignore
-          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear(); // @ts-ignore
+          if (uniqueKeys && uniqueKeys.clear) uniqueKeys.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

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.'],