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

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

@@ -1,75 +1,118 @@
 import { Backoff } from '../../../utils/Backoff';
+import { MEMBERSHIPS } from '../../../utils/constants';
+import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType) {
-    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-    var currentChangeNumber = -1;
-    var handleNewEvent = false;
-    var isHandlingEvent;
-    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    var _delay;
-    var _delayTimeoutID;
-    var backoff = new Backoff(__handleMySegmentsUpdateCall);
-    function __handleMySegmentsUpdateCall() {
-        isHandlingEvent = true;
-        if (maxChangeNumber > currentChangeNumber) {
-            handleNewEvent = false;
-            var currentMaxChangeNumber_1 = maxChangeNumber;
-            // fetch mySegments revalidating data if cached
-            var syncTask = _delay ?
-                new Promise(function (res) {
-                    _delayTimeoutID = setTimeout(function () {
-                        _delay = undefined;
-                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
-                    }, _delay);
-                }) :
-                mySegmentsSyncTask.execute(_segmentsData, true);
-            syncTask.then(function (result) {
-                if (!isHandlingEvent)
-                    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);
-                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-                }
-                if (handleNewEvent) {
-                    __handleMySegmentsUpdateCall();
-                }
-                else {
-                    backoff.scheduleCall();
-                }
-            });
-        }
-        else {
-            isHandlingEvent = false;
+export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker) {
+    var _a;
+    function createUpdateWorker(mySegmentsCache) {
+        var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+        var currentChangeNumber = -1;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+        var _delay;
+        var _delayTimeoutID;
+        var backoff = new Backoff(__handleMySegmentsUpdateCall);
+        function __handleMySegmentsUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
+                handleNewEvent = false;
+                var currentMaxChangeNumber_1 = maxChangeNumber;
+                // fetch mySegments revalidating data if cached
+                var syncTask = _delay ?
+                    new Promise(function (res) {
+                        _delayTimeoutID = setTimeout(function () {
+                            _delay = undefined;
+                            mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
+                        }, _delay);
+                    }) :
+                    mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
+                syncTask.then(function (result) {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
+                        var storageChangeNumber = mySegmentsCache.getChangeNumber();
+                        currentChangeNumber = storageChangeNumber > -1 ?
+                            storageChangeNumber :
+                            Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                    }
+                    if (handleNewEvent) {
+                        __handleMySegmentsUpdateCall();
+                    }
+                    else {
+                        if (_segmentsData)
+                            telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
+                        var attempts = backoff.attempts + 1;
+                        if (maxChangeNumber <= currentChangeNumber) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleMySegmentsUpdateCall();
+                        }
+                    }
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
         }
+        return {
+            /**
+             * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+             *
+             * @param changeNumber change number of the notification
+             * @param segmentsData data for KeyList or SegmentRemoval instant updates
+             * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
+             */
+            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 (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber || _delay)
+                    return;
+                maxChangeNumber = cn;
+                handleNewEvent = true;
+                cdnBypass = false;
+                _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
+                _delay = delay;
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleMySegmentsUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                clearTimeout(_delayTimeoutID);
+                _delay = undefined;
+                isHandlingEvent = false;
+                backoff.reset();
+            }
+        };
     }
+    var updateWorkers = (_a = {},
+        _a[MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
+        _a[MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
+        _a);
     return {
-        /**
-         * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
-         *
-         * @param changeNumber change number of the notification
-         * @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) {
-            // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay)
-                return;
-            maxChangeNumber = changeNumber;
-            handleNewEvent = true;
-            _segmentsData = segmentsData;
-            _delay = delay;
-            if (backoff.timeoutID || !isHandlingEvent)
-                __handleMySegmentsUpdateCall();
-            backoff.reset();
+        put: function (mySegmentsData, payload, delay) {
+            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
         },
         stop: function () {
-            clearTimeout(_delayTimeoutID);
-            _delay = undefined;
-            isHandlingEvent = false;
-            backoff.reset();
+            updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
+            updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
         }
     };
 }

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 MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export var MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_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 { 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 { 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;
@@ -140,9 +140,8 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
-                var worker = _a.worker, workerLarge = _a.workerLarge;
-                worker.stop();
-                workerLarge.stop();
+                var worker = _a.worker;
+                return worker.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -197,7 +196,6 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.put(parsedData);
     });
     function handleMySegmentsUpdate(parsedData) {
-        var isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
                 var bitmap_1;
@@ -205,13 +203,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_MEMBERSHIPS_UPDATE, ['BoundedFetchRequest', e]);
                     break;
                 }
                 forOwn(clients, function (_a, matchingKey) {
-                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    var hash64 = _a.hash64, worker = _a.worker;
                     if (isInBitmap(bitmap_1, hash64.hex)) {
-                        (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+                        worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
                     }
                 });
                 return;
@@ -224,51 +222,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_MEMBERSHIPS_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_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
-                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    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) {
-                        (isLS ? workerLarge : worker).put(parsedData.cn, [{
-                                isLS: isLS,
-                                name: parsedData.n[0],
-                                add: add,
-                            }]);
+                        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_MEMBERSHIPS_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
-                    }); }));
+                    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, workerLarge = _a.workerLarge;
-            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+            var worker = _a.worker;
+            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(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
     }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
@@ -306,8 +301,7 @@ 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(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.

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.12",
   "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_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/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_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/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' } };
@@ -67,15 +67,15 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMemberships(userMatchingKey: string, noCache?: boolean) {
+    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
       /**
        * URI encoding of user keys in order to:
        *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
        *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
        *  - 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));
+      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
     },
 
     /**

package/src/services/types.ts

@@ -39,7 +39,7 @@ export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: numbe
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-unused-vars */
+import { IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
 
 /**
@@ -28,7 +30,9 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   /**
    * clear the cache.
    */
-  abstract clear(): void
+  clear() {
+    this.resetSegments({});
+  }
 
   /**
    * 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.
@@ -49,16 +53,57 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   abstract getKeysCount(): number
 
   /**
-   * For server-side synchronizer: set the change number of `name` segment.
-   * For client-side synchronizer: the method is not used.
+   * For server-side synchronizer: change number of `name` segment.
+   * For client-side synchronizer: change number of mySegments.
    */
-  setChangeNumber(name: string, changeNumber: number): boolean { return true; }
-
+  abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void
   abstract getChangeNumber(name: string): number
 
   /**
    * 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.
    */
-  resetSegments(names: string[], changeNumber?: number): boolean { return true; }
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(undefined, segmentsData.cn);
+
+    const { added, removed } = segmentsData as MySegmentsData;
+
+    if (added && removed) {
+      let isDiff = false;
+
+      added.forEach(segment => {
+        isDiff = this.addToSegment(segment) || isDiff;
+      });
+
+      removed.forEach(segment => {
+        isDiff = this.removeFromSegment(segment) || isDiff;
+      });
+
+      return isDiff;
+    }
+
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
+
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
+
+    let 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 (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeFromSegment(storedSegmentKeys[removeIndex]);
+    }
+
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addToSegment(names[addIndex]);
+    }
+
+    return true;
+  }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -32,7 +32,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean
+  abstract setChangeNumber(changeNumber: number): boolean | void
 
   abstract getChangeNumber(): number
 

package/src/storages/dataLoader.ts

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