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

package/esm/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -25,20 +25,28 @@ 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) {
         if (changeNumber !== undefined) {
             return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });

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));
+            });
         });
     };
     /**

package/esm/storages/pluggable/RBSegmentsCachePluggable.js

@@ -25,20 +25,28 @@ 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) {
         if (changeNumber !== undefined) {
             return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');

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);
     };
 }

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -1,6 +1,4 @@
-import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
-import { CONTROL } from '../../../utils/constants';
 import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
@@ -10,53 +8,35 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
     var log = settings.log, definitions = storage.definitions;
     var startingUp = true;
     return function objectUpdater() {
-        var splits = [];
-        var loadError = null;
-        var splitsMock = {};
+        var changes;
         try {
-            splitsMock = splitsParser(settings);
+            changes = splitsParser(settings);
         }
         catch (err) {
-            loadError = err;
             log.error(ERROR_SYNC_OFFLINE_LOADING, [err]);
         }
-        if (!loadError && splitsMock) {
-            log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
-            forOwn(splitsMock, function (val, name) {
-                // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-                splits.push({
-                    name: name,
-                    status: 'ACTIVE',
-                    killed: false,
-                    trafficAllocation: 100,
-                    defaultTreatment: CONTROL,
-                    conditions: val.conditions || [],
-                    configurations: val.configurations,
-                    trafficTypeName: val.trafficTypeName
-                });
-            });
-            return Promise.all([
-                definitions.clear(),
-                definitions.update(splits, [], Date.now())
-            ]).then(function () {
-                readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
-                if (startingUp) {
-                    startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (cacheMetadata) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (!cacheMetadata.initialCacheLoad) {
-                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
-                        }
-                        // Emits SDK_READY
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
-                    });
-                }
-                return true;
-            });
-        }
-        else {
+        if (!changes || !changes.d)
             return Promise.resolve(true);
-        }
+        var _a = changes.d, updated = _a.updated, removed = _a.removed, till = _a.till;
+        log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(changes.d)]);
+        // On start, clear definitions that might be in the storage from a previous session (InLocalStorage), since the parser only tracks its own changes.
+        return Promise.resolve(startingUp && definitions.clear()).then(function () {
+            return definitions.update(updated, removed, till);
+        }).then(function (names) {
+            readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: names });
+            if (startingUp) {
+                startingUp = false;
+                Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (cacheMetadata) {
+                    // Emits SDK_READY_FROM_CACHE
+                    if (!cacheMetadata.initialCacheLoad) {
+                        readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+                    }
+                    // Emits SDK_READY
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
+                });
+            }
+            return true;
+        });
     };
 }
 /**

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

@@ -68,9 +68,8 @@ export 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 });
 }
 function convertInstantUpdateToDefinitionChanges(instantUpdate) {
     var payload = instantUpdate.payload, changeNumber = instantUpdate.changeNumber;
@@ -142,30 +141,28 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                 .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(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(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(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/esm/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.js

@@ -1,5 +1,5 @@
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, FLAGS_UPDATE } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { RB_SEGMENT_UPDATE } from '../constants';
@@ -118,7 +118,7 @@ export function DefinitionsUpdateWorker(params, pollingManager) {
             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(SDK_DEFINITIONS_ARRIVED, true);
+                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [splitName] }, true /* isSplitKill */);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });

package/package.json

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

package/src/storages/AbstractDefinitionsCacheAsync.ts

@@ -12,13 +12,14 @@ export abstract class AbstractDefinitionsCacheAsync implements IDefinitionsCache
   protected abstract remove(name: string): Promise<boolean>
   protected abstract setChangeNumber(changeNumber?: number): MaybeThenable<boolean | void>
 
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): Promise<boolean> {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): Promise<string[]> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(addedFF => this.add(addedFF))),
       Promise.all(toRemove.map(removedFF => this.remove(removedFF)))
     ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
+      return toRemove.filter((_, i) => removed[i])
+        .concat(toAdd.filter((_, i) => added[i]).map(addedFF => addedFF.name));
     });
   }
 

package/src/storages/AbstractDefinitionsCacheSync.ts

