@splitsoftware/splitio-commons 3.1.1-rc.11 → 3.1.1-rc.13

package/cjs/sync/polling/updaters/definitionChangesUpdater.js

@@ -8,6 +8,7 @@ var lang_1 = require("../../../utils/lang");
 var constants_3 = require("../../../utils/constants");
 var sets_1 = require("../../../utils/lang/sets");
 var constants_4 = require("../../streaming/constants");
+var thenable_1 = require("../../../utils/promise/thenable");
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -71,9 +72,8 @@ function computeMutation(update, segments, filters) {
         else {
             accum.removed.push(ruleEntity.name);
         }
-        accum.names.push(ruleEntity.name);
         return accum;
-    }, { updated: [], removed: update.removed, names: update.removed.slice() });
+    }, { updated: [], removed: update.removed });
 }
 exports.computeMutation = computeMutation;
 function convertInstantUpdateToDefinitionChanges(instantUpdate) {
@@ -115,7 +115,7 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
      * @param noCache - true to revalidate data to fetch
      * @param till - query param to bypass CDN requests
      */
-    return function definitionChangesUpdater(noCache, till, instantUpdate) {
+    return function definitionChangesUpdater(noCache, till, instantUpdate, pcns) {
         /**
          * @param since - current changeNumber at definitionsCache
          * @param retry - current number of retry attempts
@@ -123,8 +123,14 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
         function _definitionChangesUpdater(sinces, retry) {
             if (retry === void 0) { retry = 0; }
             var since = sinces[0], rbSince = sinces[1];
-            log.debug(constants_2.SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
-            return Promise.resolve(instantUpdate ?
+            // If provided, `since` and `rbSince` must not be higher than it, to avoid missing an update that the scoped `pcn` indicates hasn't been fetched yet.
+            if (pcns) {
+                if (pcns.since !== undefined && pcns.since < since)
+                    since = pcns.since;
+                if (pcns.rbSince !== undefined && pcns.rbSince < rbSince)
+                    rbSince = pcns.rbSince;
+            }
+            var definitionChangesRequest = instantUpdate ?
                 instantUpdate.type === constants_4.RB_SEGMENT_UPDATE ?
                     { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                     // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
@@ -133,34 +139,35 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                             { d: convertInstantUpdateToDefinitionChanges(instantUpdate) } :
                             definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
                     }) :
-                definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
+                definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
+            if ((0, thenable_1.thenable)(definitionChangesRequest))
+                log.debug(constants_2.SYNC_FETCH, [definitionChangesFetcher.type, since, rbSince]);
+            return Promise.resolve(definitionChangesRequest)
                 .then(function (definitionChanges) {
                 var usedSegments = new Set();
                 var updatedDefinitions = [];
-                var ffUpdate = false;
                 if (definitionChanges.d) {
-                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), updated = _a.updated, removed = _a.removed, names = _a.names;
-                    updatedDefinitions = names;
+                    var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), updated = _a.updated, removed = _a.removed;
                     log.debug(constants_2.SYNC_UPDATE, [definitionChangesFetcher.type, updated.length, removed.length]);
-                    ffUpdate = definitions.update(updated, removed, definitionChanges.d.till);
+                    updatedDefinitions = definitions.update(updated, removed, definitionChanges.d.till);
                 }
-                var rbsUpdate = false;
+                var updatedRBSNames = [];
                 if (definitionChanges.rbs) {
                     var _b = computeMutation(definitionChanges.rbs, usedSegments), updated = _b.updated, removed = _b.removed;
                     log.debug(constants_2.SYNC_UPDATE, ['rule-based segments', updated.length, removed.length]);
-                    rbsUpdate = rbSegments.update(updated, removed, definitionChanges.rbs.till);
+                    updatedRBSNames = rbSegments.update(updated, removed, definitionChanges.rbs.till);
                 }
-                return Promise.all([ffUpdate, rbsUpdate,
+                return Promise.all([updatedDefinitions, updatedRBSNames,
                     // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
                     segments.registerSegments((0, sets_1.setToArray)(usedSegments))
                 ]).then(function (_a) {
-                    var ffChanged = _a[0], rbsChanged = _a[1];
+                    var updatedDefinitions = _a[0], updatedRBSNames = _a[1];
                     if (storage.save)
                         storage.save();
                     startingUp = false;
                     if (definitionsEventEmitter) {
                         // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must wait for all registered segments to be fetched
-                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
+                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((updatedDefinitions.length > 0 || updatedRBSNames.length > 0) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

package/cjs/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.js

@@ -9,9 +9,11 @@ var constants_4 = require("../constants");
 var parseUtils_1 = require("../parseUtils");
 var constants_5 = require("./constants");
 /**
- * DefinitionsUpdateWorker factory
+ * DefinitionsUpdateWorker factory for Flags SDKs, where notifications pcn and changeNumber are environment-scoped
  */
-function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker) {
+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) {
@@ -96,7 +98,7 @@ function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsE
         put: function (parsedData) {
             if (parsedData.d && parsedData.c !== undefined) {
                 try {
-                    var payload = (0, parseUtils_1.parseFFUpdatePayload)(parsedData.c, parsedData.d);
+                    var payload = (0, parseUtils_1.parseUpdatePayload)(parsedData.c, parsedData.d);
                     if (payload) {
                         (parsedData.type === constants_4.RB_SEGMENT_UPDATE ? rbs : ff).put(parsedData, payload);
                         return;
@@ -119,7 +121,7 @@ function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsE
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
             if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
-                definitionsEventEmitter.emit(constants_2.SDK_DEFINITIONS_ARRIVED, true);
+                definitionsEventEmitter.emit(constants_2.SDK_DEFINITIONS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [splitName] }, true /* isSplitKill */);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });

package/cjs/sync/streaming/parseUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDelay = exports.parseFFUpdatePayload = exports.isInBitmap = exports.parseBitmap = exports.parseCompressedData = void 0;
+exports.getDelay = exports.parseUpdatePayload = exports.isInBitmap = exports.parseBitmap = exports.parseCompressedData = void 0;
 var decompress_1 = require("../../utils/decompress");
 var base64_1 = require("../../utils/base64");
 var murmur3_1 = require("../../utils/murmur3/murmur3");
@@ -79,14 +79,14 @@ function isInBitmap(bitmap, hash64hex) {
 }
 exports.isInBitmap = isInBitmap;
 /**
- * Parse feature flags notifications for instant feature flag updates
+ * Parse notifications for instant updates
  */
-function parseFFUpdatePayload(compression, data) {
+function parseUpdatePayload(compression, data) {
     return compression > 0 ?
         parseCompressedData(data, compression, false) :
         JSON.parse((0, base64_1.decodeFromBase64)(data));
 }
-exports.parseFFUpdatePayload = parseFFUpdatePayload;
+exports.parseUpdatePayload = parseUpdatePayload;
 var DEFAULT_MAX_INTERVAL = 60000;
 function getDelay(parsedData, matchingKey) {
     if (parsedData.h === 0)

package/cjs/sync/streaming/pushManager.js

@@ -21,8 +21,9 @@ var constants_3 = require("../../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
  */
-function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+function pushManagerFactory(params, pollingManager, definitionsUpdateWorkerFactory) {
+    if (definitionsUpdateWorkerFactory === void 0) { definitionsUpdateWorkerFactory = DefinitionsUpdateWorker_1.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 = (0, key_1.checkIfServerSide)(settings) ? undefined : (0, key_1.getMatching)(settings.core.key);
@@ -44,7 +45,7 @@ function pushManagerFactory(params, pollingManager) {
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : (0, SegmentsUpdateWorker_1.SegmentsUpdateWorker)(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
-    var definitionsUpdateWorker = (0, DefinitionsUpdateWorker_1.DefinitionsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
+    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 = {};

package/esm/services/authProvider.js

@@ -1,4 +1,4 @@
-import { fetchAuthFactory } from '../sync/streaming/AuthClient';
+import { fetchAuthFactory } from './fetchAuth';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { TOKEN } from '../utils/constants';

package/esm/{sync/streaming/AuthClient/index.js → services/fetchAuth.js}

@@ -1,5 +1,5 @@
-import { objectAssign } from '../../../utils/lang/objectAssign';
-import { decodeJWTtoken } from '../../../utils/jwt';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { decodeJWTtoken } from '../utils/jwt';
 /**
  * Factory of authentication function.
  *

package/esm/services/splitApi.js

@@ -2,7 +2,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
-import { fetchAuthFactory } from '../sync/streaming/AuthClient';
+import { fetchAuthFactory } from './fetchAuth';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.

package/esm/storages/AbstractDefinitionsCacheAsync.js

@@ -14,7 +14,8 @@ var AbstractDefinitionsCacheAsync = /** @class */ (function () {
             Promise.all(toRemove.map(function (removedFF) { return _this.remove(removedFF); }))
         ]).then(function (_a) {
             var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+            return toRemove.filter(function (_, i) { return removed[i]; })
+                .concat(toAdd.filter(function (_, i) { return added[i]; }).map(function (addedFF) { return addedFF.name; }));
         });
     };
     // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')

package/esm/storages/AbstractDefinitionsCacheSync.js

@@ -9,8 +9,8 @@ var AbstractDefinitionsCacheSync = /** @class */ (function () {
     }
     AbstractDefinitionsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.add(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.remove(removedFF); }).some(function (result) { return result; }) || updated;
+        var updated = toRemove.filter(function (removedFF) { return _this.remove(removedFF); })
+            .concat(toAdd.filter(function (addedFF) { return _this.add(addedFF); }).map(function (addedFF) { return addedFF.name; }));
         this.setChangeNumber(changeNumber);
         return updated;
     };

package/esm/storages/inLocalStorage/DefinitionsCacheInLocal.js

@@ -72,6 +72,8 @@ var DefinitionsCacheInLocal = /** @class */ (function (_super) {
         var definitionFromStorage = this.storage.getItem(definitionKey);
         var previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
         if (previousDefinition) {
+            if (previousDefinition.changeNumber >= definition.changeNumber)
+                return false;
             this._decrementCounts(previousDefinition);
             this.removeFromSets(previousDefinition.name, previousDefinition.sets);
         }
@@ -95,7 +97,8 @@ var DefinitionsCacheInLocal = /** @class */ (function (_super) {
     };
     DefinitionsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+            if (changeNumber !== undefined)
+                this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
             // update "last updated" timestamp with current time
             this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
             this.hasSync = true;

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -15,14 +15,15 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).some(function (result) { return result; }) || updated;
+        var updated = toRemove.filter(function (name) { return _this.remove(name); })
+            .concat(toAdd.filter(function (rbSegment) { return _this.add(rbSegment); }).map(function (rbSegment) { return rbSegment.name; }));
         this.setChangeNumber(changeNumber);
         return updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+            if (changeNumber !== undefined)
+                this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
             this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
         }
         catch (e) {
@@ -42,6 +43,8 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         var rbSegmentKey = this.keys.buildRBSegmentKey(name);
         var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
         var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
+        if (previous && previous.changeNumber >= rbSegment.changeNumber)
+            return false;
         this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
         var usesSegmentsDiff = 0;
         if (previous && usesSegments(previous))

package/esm/storages/inMemory/DefinitionsCacheInMemory.js

@@ -27,6 +27,8 @@ var DefinitionsCacheInMemory = /** @class */ (function (_super) {
         var name = definition.name;
         var previousDefinition = this.get(name);
         if (previousDefinition) { // We had this Split already
+            if (previousDefinition.changeNumber >= definition.changeNumber)
+                return false;
             var previousTtName = previousDefinition.trafficTypeName;
             this.ttCache[previousTtName]--;
             if (!this.ttCache[previousTtName])
@@ -67,7 +69,8 @@ var DefinitionsCacheInMemory = /** @class */ (function (_super) {
         return this.definitionsCache[name] || null;
     };
     DefinitionsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.changeNumber = changeNumber;
+        if (changeNumber !== undefined)
+            this.changeNumber = changeNumber;
         return true;
     };
     DefinitionsCacheInMemory.prototype.getChangeNumber = function () {

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -13,14 +13,17 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     };
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).some(function (result) { return result; }) || updated;
-        this.changeNumber = changeNumber;
+        var updated = toRemove.filter(function (name) { return _this.remove(name); })
+            .concat(toAdd.filter(function (rbSegment) { return _this.add(rbSegment); }).map(function (rbSegment) { return rbSegment.name; }));
+        if (changeNumber !== undefined)
+            this.changeNumber = changeNumber;
         return updated;
     };
     RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
         var name = rbSegment.name;
         var previous = this.get(name);
+        if (previous && previous.changeNumber >= rbSegment.changeNumber)
+            return false;
         if (previous && usesSegments(previous))
             this.segmentsCount--;
         this.cache[name] = rbSegment;

package/esm/storages/inRedis/DefinitionsCacheInRedis.js

@@ -73,6 +73,8 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
             var parsedPreviousDefinition, stringifiedNewDefinition;
             try {
                 parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                if (parsedPreviousDefinition && parsedPreviousDefinition.changeNumber >= definition.changeNumber)
+                    return false;
                 stringifiedNewDefinition = JSON.stringify(definition);
             }
             catch (e) {
@@ -87,8 +89,8 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
                     if (parsedPreviousDefinition)
                         return _this._decrementCounts(parsedPreviousDefinition);
                 });
-            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
-        }).then(function () { return true; });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); }).then(function () { return true; });
+        });
     };
     /**
      * Remove a given definition.
@@ -98,11 +100,11 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
     DefinitionsCacheInRedis.prototype.remove = function (name) {
         var _this = this;
         return this.get(name).then(function (definition) {
-            if (definition) {
-                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
-            }
-        }).then(function () {
-            return _this.redis.del(_this.keys.buildDefinitionKey(name)).then(function (status) { return status === 1; });
+            if (!definition)
+                return false;
+            return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); }).then(function () {
+                return _this.redis.del(_this.keys.buildDefinitionKey(name)).then(function (status) { return status === 1; });
+            });
         });
     };
     /**
@@ -123,7 +125,9 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
      * or rejected if it fails.
      */
     DefinitionsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+        if (changeNumber !== undefined) {
+            return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+        }
     };
     /**
      * Get till number or -1 if it's not defined.

package/esm/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -25,22 +25,32 @@ var RBSegmentsCacheInRedis = /** @class */ (function () {
         var _this = this;
         return Promise.all([
             this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (toAdd) {
-                var key = _this.keys.buildRBSegmentKey(toAdd.name);
-                var stringifiedNewRBSegment = JSON.stringify(toAdd);
-                return _this.redis.set(key, stringifiedNewRBSegment).then(function () { return true; });
-            })),
-            Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove);
-                return _this.redis.del(key).then(function (status) { return status === 1; });
-            }))
+            Promise.all(toAdd.map(function (rbSegment) { return _this.add(rbSegment); })),
+            Promise.all(toRemove.map(function (name) { return _this.remove(name); }))
         ]).then(function (_a) {
             var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+            return toRemove.filter(function (_, i) { return removed[i]; })
+                .concat(toAdd.filter(function (_, i) { return added[i]; }).map(function (rbSegment) { return rbSegment.name; }));
         });
     };
