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

package/esm/sync/streaming/constants.js

@@ -22,8 +22,7 @@ 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 = 'MY_SEGMENTS_UPDATE';
-export var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export var MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';

package/esm/sync/streaming/parseUtils.js

@@ -1,5 +1,6 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
+import { hash } from '../../utils/murmur3/murmur3';
 var GZIP = 1;
 var ZLIB = 2;
 function Uint8ArrayToString(myUint8Arr) {
@@ -74,14 +75,17 @@ export function isInBitmap(bitmap, hash64hex) {
 }
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
 export function parseFFUpdatePayload(compression, data) {
-    var avoidPrecisionLoss = false;
-    if (compression > 0)
-        return parseKeyList(data, compression, avoidPrecisionLoss);
-    else
-        return JSON.parse(decodeFromBase64(data));
+    return compression > 0 ?
+        parseKeyList(data, compression, false) :
+        JSON.parse(decodeFromBase64(data));
+}
+var DEFAULT_MAX_INTERVAL = 60000;
+export function getDelay(parsedData, matchingKey) {
+    if (parsedData.h === 0)
+        return 0;
+    var interval = parsedData.i || DEFAULT_MAX_INTERVAL;
+    var seed = parsedData.s || 0;
+    return hash(matchingKey, seed) % interval;
 }

package/esm/sync/streaming/pushManager.js

@@ -8,19 +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, 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, 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_V2, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+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 { UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
-import { hash } from '../../utils/murmur3/murmur3';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
-export function getDelay(parsedData, matchingKey) {
-    var interval = parsedData.i || 60000;
-    var seed = parsedData.s || 0;
-    return hash(matchingKey, seed) % interval;
-}
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -54,7 +48,7 @@ export function pushManagerFactory(params, pollingManager) {
     // [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 MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+    // Hash64 is used to process MY_SEGMENTS_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;
@@ -148,7 +142,7 @@ export function pushManagerFactory(params, pollingManager) {
             forOwn(clients, function (_a) {
                 var worker = _a.worker, workerLarge = _a.workerLarge;
                 worker.stop();
-                workerLarge && workerLarge.stop();
+                workerLarge.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -203,7 +197,7 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.put(parsedData);
     });
     function handleMySegmentsUpdate(parsedData) {
-        var isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+        var isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
                 var bitmap_1;
@@ -211,15 +205,13 @@ export function pushManagerFactory(params, pollingManager) {
                     bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_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 && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-                            worker.put(parsedData.changeNumber);
+                        (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
                     }
                 });
                 return;
@@ -232,64 +224,50 @@ export function pushManagerFactory(params, pollingManager) {
                     removed_1 = new _Set(keyList.r);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+                    break;
+                }
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_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 && workerLarge.put(parsedData.changeNumber, {
-                                name: parsedData.largeSegments[0],
-                                add: add
-                            }) :
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
+                        (isLS ? workerLarge : worker).put(parsedData.cn, [{
+                                isLS: isLS,
+                                name: parsedData.n[0],
+                                add: add,
+                            }]);
                     }
                 });
                 return;
             }
             case UpdateStrategy.SegmentRemoval:
-                if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
-                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
-                    isLS ?
-                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
-                            workerLarge.put(parsedData.changeNumber, {
-                                name: largeSegment,
-                                add: false
-                            });
-                        }) :
-                        worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
-                            add: false
-                        });
+                    (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n.map(function (largeSegment) { return ({
+                        isLS: isLS,
+                        name: largeSegment,
+                        add: false,
+                        cn: parsedData.cn
+                    }); }));
                 });
                 return;
         }
         // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
         forOwn(clients, function (_a, matchingKey) {
             var worker = _a.worker, workerLarge = _a.workerLarge;
-            isLS ?
-                workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-                worker.put(parsedData.changeNumber);
+            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
         });
     }
     if (userKey) {
-        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-            var userKeyHash = channel.split('_')[2];
-            var userKey = userKeyHashes[userKeyHash];
-            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-            }
-        });
-        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+        pushEmitter.on(MY_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
         pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
     }
     else {
@@ -313,7 +291,7 @@ export function pushManagerFactory(params, pollingManager) {
                 return;
             disconnected = false;
             if (userKey)
-                this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask); // client-side
+                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
             else
                 setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
@@ -322,14 +300,14 @@ export function pushManagerFactory(params, pollingManager) {
             return disconnected === false;
         },
         // [Only for client-side]
-        add: function (userKey, mySegmentsSyncTask, myLargeSegmentsSyncTask) {
+        add: function (userKey, mySegmentsSyncTask) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
                 clients[userKey] = {
                     hash64: hash64(userKey),
                     worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
-                    workerLarge: myLargeSegmentsSyncTask ? MySegmentsUpdateWorker(myLargeSegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT) : undefined
+                    workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT)
                 };
                 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/sync/submitters/telemetrySubmitter.js

@@ -61,12 +61,10 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
-                lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
                 rR: {
                     sp: scheduler.featuresRefreshRate / 1000,
                     se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
                     ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
-                    mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
                     im: scheduler.impressionsRefreshRate / 1000,
                     ev: scheduler.eventsPushRate / 1000,
                     te: scheduler.telemetryRefreshRate / 1000,

package/esm/sync/syncManagerOnline.js

@@ -2,7 +2,7 @@ import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
-import { IN_LARGE_SEGMENT, IN_SEGMENT, POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
+import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -114,53 +114,43 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             shared: function (matchingKey, readinessManager, storage) {
                 if (!pollingManager)
                     return;
-                var _a = pollingManager.add(matchingKey, readinessManager, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
                 return {
-                    isRunning: msSyncTask.isRunning,
+                    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.usesMatcher(IN_SEGMENT))
-                                        msSyncTask.start();
-                                    if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                                        mlsSyncTask.start();
+                                    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
-                                    msSyncTask.execute();
-                                    mlsSyncTask && mlsSyncTask.execute();
+                                    mySegmentsSyncTask.execute();
                                 }
-                                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
+                                pushManager.add(matchingKey, mySegmentsSyncTask);
                             }
                             else {
-                                if (storage.splits.usesMatcher(IN_SEGMENT))
-                                    msSyncTask.start();
-                                if (mlsSyncTask && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                                    mlsSyncTask.start();
+                                if (storage.splits.usesSegments())
+                                    mySegmentsSyncTask.start();
                             }
                         }
                         else {
-                            if (!readinessManager.isReady()) {
-                                msSyncTask.execute();
-                                mlsSyncTask && mlsSyncTask.execute();
-                            }
+                            if (!readinessManager.isReady())
+                                mySegmentsSyncTask.execute();
                         }
                     },
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
-                        var syncTasks = pollingManager.get(matchingKey);
-                        if (syncTasks) {
-                            var msSyncTask_1 = syncTasks.msSyncTask, mlsSyncTask_1 = syncTasks.mlsSyncTask;
+                        var mySegmentsSyncTask = pollingManager.get(matchingKey);
+                        if (mySegmentsSyncTask) {
                             // stop syncing
                             if (pushManager)
                                 pushManager.remove(matchingKey);
-                            if (msSyncTask_1.isRunning())
-                                msSyncTask_1.stop();
-                            if (mlsSyncTask_1 && mlsSyncTask_1.isRunning())
-                                mlsSyncTask_1.stop();
+                            if (mySegmentsSyncTask.isRunning())
+                                mySegmentsSyncTask.stop();
                             pollingManager.remove(matchingKey);
                         }
                     },

package/esm/utils/constants/index.js

@@ -87,7 +87,7 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAG_SPEC_VERSION = '1.1';
+export var FLAG_SPEC_VERSION = '1.2';
 // Matcher types
 export var IN_SEGMENT = 'IN_SEGMENT';
 export var IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/esm/utils/settingsValidation/index.js

@@ -27,8 +27,6 @@ export var base = {
         featuresRefreshRate: 60,
         // fetch segments updates each 60 sec
         segmentsRefreshRate: 60,
-        // fetch large segments updates each 60 sec
-        largeSegmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
@@ -74,8 +72,7 @@ export var base = {
         impressionsMode: OPTIMIZED,
         localhostMode: undefined,
         enabled: true,
-        flagSpecVersion: FLAG_SPEC_VERSION,
-        largeSegmentsEnabled: false
+        flagSpecVersion: FLAG_SPEC_VERSION
     },
     // Logger
     log: undefined
@@ -114,7 +111,6 @@ export function settingsValidation(config, validationParams) {
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-    scheduler.largeSegmentsRefreshRate = fromSecondsToMillis(scheduler.largeSegmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));

package/package.json

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

package/src/dtos/types.ts

@@ -224,18 +224,20 @@ export interface ISegmentChangesResponse {
   till: number
 }
 
-/** Interface of the parsed JSON response of `/mySegments/{userKey}` */
-export interface IMySegmentsResponse {
-  mySegments: {
-    id: string,
-    name: string
-  }[]
-}
-
-/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
-export interface IMyLargeSegmentsResponse {
-  myLargeSegments: string[],
-  changeNumber: number
+/** 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
+    }>
+  }
 }
 
 /** Metadata internal type for storages */

package/src/logger/constants.ts

@@ -36,6 +36,7 @@ export const IMPRESSION = 102;
 export const IMPRESSION_QUEUEING = 103;
 export const NEW_SHARED_CLIENT = 104;
 export const NEW_FACTORY = 105;
+export const POLLING_SMART_PAUSING = 106;
 export const POLLING_START = 107;
 export const POLLING_STOP = 108;
 export const SYNC_SPLITS_FETCH_RETRY = 109;
@@ -78,7 +79,7 @@ export const WARN_SPLITS_FILTER_IGNORED = 219;
 export const WARN_SPLITS_FILTER_INVALID = 220;
 export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
-export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
+export const STREAMING_PARSING_MY_SEGMENTS_UPDATE = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export const WARN_INVALID_FLAGSET = 225;
 export const WARN_LOWERCASE_FLAGSET = 226;

package/src/logger/messages/info.ts

@@ -19,10 +19,11 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
 
   // synchronizer
+  [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/src/logger/messages/warn.ts

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

package/src/readiness/readinessManager.ts

@@ -10,7 +10,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-  // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
   splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
@@ -18,8 +18,10 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   return splitsEventEmitter;
 }
 
-function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter, segmentsArrived = false): ISegmentsEventEmitter {
-  const segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived });
+function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISegmentsEventEmitter {
+  const segmentsEventEmitter = objectAssign(new EventEmitter(), {
+    segmentsArrived: false
+  });
 
   segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, () => { segmentsEventEmitter.segmentsArrived = true; });
 
@@ -34,10 +36,9 @@ export function readinessManagerFactory(
   settings: ISettings,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
-  const { startup: { readyTimeout, waitForLargeSegments }, sync: { largeSegmentsEnabled } } = settings;
+  const readyTimeout = settings.startup.readyTimeout;
 
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
-  const largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
   const gate: IReadinessEventEmitter = new EventEmitter();
 
   // emit SDK_READY_FROM_CACHE
@@ -63,7 +64,6 @@ export function readinessManagerFactory(
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
-  if (largeSegments) largeSegments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
 
@@ -89,7 +89,7 @@ export function readinessManagerFactory(
         setTimeout(() => { throw e; }, 0);
       }
     } else {
-      if (splits.splitsArrived && segments.segmentsArrived && (!largeSegments || largeSegments.segmentsArrived)) {
+      if (splits.splitsArrived && segments.segmentsArrived) {
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
@@ -107,7 +107,6 @@ export function readinessManagerFactory(
   return {
     splits,
     segments,
-    largeSegments,
     gate,
 
     shared() {
@@ -126,7 +125,6 @@ export function readinessManagerFactory(
       isDestroyed = true;
 
       segments.removeAllListeners();
-      if (largeSegments) largeSegments.removeAllListeners();
       gate.removeAllListeners();
       clearTimeout(readyTimeoutId);
 

package/src/readiness/types.ts

@@ -45,7 +45,6 @@ export interface IReadinessManager {
   /** Event emitters */
   splits: ISplitsEventEmitter,
   segments: ISegmentsEventEmitter,
-  largeSegments?: ISegmentsEventEmitter, // Undefined if largeSegmentsEnabled or waitForLargeSegments are false
   gate: IReadinessEventEmitter,
 
   /** Readiness status */

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, MY_LARGE_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -22,7 +22,7 @@ function userKeyToQueryParam(userKey: string) {
  */
 export function splitApiFactory(
   settings: ISettings,
-  platform: IPlatform,
+  platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
   telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
@@ -67,22 +67,17 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMySegments(userMatchingKey: string, noCache?: boolean) {
+    fetchMemberships(userMatchingKey: string, noCache?: boolean) {
       /**
        * URI encoding of user keys in order to:
-       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
-       *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
+       *  - 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}/mySegments/${encodeURIComponent(userMatchingKey)}`;
+      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
     },
 
-    fetchMyLargeSegments(userMatchingKey: string, noCache?: boolean) {
-      const url = `${urls.sdk}/myLargeSegments/${encodeURIComponent(userMatchingKey)}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_LARGE_SEGMENT));
-    },
-
     /**
      * Post events.
      *

package/src/services/splitHttpClient.ts

@@ -12,7 +12,7 @@ const messageNoFetch = 'Global fetch API is not available.';
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
  * @param platform object containing environment-specific dependencies
  */
-export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient {
+export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient {
 
   const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
   const options = getOptions && getOptions(settings);

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 IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
@@ -61,8 +61,7 @@ export interface ISplitApi {
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
-	fetchMySegments: IFetchMySegments
-	fetchMyLargeSegments: IFetchMySegments
+	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
 	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -54,15 +54,11 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
    */
   setChangeNumber(name: string, changeNumber: number): boolean { return true; }
 
-  /**
-   * For server-side synchronizer: get the change number of `name` segment.
-   * For client-side synchronizer: the method is not used.
-   */
-  getChangeNumber(name: string): number { return -1; }
+  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.
    */
-  resetSegments(names: string[]): boolean { return true; }
+  resetSegments(names: string[], changeNumber?: number): boolean { return true; }
 }

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -22,9 +22,9 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 
-  // @TODO revisit segment-related methods ('usesMatcher', 'getRegisteredSegments', 'registerSegments')
+  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
   // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-  usesMatcher(): Promise<boolean> {
+  usesSegments(): Promise<boolean> {
     return Promise.resolve(true);
   }