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

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

@@ -1,5 +1,5 @@
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
-import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
+import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
 /**
  * Factory of SegmentChanges updater, a task that:
@@ -20,7 +20,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         return promise;
     }
     function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
-        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Processing segment ").concat(segmentName));
+        log.debug("".concat(LOG_PREFIX_SYNC, "Processing segment ").concat(segmentName));
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
@@ -28,14 +28,14 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with since = ").concat(x.since, " and till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });
                 }).catch(function (error) {
                     if (retries) {
-                        log.warn("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Retrying fetch of segment ").concat(segmentName, " (attempt #").concat(retries, "). Reason: ").concat(error));
+                        log.warn("".concat(LOG_PREFIX_SYNC, "Retrying fetch of segment ").concat(segmentName, " (attempt #").concat(retries, "). Reason: ").concat(error));
                         return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
                     }
                     throw error;
@@ -54,7 +54,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
      * @param till - till target for the provided segmentName, for CDN bypass.
      */
     return function segmentChangesUpdater(fetchOnlyNew, segmentName, noCache, till) {
-        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Started segments update"));
+        log.debug("".concat(LOG_PREFIX_SYNC, "Started segments update"));
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
@@ -63,7 +63,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    if (readiness) {
+                    if (readiness && !fetchOnlyNew) {
                         var metadata = {
                             type: SEGMENTS_UPDATE,
                             names: []
@@ -84,7 +84,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 log.error("".concat(LOG_PREFIX_INSTANTIATION, ": you passed a client-side type authorizationKey, please grab an SDK Key from Harness FME UI that is of type server-side."));
             }
             else {
-                log.warn("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Error while doing fetch of segments. ").concat(error));
+                log.warn("".concat(LOG_PREFIX_SYNC, "Error while doing fetch of segments. ").concat(error));
             }
             return false;
         });

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

@@ -1,5 +1,5 @@
 import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
-import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
+import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
 var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
 var STREAMING_EVENT_TYPES = [OCCUPANCY_PRI, OCCUPANCY_SEC];
 /**
@@ -70,7 +70,7 @@ export function notificationKeeperFactory(pushEmitter, telemetryTracker) {
                         c.cTime = timestamp;
                         if (controlType === ControlType.STREAMING_DISABLED) {
                             telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
-                            pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                            pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                         }
                         else if (hasPublishers) {
                             if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {

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, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_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';
 /**
@@ -48,7 +48,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 pushEmitter.emit(PUSH_RETRYABLE_ERROR);
             }
             else {
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
             }
         },
         /* NotificationProcessor */
@@ -71,6 +71,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
+                case CONFIG_UPDATE:
                 case SEGMENT_UPDATE:
                 case MEMBERSHIPS_MS_UPDATE:
                 case MEMBERSHIPS_LS_UPDATE:

package/esm/sync/streaming/UpdateWorkers/{SplitsUpdateWorker.js → DefinitionsUpdateWorker.js}

@@ -1,40 +1,39 @@
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { RB_SEGMENT_UPDATE } from '../constants';
-import { parseFFUpdatePayload } from '../parseUtils';
+import { parseUpdatePayload } from '../parseUtils';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
- * SplitsUpdateWorker factory
+ * DefinitionsUpdateWorker factory for Flags SDKs, where notifications pcn and changeNumber are environment-scoped
  */