@@ -13,9 +13,9 @@ export abstract class AbstractDefinitionsCacheSync implements IDefinitionsCacheS
   protected abstract remove(name: string): boolean
   protected abstract setChangeNumber(changeNumber?: number): boolean | void
 
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): boolean {
-    let updated = toAdd.map(addedFF => this.add(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.remove(removedFF)).some(result => result) || updated;
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(removedFF => this.remove(removedFF))
+      .concat(toAdd.filter(addedFF => this.add(addedFF)).map(addedFF => addedFF.name));
     this.setChangeNumber(changeNumber);
     return updated;
   }

package/src/storages/inLocalStorage/DefinitionsCacheInLocal.ts

@@ -79,13 +79,15 @@ export class DefinitionsCacheInLocal extends AbstractDefinitionsCacheSync {
     this.hasSync = false;
   }
 
-  add(definition: IDefinition) {
+  add(definition: IDefinition): boolean {
     const name = definition.name;
     const definitionKey = this.keys.buildDefinitionKey(name);
     const definitionFromStorage = this.storage.getItem(definitionKey);
     const previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
 
     if (previousDefinition) {
+      if (previousDefinition.changeNumber >= definition.changeNumber) return false;
+
       this._decrementCounts(previousDefinition);
       this.removeFromSets(previousDefinition.name, previousDefinition.sets);
     }

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -25,9 +25,9 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): boolean {
-    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(name => this.remove(name))
+      .concat(toAdd.filter(rbSegment => this.add(rbSegment)).map(rbSegment => rbSegment.name));
     this.setChangeNumber(changeNumber);
     return updated;
   }
@@ -54,6 +54,8 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
     const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
+    if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
+
     this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
     let usesSegmentsDiff = 0;

package/src/storages/inMemory/DefinitionsCacheInMemory.ts

@@ -31,6 +31,7 @@ export class DefinitionsCacheInMemory extends AbstractDefinitionsCacheSync {
     const name = definition.name;
     const previousDefinition = this.get(name);
     if (previousDefinition) { // We had this Split already
+      if (previousDefinition.changeNumber >= definition.changeNumber) return false;
 
       const previousTtName = previousDefinition.trafficTypeName;
       this.ttCache[previousTtName]--;

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -15,9 +15,9 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     this.segmentsCount = 0;
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): boolean {
-    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): string[] {
+    const updated = toRemove.filter(name => this.remove(name))
+      .concat(toAdd.filter(rbSegment => this.add(rbSegment)).map(rbSegment => rbSegment.name));
     if (changeNumber !== undefined) this.changeNumber = changeNumber;
     return updated;
   }
@@ -25,6 +25,7 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
   private add(rbSegment: IRBSegment): boolean {
     const name = rbSegment.name;
     const previous = this.get(name);
+    if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
     if (previous && usesSegments(previous)) this.segmentsCount--;
 
     this.cache[name] = rbSegment;

package/src/storages/inRedis/DefinitionsCacheInRedis.ts

@@ -91,6 +91,8 @@ export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
       let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
       try {
         parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        if (parsedPreviousDefinition && parsedPreviousDefinition.changeNumber >= definition.changeNumber) return false;
+
         stringifiedNewDefinition = JSON.stringify(definition);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
@@ -104,8 +106,8 @@ export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
         return this._incrementCounts(definition).then(() => {
           if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
         });
-      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
-    }).then(() => true);
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets)).then(() => true);
+    });
   }
 
   /**
@@ -115,11 +117,11 @@ export class DefinitionsCacheInRedis extends AbstractDefinitionsCacheAsync {
    */
   remove(name: string) {
     return this.get(name).then((definition) => {
-      if (definition) {
-        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
-      }
-    }).then(() => {
-      return this.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
+      if (!definition) return false;
+
+      return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets)).then(() => {
+        return this.redis.del(this.keys.buildDefinitionKey(name)).then((status: number) => status === 1);
+      });
     });
   }
 

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -37,23 +37,32 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber?: number): Promise<string[]> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(toAdd => {
-        const key = this.keys.buildRBSegmentKey(toAdd.name);
-        const stringifiedNewRBSegment = JSON.stringify(toAdd);
-        return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
-      })),
-      Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove);
-        return this.redis.del(key).then((status: number) => status === 1);
-      }))
+      Promise.all(toAdd.map(rbSegment => this.add(rbSegment))),
+      Promise.all(toRemove.map(name => this.remove(name)))
     ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
+      return toRemove.filter((_, i) => removed[i])
+        .concat(toAdd.filter((_, i) => added[i]).map(rbSegment => rbSegment.name));
     });
   }
 
+  private add(rbSegment: IRBSegment): Promise<boolean> {
+    const key = this.keys.buildRBSegmentKey(rbSegment.name);
+    return this.get(rbSegment.name).then(previous => {
+      if (previous && previous.changeNumber >= rbSegment.changeNumber) return false;
+
+      const stringifiedNewRBSegment = JSON.stringify(rbSegment);
+      return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
+    });
+  }
+
+  private remove(name: string): Promise<boolean> {
+    const key = this.keys.buildRBSegmentKey(name);
+    return this.redis.del(key).then((status: number) => status === 1);
+  }
+
   setChangeNumber(changeNumber?: number) {
     if (changeNumber !== undefined) {
       return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(

package/src/storages/pluggable/DefinitionsCachePluggable.ts

@@ -75,11 +75,14 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
       let parsedPreviousDefinition: IDefinition, stringifiedNewDefinition;
       try {
         parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+        if (parsedPreviousDefinition && parsedPreviousDefinition.changeNumber >= definition.changeNumber) return false;
+
         stringifiedNewDefinition = JSON.stringify(definition);
       } catch (e) {
         throw new Error('Error parsing feature flag definition: ' + e);
       }
 
+
       return this.wrapper.set(definitionKey, stringifiedNewDefinition).then(() => {
         // avoid unnecessary increment/decrement operations
         if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName) return;
@@ -88,8 +91,8 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
         return this._incrementCounts(definition).then(() => {
           if (parsedPreviousDefinition) return this._decrementCounts(parsedPreviousDefinition);
         });
-      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets));
-    }).then(() => true);
+      }).then(() => this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets)).then(() => true);
+    });
   }
 
   /**
@@ -99,11 +102,11 @@ export class DefinitionsCachePluggable extends AbstractDefinitionsCacheAsync {
    */
   remove(name: string) {
     return this.get(name).then((definition) => {
-      if (definition) {
-        return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets));
-      }
-    }).then(() => {
-      return this.wrapper.del(this.keys.buildDefinitionKey(name));
+      if (!definition) return false;
+
+      return this._decrementCounts(definition).then(() => this._updateSets(name, definition.sets)).then(() => {
+        return this.wrapper.del(this.keys.buildDefinitionKey(name));
+      });
     });
   }