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

package/CHANGES.txt

@@ -4,6 +4,8 @@
  - Added support for ioredis v6 (Related to issue https://github.com/splitio/javascript-client/issues/951). Note that ioredis v6 requires Node.js 20 or above; stay on ioredis v4 or v5 for older Node.js versions.
  - Removed the `@types/ioredis` dependency, which is no longer required since the public type definitions don't depend on ioredis types. The `@types/node` dependency, previously installed transitively by `@types/ioredis`, is now declared explicitly, since the public type definitions use Node.js types for the `agent` and `tls` options.
  - Removed Configs SDK-related types and modules and moved them to the Configs SDK repository.
+ - Bugfix - Fixed the SDK_UPDATE event in localhost mode, which is now emitted with the correct list of names of the updated or removed feature flags.
+ - Bugfix - Fixed the SDK_UPDATE event emitted on SPLIT_KILL notifications, which now carries the metadata with the name of the killed feature flag (previously, the metadata was `true`). Also, SPLIT_KILL no longer triggers a second SDK_UPDATE event when the subsequent fetch returns the already killed feature flag with the same change number.
  - Bugfix - Fixed a memory leak in the `Backoff` utility, where promises returned by pending scheduled calls were never settled when the backoff was reset.
  - Bugfix - Fixed the authentication service to not send unauthenticated requests when the SDK is destroyed while an authentication retry is pending.
 

package/cjs/storages/AbstractDefinitionsCacheAsync.js

@@ -17,7 +17,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/cjs/storages/AbstractDefinitionsCacheSync.js

@@ -12,8 +12,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/cjs/storages/inLocalStorage/DefinitionsCacheInLocal.js

@@ -75,6 +75,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);
         }

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -18,8 +18,8 @@ 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;
     };
@@ -46,6 +46,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 && (0, AbstractDefinitionsCacheSync_1.usesSegments)(previous))

package/cjs/storages/inMemory/DefinitionsCacheInMemory.js

@@ -30,6 +30,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])

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -16,8 +16,8 @@ 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;
+        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;
@@ -25,6 +25,8 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
         var name = rbSegment.name;
         var previous = this.get(name);
+        if (previous && previous.changeNumber >= rbSegment.changeNumber)
+            return false;
         if (previous && (0, AbstractDefinitionsCacheSync_1.usesSegments)(previous))
             this.segmentsCount--;
         this.cache[name] = rbSegment;

package/cjs/storages/inRedis/DefinitionsCacheInRedis.js

@@ -76,6 +76,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) {
@@ -90,8 +92,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.
@@ -101,11 +103,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; });
+            });
         });
     };
     /**

package/cjs/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -28,20 +28,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/cjs/storages/pluggable/DefinitionsCachePluggable.js

@@ -63,6 +63,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) {
@@ -77,8 +79,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.
@@ -88,11 +90,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/cjs/storages/pluggable/RBSegmentsCachePluggable.js

@@ -28,20 +28,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/cjs/sync/offline/splitsParser/definitionChangesBuilder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitionChangesBuilderFactory = void 0;
+var tslib_1 = require("tslib");
+var constants_1 = require("../../../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`.
+ */
+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 (tslib_1.__assign({ name: name, status: 'ACTIVE', killed: false, trafficAllocation: 100, defaultTreatment: constants_1.CONTROL }, mock[name])); });
+        return { d: { updated: updated, removed: removed, till: till } };
+    };
+}
+exports.definitionChangesBuilderFactory = definitionChangesBuilderFactory;

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

@@ -3,43 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitsParserFromSettingsFactory = void 0;
 var lang_1 = require("../../../utils/lang");
 var parseCondition_1 = require("./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;
-    }
-}
+var definitionChangesBuilder_1 = require("./definitionChangesBuilder");
 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 = (0, lang_1.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 = (0, lang_1.merge)({}, currentData);
-            return changed;
-        });
-    }
+    var definitionChangesBuilder = (0, definitionChangesBuilder_1.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 = {};
         (0, lang_1.forOwn)(features, function (data, splitName) {
             var treatment = data;
             var config = null;
@@ -50,13 +23,13 @@ function splitsParserFromSettingsFactory() {
             var configurations = {};
             if (config !== null)
                 configurations[treatment] = config;
-            splitObjects[splitName] = {
+            mock[splitName] = {
                 trafficTypeName: 'localhost',
                 conditions: [(0, parseCondition_1.parseCondition)({ treatment: treatment })],
                 configurations: configurations
             };
         });
-        return splitObjects;
+        return definitionChangesBuilder(mock);
     };
 }
 exports.splitsParserFromSettingsFactory = splitsParserFromSettingsFactory;

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

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromObjectSyncTaskFactory = exports.fromObjectUpdaterFactory = void 0;
-var lang_1 = require("../../../utils/lang");
 var syncTask_1 = require("../../syncTask");
-var constants_1 = require("../../../utils/constants");
-var constants_2 = require("../../../readiness/constants");
-var constants_3 = require("../../../logger/constants");
+var constants_1 = require("../../../readiness/constants");
+var constants_2 = require("../../../logger/constants");
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
@@ -13,53 +11,35 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
     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(constants_3.ERROR_SYNC_OFFLINE_LOADING, [err]);
+            log.error(constants_2.ERROR_SYNC_OFFLINE_LOADING, [err]);
         }
-        if (!loadError && splitsMock) {
-            log.debug(constants_3.SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
-            (0, lang_1.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: constants_1.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(constants_2.SDK_DEFINITIONS_ARRIVED, { type: constants_2.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(constants_2.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
-                        }
-                        // Emits SDK_READY
-                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: constants_2.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(constants_2.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(constants_1.SDK_DEFINITIONS_ARRIVED, { type: constants_1.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(constants_1.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+                    }
+                    // Emits SDK_READY
+                    readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: constants_1.SEGMENTS_UPDATE, names: [] });
+                });
+            }
+            return true;
+        });
     };
 }
 exports.fromObjectUpdaterFactory = fromObjectUpdaterFactory;

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

@@ -72,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) {
@@ -147,30 +146,28 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                 .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

@@ -121,7 +121,7 @@ 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(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/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);
         }

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -15,8 +15,8 @@ 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;
     };
@@ -43,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])

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -13,8 +13,8 @@ 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;
+        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;
@@ -22,6 +22,8 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     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; });
+            });
         });
     };
     /**