+    RBSegmentsCacheInRedis.prototype.add = function (rbSegment) {
+        var _this = this;
+        var key = this.keys.buildRBSegmentKey(rbSegment.name);
+        return this.get(rbSegment.name).then(function (previous) {
+            if (previous && previous.changeNumber >= rbSegment.changeNumber)
+                return false;
+            var stringifiedNewRBSegment = JSON.stringify(rbSegment);
+            return _this.redis.set(key, stringifiedNewRBSegment).then(function () { return true; });
+        });
+    };
+    RBSegmentsCacheInRedis.prototype.remove = function (name) {
+        var key = this.keys.buildRBSegmentKey(name);
+        return this.redis.del(key).then(function (status) { return status === 1; });
+    };
     RBSegmentsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+        if (changeNumber !== undefined) {
+            return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+        }
     };
     RBSegmentsCacheInRedis.prototype.getChangeNumber = function () {
         var _this = this;

package/esm/storages/pluggable/DefinitionsCachePluggable.js

@@ -60,6 +60,8 @@ var DefinitionsCachePluggable = /** @class */ (function (_super) {
             var parsedPreviousDefinition, stringifiedNewDefinition;
             try {
                 parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                if (parsedPreviousDefinition && parsedPreviousDefinition.changeNumber >= definition.changeNumber)
+                    return false;
                 stringifiedNewDefinition = JSON.stringify(definition);
             }
             catch (e) {
@@ -74,8 +76,8 @@ var DefinitionsCachePluggable = /** @class */ (function (_super) {
                     if (parsedPreviousDefinition)
                         return _this._decrementCounts(parsedPreviousDefinition);
                 });
-            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
-        }).then(function () { return true; });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); }).then(function () { return true; });
+        });
     };
     /**
      * Remove a given definition.
@@ -85,11 +87,11 @@ var DefinitionsCachePluggable = /** @class */ (function (_super) {
     DefinitionsCachePluggable.prototype.remove = function (name) {
         var _this = this;
         return this.get(name).then(function (definition) {
-            if (definition) {
-                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
-            }
-        }).then(function () {
-            return _this.wrapper.del(_this.keys.buildDefinitionKey(name));
+            if (!definition)
+                return false;
+            return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); }).then(function () {
+                return _this.wrapper.del(_this.keys.buildDefinitionKey(name));
+            });
         });
     };
     /**
@@ -183,7 +185,9 @@ var DefinitionsCachePluggable = /** @class */ (function (_super) {
      * or rejected if it fails (e.g., wrapper operation fails).
      */
     DefinitionsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
-        return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+        if (changeNumber !== undefined) {
+            return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+        }
     };
     /**
      * Get till number or -1 if it's not defined.

package/esm/storages/pluggable/RBSegmentsCachePluggable.js

@@ -25,22 +25,32 @@ var RBSegmentsCachePluggable = /** @class */ (function () {
         var _this = this;
         return Promise.all([
             this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (toAdd) {
-                var key = _this.keys.buildRBSegmentKey(toAdd.name);
-                var stringifiedNewRBSegment = JSON.stringify(toAdd);
-                return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
-            })),
-            Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove);
-                return _this.wrapper.del(key);
-            }))
+            Promise.all(toAdd.map(function (rbSegment) { return _this.add(rbSegment); })),
+            Promise.all(toRemove.map(function (name) { return _this.remove(name); }))
         ]).then(function (_a) {
             var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+            return toRemove.filter(function (_, i) { return removed[i]; })
+                .concat(toAdd.filter(function (_, i) { return added[i]; }).map(function (rbSegment) { return rbSegment.name; }));
         });
     };
+    RBSegmentsCachePluggable.prototype.add = function (rbSegment) {
+        var _this = this;
+        var key = this.keys.buildRBSegmentKey(rbSegment.name);
+        return this.get(rbSegment.name).then(function (previous) {
+            if (previous && previous.changeNumber >= rbSegment.changeNumber)
+                return false;
+            var stringifiedNewRBSegment = JSON.stringify(rbSegment);
+            return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
+        });
+    };
+    RBSegmentsCachePluggable.prototype.remove = function (name) {
+        var key = this.keys.buildRBSegmentKey(name);
+        return this.wrapper.del(key);
+    };
     RBSegmentsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
-        return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+        if (changeNumber !== undefined) {
+            return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+        }
     };
     RBSegmentsCachePluggable.prototype.getChangeNumber = function () {
         var _this = this;

package/esm/sync/offline/splitsParser/definitionChangesBuilder.js

@@ -0,0 +1,33 @@
+import { __assign } from "tslib";
+import { CONTROL } from '../../../utils/constants';
+/**
+ * Factory of a stateful function that, given the current mocked definitions, returns the changes since the previous call
+ * as an `IDefinitionChangesResponse`, i.e., the full definitions that were added or modified, and the names of the removed ones.
+ * Definitions are compared by value. The response `till` is an incrementing value based on the current time.
+ * Definitions have no `changeNumber`, so storages never consider them outdated.
+ *
+ * The response has no `d` property if there are no changes, except for the first call, which reports the (possibly empty) mock.
+ * It is meant to be used by `IDefinitionsParser` implementations, such as `splitsParserFromSettings`.
+ */
+export function definitionChangesBuilderFactory() {
+    var previous; // serialized definitions of the last reported mock, by name
+    var lastTill = 0;
+    return function definitionChangesBuilder(mock) {
+        var current = {};
+        var updatedNames = Object.keys(mock).reduce(function (updatedNames, name) {
+            current[name] = JSON.stringify(mock[name]);
+            if (!previous || previous[name] !== current[name])
+                updatedNames.push(name);
+            return updatedNames;
+        }, []);
+        var removed = previous ? Object.keys(previous).filter(function (name) { return current[name] === undefined; }) : [];
+        // Only the first call reports an empty change
+        if (previous && updatedNames.length === 0 && removed.length === 0)
+            return {};
+        previous = current;
+        // Incrementing `till` based on the current time
+        var till = lastTill = Math.max(Date.now(), lastTill + 1);
+        var updated = updatedNames.map(function (name) { return (__assign({ name: name, status: 'ACTIVE', killed: false, trafficAllocation: 100, defaultTreatment: CONTROL }, mock[name])); });
+        return { d: { updated: updated, removed: removed, till: till } };
+    };
+}

package/esm/sync/offline/splitsParser/splitsParserFromSettings.js

@@ -1,42 +1,15 @@
-import { isObject, forOwn, merge } from '../../../utils/lang';
+import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
-function hasTreatmentChanged(prev, curr) {
-    if (typeof prev !== typeof curr)
-        return true;
-    if (typeof prev === 'string') { // strings treatments, just compare
-        return prev !== curr;
-    }
-    else { // has treatment and config, compare both
-        return prev.treatment !== curr.treatment || prev.config !== curr.config;
-    }
-}
+import { definitionChangesBuilderFactory } from './definitionChangesBuilder';
 export function splitsParserFromSettingsFactory() {
-    var previousMock = { 'emptyMock': '1' };
-    function mockUpdated(currentData) {
-        var names = Object.keys(currentData);
-        // Different amount of items
-        if (names.length !== Object.keys(previousMock).length) {
-            previousMock = merge({}, currentData);
-            return true;
-        }
-        return names.some(function (name) {
-            var newSplit = !previousMock[name];
-            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-            var changed = newSplit || newTreatment;
-            if (changed)
-                previousMock = merge({}, currentData);
-            return changed;
-        });
-    }
+    var definitionChangesBuilder = definitionChangesBuilderFactory();
     /**
      *
      * @param settings - validated object with mocked features mapping.
      */
     return function splitsParserFromSettings(settings) {
         var features = settings.features || {};
-        if (!mockUpdated(features))
-            return false;
-        var splitObjects = {};
+        var mock = {};
         forOwn(features, function (data, splitName) {
             var treatment = data;
             var config = null;
@@ -47,12 +20,12 @@ export function splitsParserFromSettingsFactory() {
             var configurations = {};
             if (config !== null)
                 configurations[treatment] = config;
-            splitObjects[splitName] = {
+            mock[splitName] = {
                 trafficTypeName: 'localhost',
                 conditions: [parseCondition({ treatment: treatment })],
                 configurations: configurations
             };
         });
-        return splitObjects;
+        return definitionChangesBuilder(mock);
     };
 }