-export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
-    var ff = SplitsUpdateWorker(storage.splits);
-    var rbs = SplitsUpdateWorker(storage.rbSegments);
-    function SplitsUpdateWorker(cache) {
+export function DefinitionsUpdateWorker(params, pollingManager) {
+    var log = params.settings.log, storage = params.storage, telemetryTracker = params.telemetryTracker, definitionsEventEmitter = params.readiness.definitions;
+    var definitionsSyncTask = pollingManager.definitionsSyncTask;
+    var ff = DefinitionsUpdateWorker(storage.definitions);
+    var rbs = DefinitionsUpdateWorker(storage.rbSegments);
+    function DefinitionsUpdateWorker(cache) {
         var maxChangeNumber = -1;
         var handleNewEvent = false;
         var isHandlingEvent;
         var cdnBypass;
         var instantUpdate;
-        var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-        function __handleSplitUpdateCall() {
+        var backoff = new Backoff(__handleDefinitionUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+        function __handleDefinitionUpdateCall() {
             isHandlingEvent = true;
             if (maxChangeNumber > cache.getChangeNumber()) {
                 handleNewEvent = false;
                 // fetch splits revalidating data if cached
-                splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
+                definitionsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
                     if (!isHandlingEvent)
                         return; // halt if `stop` has been called
                     if (handleNewEvent) {
-                        __handleSplitUpdateCall();
+                        __handleDefinitionUpdateCall();
                     }
                     else {
                         if (instantUpdate)
                             telemetryTracker.trackUpdatesFromSSE(SPLITS);
-                        // fetch new registered segments for server-side API. Not retrying on error
-                        if (segmentsSyncTask)
-                            segmentsSyncTask.execute(true);
                         var attempts = backoff.attempts + 1;
                         if (ff.isSync() && rbs.isSync()) {
                             log.debug("Refresh completed".concat(cdnBypass ? ' bypassing the CDN' : '', " in ").concat(attempts, " attempts."));
@@ -52,7 +51,7 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
                         else {
                             backoff.reset();
                             cdnBypass = true;
-                            __handleSplitUpdateCall();
+                            __handleDefinitionUpdateCall();
                         }
                     }
                 });
@@ -80,7 +79,7 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
                     instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
                 }
                 if (backoff.timeoutID || !isHandlingEvent)
-                    __handleSplitUpdateCall();
+                    __handleDefinitionUpdateCall();
                 backoff.reset();
             },
             stop: function () {
@@ -96,7 +95,7 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
         put: function (parsedData) {
             if (parsedData.d && parsedData.c !== undefined) {
                 try {
-                    var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+                    var payload = parseUpdatePayload(parsedData.c, parsedData.d);
                     if (payload) {
                         (parsedData.type === RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
                         return;
@@ -115,11 +114,11 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
          * @param splitName - name of split to kill
          * @param defaultTreatment - default treatment value
          */
-        killSplit: function (_a) {
+        killDefinition: function (_a) {
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-            if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+            if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
-                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
+                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, true);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });

package/esm/sync/streaming/constants.js

@@ -5,7 +5,7 @@ export var SECONDS_BEFORE_EXPIRATION = 600;
  * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
  * triggers `handleNonRetryableError` call
  */
-export var PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+export var PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
 /**
  * emitted on SSE and Authenticate recoverable errors
  * triggers `handleRetryableError` call
@@ -17,7 +17,7 @@ export var PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
  */
 export var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 /**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NON_RETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
  * triggers `startPolling` and `stopWorkers` calls
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
@@ -27,6 +27,7 @@ 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 CONFIG_UPDATE = 'CONFIG_UPDATE';
 export var RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 export var CONTROL = 'CONTROL';

package/esm/sync/streaming/parseUtils.js

@@ -30,22 +30,22 @@ function decompress(data, compression) {
     throw new Error("Invalid compression algorithm #".concat(compression));
 }
 /**
- * Decode, decompress and parse the provided 'data' into a KeyList object
+ * Decode, decompress and parse the provided 'data' into an object of type T
  *
  * @param data - base64 encoded string
  * @param compression - 1 GZIP, 2 ZLIB
  * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns keyList
+ * @returns parsed object
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data, compression, avoidPrecisionLoss) {
+export function parseCompressedData(data, compression, avoidPrecisionLoss) {
     if (avoidPrecisionLoss === void 0) { avoidPrecisionLoss = true; }
-    var binKeyList = decompress(data, compression);
-    var strKeyList = Uint8ArrayToString(binKeyList);
-    // replace numbers to strings, to avoid losing precision
+    var binData = decompress(data, compression);
+    var str = Uint8ArrayToString(binData);
+    // replace numbers to strings, to avoid losing precision (e.g., 64-bit IDs in KeyList)
     if (avoidPrecisionLoss)
-        strKeyList = strKeyList.replace(/\d+/g, '"$&"');
-    return JSON.parse(strKeyList);
+        str = str.replace(/\d+/g, '"$&"');
+    return JSON.parse(str);
 }
 /**
  * Decode, decompress and parse the provided 'data' into a Bitmap object
@@ -73,11 +73,11 @@ export function isInBitmap(bitmap, hash64hex) {
     return (bitmap[internal] & 1 << offset) > 0;
 }
 /**
- * Parse feature flags notifications for instant feature flag updates
+ * Parse notifications for instant updates
  */
-export function parseFFUpdatePayload(compression, data) {
+export function parseUpdatePayload(compression, data) {
     return compression > 0 ?
-        parseKeyList(data, compression, false) :
+        parseCompressedData(data, compression, false) :
         JSON.parse(decodeFromBase64(data));
 }
 var DEFAULT_MAX_INTERVAL = 60000;

package/esm/sync/streaming/pushManager.js

@@ -3,15 +3,14 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
-import { authenticateFactory, hashUserKey } from './AuthClient';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, RB_SEGMENT_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 } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
-import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -19,8 +18,9 @@ import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+export function pushManagerFactory(params, pollingManager, definitionsUpdateWorkerFactory) {
+    if (definitionsUpdateWorkerFactory === void 0) { definitionsUpdateWorkerFactory = DefinitionsUpdateWorker; }
+    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
     var userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
@@ -34,7 +34,6 @@ export function pushManagerFactory(params, pollingManager) {
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
@@ -42,19 +41,17 @@ export function pushManagerFactory(params, pollingManager) {
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     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, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
-    // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
-    var userKeyHashes = {};
+    // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+    var definitionsUpdateWorker = definitionsUpdateWorkerFactory(params, pollingManager);
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
-    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
-    // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
     // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
     var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
@@ -90,14 +87,14 @@ export function pushManagerFactory(params, pollingManager) {
         log.info(STREAMING_CONNECTING);
         disconnected = false;
         var userKeys = userKey ? Object.keys(clients) : undefined;
-        authenticate(userKeys).then(function (authData) {
+        serviceApi.fetchAuth(userKeys).then(function (authData) {
             if (disconnected)
                 return;
-            // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+            // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
             // close the sseClient in case the org has been bloqued while the instance was connected to streaming
             if (!authData.pushEnabled) {
                 log.info(STREAMING_DISABLED);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
@@ -112,7 +109,7 @@ export function pushManagerFactory(params, pollingManager) {
             // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
             if (error.statusCode >= 400 && error.statusCode < 500) {
                 telemetryTracker.streamingEvent(AUTH_REJECTION);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // Handle other HTTP and network errors as recoverable errors
@@ -136,7 +133,7 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.stop();
+        definitionsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
@@ -152,7 +149,7 @@ export function pushManagerFactory(params, pollingManager) {
         connectPushRetryBackoff.reset();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
-    pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
         disabled = true;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
@@ -178,9 +175,12 @@ export function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
-    pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+    // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+    // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
+    pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+    pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(CONFIG_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
@@ -203,7 +203,7 @@ export function pushManagerFactory(params, pollingManager) {
             case UpdateStrategy.KeyList: {
                 var keyList = void 0, added_1, removed_1;
                 try {
-                    keyList = parseKeyList(parsedData.d, parsedData.c);
+                    keyList = parseCompressedData(parsedData.d, parsedData.c);
                     added_1 = new Set(keyList.a);
                     removed_1 = new Set(keyList.r);
                 }
@@ -282,9 +282,7 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var hash = hashUserKey(userKey);
-            if (!userKeyHashes[hash]) {
-                userKeyHashes[hash] = userKey;
+            if (!clients[userKey]) {
                 clients[userKey] = {
                     hash64: hash64(userKey),
                     worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -305,8 +303,6 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = hashUserKey(userKey);
-            delete userKeyHashes[hash];
             delete clients[userKey];
         }
     });

package/esm/sync/submitters/eventsSubmitter.js

@@ -4,7 +4,7 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
  * Submitter that periodically posts tracked events
  */
 export function eventsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.splitApi.postEventsBulk, events = params.storage.events;
+    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.serviceApi.postEventsBulk, events = params.storage.events;
     // don't retry events.
     var submitter = submitterFactory(log, postEventsBulk, events, eventsPushRate);
     // Set a timer for the first push window of events.

package/esm/sync/submitters/impressionCountsSubmitter.js

@@ -25,7 +25,7 @@ var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
  * Submitter that periodically posts impression counts
  */
 export function impressionCountsSubmitterFactory(params) {
-    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
+    var log = params.settings.log, postTestImpressionsCount = params.serviceApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
     // retry impressions counts only once.
     return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, fromImpressionCountsCollector, 1);
 }

package/esm/sync/submitters/impressionsSubmitter.js

@@ -11,7 +11,7 @@ export function fromImpressionsCollector(sendLabels, data) {
         dto.push({
             f: name,
             i: value.map(function (entry) {
-                var keyImpression = {
+                return {
                     k: entry.keyName,
                     t: entry.treatment,
                     m: entry.time,
@@ -19,9 +19,10 @@ export function fromImpressionsCollector(sendLabels, data) {
                     r: sendLabels ? entry.label : undefined,
                     b: entry.bucketingKey,
                     pt: entry.pt,
-                    properties: entry.properties // Properties
+                    properties: entry.properties,
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
+                    et: entry.entityType, // Definition type
                 };
-                return keyImpression;
             })
         });
     });
@@ -31,7 +32,7 @@ export function fromImpressionsCollector(sendLabels, data) {
  * Submitter that periodically posts impressions data
  */
 export function impressionsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions;
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.serviceApi.postTestImpressionsBulk, impressions = params.storage.impressions;
     // retry impressions only once.
     var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
     // register impressions submitter to be executed when impressions cache is full

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,18 +102,17 @@ export function telemetrySubmitterFactory(params) {
     var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, serviceApi = params.serviceApi, readiness = params.readiness;
     var stopTimer = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, serviceApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
-    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started
         if (submitter.isRunning()) {
-            var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+            var postMetricsConfigTask = submitterFactory(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
             postMetricsConfigTask.execute();
         }
     });

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -5,7 +5,7 @@ var UNIQUE_KEYS_RATE = 900000; // 15 minutes
  * Submitter that periodically posts impression counts
  */
 export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.serviceApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
     var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE);

package/esm/sync/syncManagerOnline.js

@@ -3,8 +3,8 @@ 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 { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -26,7 +26,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
-        // It is not inyected as push and polling managers, because at the moment it is required
+        // It is not injected as push and polling managers, because at the moment it is required
         var submitterManager = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
@@ -74,7 +74,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments

package/esm/utils/Backoff.js

@@ -1,6 +1,7 @@
 var Backoff = /** @class */ (function () {
     /**
-     * Schedule function calls with exponential backoff
+     * Schedule function calls with exponential backoff.
+     * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
      */
     function Backoff(cb, baseMillis, maxMillis) {
         this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -17,19 +18,50 @@ var Backoff = /** @class */ (function () {
         var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
+        this.attempts++;
         this.timeoutID = setTimeout(function () {
             _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
-        this.attempts++;
         return delayInMillis;
     };
-    Backoff.prototype.reset = function () {
+    /**
+     * Schedule a delayed call to `cb`
+     * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+     */
+    Backoff.prototype.scheduleCallAsync = function () {
+        var _this = this;
+        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+        if (this.timeoutID)
+            clearTimeout(this.timeoutID);
+        this.attempts++;
+        return new Promise(function (resolve, reject) {
+            _this.pending = { resolve: resolve, reject: reject };
+            _this.timeoutID = setTimeout(function () {
+                _this.timeoutID = undefined;
+                _this.pending = undefined;
+                _this.cb().then(resolve, reject);
+            }, delayInMillis);
+        });
+    };
+    /**
+     * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending
+     * and the caller wants to settle it immediately instead of waiting for `cb` to be invoked, pass `settle`:
+     * `{ value }` to resolve, or `{ error }` to reject.
+     */
+    Backoff.prototype.reset = function (settle) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (settle && this.pending) {
+            if ('value' in settle)
+                this.pending.resolve(settle.value);
+            else
+                this.pending.reject(settle.error);
+            this.pending = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes