@splitsoftware/splitio-commons 1.16.1-rc.10 → 1.16.1-rc.11

package/esm/services/splitApi.js

@@ -1,6 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
@@ -59,7 +59,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
             var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey);
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
         },
         /**
          * Post events.

package/esm/storages/AbstractSegmentsCacheSync.js

@@ -6,20 +6,54 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
     function AbstractSegmentsCacheSync() {
     }
     /**
-     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
-     * For client-side synchronizer: the method is not used.
+     * clear the cache.
      */
-    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    AbstractSegmentsCacheSync.prototype.clear = function () {
+        this.resetSegments({});
+    };
     /**
-     * For server-side synchronizer: set the change number of `name` segment.
+     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
      * For client-side synchronizer: the method is not used.
      */
-    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
+    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: reset the cache with the given list of segments.
+     * For client-side synchronizer: it resets or updates the cache.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (names, changeNumber) { return true; };
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
+        var _this = this;
+        this.setChangeNumber(undefined, segmentsData.cn);
+        var _a = segmentsData, added = _a.added, removed = _a.removed;
+        if (added && removed) {
+            var isDiff_1 = false;
+            added.forEach(function (segment) {
+                isDiff_1 = _this.addToSegment(segment) || isDiff_1;
+            });
+            removed.forEach(function (segment) {
+                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
+            });
+            return isDiff_1;
+        }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeFromSegment(storedSegmentKeys[removeIndex]);
+        }
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addToSegment(names[addIndex]);
+        }
+        return true;
+    };
     return AbstractSegmentsCacheSync;
 }());
 export { AbstractSegmentsCacheSync };

package/esm/storages/dataLoader.js

@@ -42,6 +42,6 @@ export function dataLoaderFactory(preloadedData) {
                 return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
-        storage.segments.resetSegments(mySegmentsData);
+        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
     };
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -11,19 +11,11 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
-    /**
-     * Removes list of segments from localStorage
-     * @NOTE this method is not being used at the moment.
-     */
-    MySegmentsCacheInLocal.prototype.clear = function () {
-        this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
-        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-        // We could optimize next sentence, since it implies iterating over all localStorage items
-        this.resetSegments([]);
-    };
     MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) === DEFINED)
+                return false;
             localStorage.setItem(segmentKey, DEFINED);
             return true;
         }
@@ -35,6 +27,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) !== DEFINED)
+                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -46,41 +40,22 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
-    /**
-     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-     *
-     * @param {string[]} names list of segment names
-     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-     */
-    MySegmentsCacheInLocal.prototype.resetSegments = function (names, changeNumber) {
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var _this = this;
-        try {
-            if (changeNumber) {
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            }
-            else {
-                localStorage.removeItem(this.keys.buildTillKey());
-            }
-        }
-        catch (e) {
-            this.log.error(e);
-        }
-        var isDiff = false;
-        var index;
         // Scan current values from localStorage
-        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
+        return Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName) {
                 accum.push(segmentName);
             }
             else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+                        if (!localStorage.getItem(newSegmentKey)) {
                             localStorage.setItem(newSegmentKey, DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -94,40 +69,21 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-        // Extreme fast => everything is empty
-        if (names.length === 0 && storedSegmentNames.length === names.length)
-            return isDiff;
-        // Quick path
-        if (storedSegmentNames.length !== names.length) {
-            isDiff = true;
-            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
-            names.forEach(function (name) { return _this.addToSegment(name); });
-        }
-        else {
-            // Slowest path => we need to find at least 1 difference because
-            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
-                // TODO: why empty statement?
-            }
-            if (index < names.length) {
-                isDiff = true;
-                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
-                names.forEach(function (name) { return _this.addToSegment(name); });
-            }
-        }
-        return isDiff;
-    };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var _this = this;
-        return Object.keys(localStorage).reduce(function (accum, key) {
-            var segmentName = _this.keys.extractSegmentName(key);
-            if (segmentName)
-                accum.push(segmentName);
-            return accum;
-        }, []);
     };
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
     };
+    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
+        try {
+            if (changeNumber)
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+            else
+                localStorage.removeItem(this.keys.buildTillKey());
+        }
+        catch (e) {
+            this.log.error(e);
+        }
+    };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
         var value = localStorage.getItem(this.keys.buildTillKey());

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -11,58 +11,23 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.clear = function () {
-        this.segmentCache = {};
-    };
     MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
+        if (this.segmentCache[name])
+            return false;
         this.segmentCache[name] = true;
         return true;
     };
     MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
+        if (!this.segmentCache[name])
+            return false;
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    /**
-     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-     * @NOTE based on the way we use segments in the browser, this way is the best option
-     *
-     * @param {string[]} names list of segment names
-     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-     */
-    MySegmentsCacheInMemory.prototype.resetSegments = function (names, changeNumber) {
-        var _this = this;
+    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
         this.cn = changeNumber;
-        var isDiff = false;
-        var index;
-        var storedSegmentKeys = Object.keys(this.segmentCache);
-        // Extreme fast => everything is empty
-        if (names.length === 0 && storedSegmentKeys.length === names.length)
-            return isDiff;
-        // Quick path
-        if (storedSegmentKeys.length !== names.length) {
-            isDiff = true;
-            this.segmentCache = {};
-            names.forEach(function (s) {
-                _this.addToSegment(s);
-            });
-        }
-        else {
-            // Slowest path => we need to find at least 1 difference because
-            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
-                // TODO: why empty statement?
-            }
-            if (index < names.length) {
-                isDiff = true;
-                this.segmentCache = {};
-                names.forEach(function (s) {
-                    _this.addToSegment(s);
-                });
-            }
-        }
-        return isDiff;
     };
     MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
         return this.cn || -1;

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -1,6 +1,7 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { MEMBERSHIP_LS_UPDATE } from '../../streaming/constants';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -19,26 +20,15 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
     }
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
-        var _a, _b, _c, _d;
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Add/Delete the segment names
-            segmentsData.forEach(function (_a) {
-                var isLS = _a.isLS, name = _a.name, add = _a.add;
-                var cache = isLS ? largeSegments : segments;
-                if (cache.isInSegment(name) !== add) {
-                    shouldNotifyUpdate = true;
-                    if (add)
-                        cache.addToSegment(name);
-                    else
-                        cache.removeFromSegment(name);
-                }
-            });
+        if (segmentsData.type !== undefined) {
+            shouldNotifyUpdate = segmentsData.type === MEMBERSHIP_LS_UPDATE ?
+                largeSegments.resetSegments(segmentsData) :
+                segments.resetSegments(segmentsData);
         }
         else {
-            // Reset the list of segment names
-            shouldNotifyUpdate = segments.resetSegments((((_a = segmentsData.ms) === null || _a === void 0 ? void 0 : _a.k) || []).map(function (segment) { return segment.n; }), (_b = segmentsData.ms) === null || _b === void 0 ? void 0 : _b.cn);
-            shouldNotifyUpdate = largeSegments.resetSegments((((_c = segmentsData.ls) === null || _c === void 0 ? void 0 : _c.k) || []).map(function (segment) { return segment.n; }), (_d = segmentsData.ls) === null || _d === void 0 ? void 0 : _d.cn) || shouldNotifyUpdate;
+            shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
+            shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
         if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {

package/esm/sync/streaming/AuthClient/index.js

@@ -10,7 +10,7 @@ import { hash } from '../../../utils/murmur3/murmur3';
 export function authenticateFactory(fetchAuth) {
     /**
      * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-     * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+     * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
      */
     return function authenticate(userKeys) {
         return fetchAuth(userKeys)

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE_V3, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -66,18 +66,16 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(STREAMING_NEW_MESSAGE, [data]);
             // we only handle update events if streaming is up
-            // @ts-expect-error
-            var type = parsedData.type || parsedData.t;
-            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1)
+            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
                 return;
-            switch (type) {
+            switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
                 case SEGMENT_UPDATE:
-                case MY_SEGMENTS_UPDATE_V3:
-                case MY_LARGE_SEGMENTS_UPDATE:
+                case MEMBERSHIP_MS_UPDATE:
+                case MEMBERSHIP_LS_UPDATE:
                 case SPLIT_KILL:
-                    pushEmitter.emit(type, parsedData);
+                    pushEmitter.emit(parsedData.type, parsedData);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -1,8 +1,9 @@
 import { Backoff } from '../../../utils/Backoff';
+import { MEMBERSHIPS } from '../../../utils/constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType) {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
     var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     var currentChangeNumber = -1;
     var handleNewEvent = false;
@@ -30,7 +31,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
                     return; // halt if `stop` has been called
                 if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
                     if (_segmentsData)
-                        telemetryTracker.trackUpdatesFromSSE(updateType);
+                        telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
                 }
                 if (handleNewEvent) {
@@ -53,13 +54,14 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
          * @param segmentsData data for KeyList or SegmentRemoval instant updates
          * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
          */
-        put: function (changeNumber, segmentsData, delay) {
+        put: function (mySegmentsData, payload, delay) {
+            var type = mySegmentsData.type, cn = mySegmentsData.cn;
             // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay)
+            if (cn <= currentChangeNumber || cn <= maxChangeNumber || _delay)
                 return;
-            maxChangeNumber = changeNumber;
+            maxChangeNumber = cn;
             handleNewEvent = true;
-            _segmentsData = segmentsData;
+            _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
             _delay = delay;
             if (backoff.timeoutID || !isHandlingEvent)
                 __handleMySegmentsUpdateCall();

package/esm/sync/streaming/constants.js

@@ -22,11 +22,11 @@ export var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
-export var MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
+export var MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
+export var MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';
-export var MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 export var CONTROL = 'CONTROL';
 export var OCCUPANCY = 'OCCUPANCY';

package/esm/sync/streaming/pushManager.js

@@ -8,13 +8,13 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE_V3, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { MEMBERSHIP_MS_UPDATE, MEMBERSHIP_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_MEMBERSHIP_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 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, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -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 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;
@@ -197,7 +197,7 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.put(parsedData);
     });
     function handleMySegmentsUpdate(parsedData) {
-        var isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
+        var isLS = parsedData.type === MEMBERSHIP_LS_UPDATE;
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
                 var bitmap_1;
@@ -205,13 +205,13 @@ export function pushManagerFactory(params, pollingManager) {
                     bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['BoundedFetchRequest', e]);
+                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['BoundedFetchRequest', e]);
                     break;
                 }
                 forOwn(clients, function (_a, matchingKey) {
                     var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
                     if (isInBitmap(bitmap_1, hash64.hex)) {
-                        (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+                        (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
                     }
                 });
                 return;
@@ -224,51 +224,48 @@ export function pushManagerFactory(params, pollingManager) {
                     removed_1 = new _Set(keyList.r);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', e]);
                     break;
                 }
                 if (!parsedData.n || !parsedData.n.length) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', 'No segment name was provided']);
+                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
                     var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
-                        (isLS ? workerLarge : worker).put(parsedData.cn, [{
-                                isLS: isLS,
-                                name: parsedData.n[0],
-                                add: add,
-                            }]);
+                        (isLS ? workerLarge : worker).put(parsedData, {
+                            added: add ? [parsedData.n[0]] : [],
+                            removed: add ? [] : [parsedData.n[0]]
+                        });
                     }
                 });
                 return;
             }
             case UpdateStrategy.SegmentRemoval:
                 if (!parsedData.n || !parsedData.n.length) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
-                    (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n.map(function (largeSegment) { return ({
-                        isLS: isLS,
-                        name: largeSegment,
-                        add: false,
-                        cn: parsedData.cn
-                    }); }));
+                    (isLS ? workerLarge : worker).put(parsedData, {
+                        added: [],
+                        removed: parsedData.n
+                    });
                 });
                 return;
         }
         // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
         forOwn(clients, function (_a, matchingKey) {
             var worker = _a.worker, workerLarge = _a.workerLarge;
-            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+            (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
         });
     }
     if (userKey) {
-        pushEmitter.on(MY_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
-        pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIP_MS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIP_LS_UPDATE, handleMySegmentsUpdate);
     }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
@@ -306,8 +303,8 @@ export function pushManagerFactory(params, pollingManager) {
                 userKeyHashes[hash] = userKey;
                 clients[userKey] = {
                     hash64: hash64(userKey),
-                    worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
-                    workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT)
+                    worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker),
+                    workerLarge: 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.

package/esm/utils/constants/index.js

@@ -60,8 +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 MY_LARGE_SEGMENT = 'mls';
+export var MEMBERSHIPS = 'ms';
 export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';

package/package.json

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

package/src/dtos/types.ts

@@ -224,20 +224,17 @@ export interface ISegmentChangesResponse {
   till: number
 }
 
+export interface IMySegmentsResponse {
+  cn?: number,
+  k?: {
+    n: string
+  }[]
+}
+
 /** Interface of the parsed JSON response of `/memberships/{userKey}` */
 export interface IMembershipsResponse {
-  ms?: {
-    cn?: number,
-    k?: Array<{
-      n: string
-    }>
-  },
-  ls?: {
-    cn?: number,
-    k?: Array<{
-      n: string
-    }>
-  }
+  ms?: IMySegmentsResponse,
+  ls?: IMySegmentsResponse
 }
 
 /** Metadata internal type for storages */

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 = 223;
+export const STREAMING_PARSING_MEMBERSHIP_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/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, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
+  [c.STREAMING_PARSING_MEMBERSHIP_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/services/splitApi.ts

@@ -4,7 +4,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -75,7 +75,7 @@ export function splitApiFactory(
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
       const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
     },
 
     /**