@splitsoftware/splitio-commons 1.17.1 → 1.17.2-rc.1

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -88,54 +88,28 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         this.hasSync = false;
     };
     SplitsCacheInLocal.prototype.addSplit = function (name, split) {
-        try {
-            var splitKey = this.keys.buildSplitKey(name);
-            var splitFromLocalStorage = localStorage.getItem(splitKey);
-            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-            localStorage.setItem(splitKey, JSON.stringify(split));
-            this._incrementCounts(split);
-            this._decrementCounts(previousSplit);
-            if (previousSplit)
-                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            this.addToFlagSets(split);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
-        }
+        var splitKey = this.keys.buildSplitKey(name);
+        var splitFromLocalStorage = localStorage.getItem(splitKey);
+        var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
+        localStorage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this._decrementCounts(previousSplit);
+        // if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+        // this.addToFlagSets(split);
+        return true;
     };
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        try {
-            var split = this.getSplit(name);
-            localStorage.removeItem(this.keys.buildSplitKey(name));
-            this._decrementCounts(split);
-            if (split)
-                this.removeFromFlagSets(split.name, split.sets);
-            return true;
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-            return false;
-        }
+        var split = this.getSplit(name);
+        localStorage.removeItem(this.keys.buildSplitKey(name));
+        this._decrementCounts(split);
+        // if (split) this.removeFromFlagSets(split.name, split.sets);
+        return true;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
         var item = localStorage.getItem(this.keys.buildSplitKey(name));
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        // when using a new split query, we must update it at the store
-        if (this.updateNewFilter) {
-            this.log.info(constants_1.LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
-            var storageHashKey = this.keys.buildHashKey();
-            try {
-                localStorage.setItem(storageHashKey, this.storageHash);
-            }
-            catch (e) {
-                this.log.error(constants_1.LOG_PREFIX + e);
-            }
-            this.updateNewFilter = false;
-        }
         try {
             localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
             // update "last updated" timestamp with current time
@@ -213,11 +187,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var storageHash = localStorage.getItem(storageHashKey);
         if (storageHash !== this.storageHash) {
             try {
-                // mark cache to update the new query filter on first successful splits fetch
-                this.updateNewFilter = true;
                 // if there is cache, clear it
                 if (this.checkCache())
                     this.clear();
+                this.log.info(constants_1.LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
+                localStorage.setItem(storageHashKey, this.storageHash);
             }
             catch (e) {
                 this.log.error(constants_1.LOG_PREFIX + e);
@@ -233,41 +207,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return new sets_1._Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            var flagSetCache = new sets_1._Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-            flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
-        });
-    };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
-        var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-        if (!flagSetFromLocalStorage)
-            return;
-        var flagSetCache = new sets_1._Set(JSON.parse(flagSetFromLocalStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            localStorage.removeItem(flagSetKey);
-            return;
-        }
-        localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
-    };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));
 exports.SplitsCacheInLocal = SplitsCacheInLocal;

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

@@ -102,7 +102,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
     }
     /** Returns true if at least one split was updated */
     function isThereUpdate(flagsChange) {
-        var added = flagsChange[1], removed = flagsChange[2];
+        var added = flagsChange[0], removed = flagsChange[1];
         // There is at least one added or modified feature flag
         if (added && added.some(function (update) { return update; }))
             return true;
@@ -130,36 +130,38 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
-                startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
                 log.debug(constants_2.SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(constants_2.SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(constants_2.SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
                 // Write into storage
-                // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
-                return Promise.all([
-                    // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-                    splits.setChangeNumber(splitChanges.till),
-                    splits.addSplits(mutation.added),
-                    splits.removeSplits(mutation.removed),
-                    segments.registerSegments(mutation.segments)
-                ]).then(function (flagsChange) {
-                    if (splitsEventEmitter) {
-                        // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
-                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                            .then(function (emitSplitsArrivedEvent) {
-                            // emit SDK events
-                            if (emitSplitsArrivedEvent)
-                                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED);
-                            return true;
-                        });
-                    }
-                    return true;
+                // Wrap into a promise to handle LOCALSTORAGE exceptions and REDIS rejected promises uniformly
+                return Promise.resolve().then(function () {
+                    return Promise.all([
+                        splits.addSplits(mutation.added),
+                        splits.removeSplits(mutation.removed),
+                        segments.registerSegments(mutation.segments)
+                    ]).then(function (flagsChange) {
+                        splits.setChangeNumber(splitChanges.till);
+                        startingUp = false;
+                        if (splitsEventEmitter) {
+                            // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+                            return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+                                .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
+                                .then(function (emitSplitsArrivedEvent) {
+                                // emit SDK events
+                                if (emitSplitsArrivedEvent)
+                                    splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED);
+                                return true;
+                            });
+                        }
+                        return true;
+                    });
                 });
             })
                 .catch(function (error) {
                 log.warn(constants_2.SYNC_SPLITS_FETCH_FAILS, [error]);
+                console.log('startingUp', startingUp, 'retriesOnFailureBeforeReady', retriesOnFailureBeforeReady, 'retry', retry);
                 if (startingUp && retriesOnFailureBeforeReady > retry) {
                     retry += 1;
                     log.info(constants_2.SYNC_SPLITS_FETCH_RETRY, [retry, error]);

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
-import { _Set, setToArray } from '../../utils/lang/sets';
+import { _Set } from '../../utils/lang/sets';
 import { getStorageHash } from '../KeyBuilder';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -85,54 +85,28 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         this.hasSync = false;
     };
     SplitsCacheInLocal.prototype.addSplit = function (name, split) {
-        try {
-            var splitKey = this.keys.buildSplitKey(name);
-            var splitFromLocalStorage = localStorage.getItem(splitKey);
-            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-            localStorage.setItem(splitKey, JSON.stringify(split));
-            this._incrementCounts(split);
-            this._decrementCounts(previousSplit);
-            if (previousSplit)
-                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            this.addToFlagSets(split);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
+        var splitKey = this.keys.buildSplitKey(name);
+        var splitFromLocalStorage = localStorage.getItem(splitKey);
+        var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
+        localStorage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this._decrementCounts(previousSplit);
+        // if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+        // this.addToFlagSets(split);
+        return true;
     };
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        try {
-            var split = this.getSplit(name);
-            localStorage.removeItem(this.keys.buildSplitKey(name));
-            this._decrementCounts(split);
-            if (split)
-                this.removeFromFlagSets(split.name, split.sets);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
+        var split = this.getSplit(name);
+        localStorage.removeItem(this.keys.buildSplitKey(name));
+        this._decrementCounts(split);
+        // if (split) this.removeFromFlagSets(split.name, split.sets);
+        return true;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
         var item = localStorage.getItem(this.keys.buildSplitKey(name));
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        // when using a new split query, we must update it at the store
-        if (this.updateNewFilter) {
-            this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
-            var storageHashKey = this.keys.buildHashKey();
-            try {
-                localStorage.setItem(storageHashKey, this.storageHash);
-            }
-            catch (e) {
-                this.log.error(LOG_PREFIX + e);
-            }
-            this.updateNewFilter = false;
-        }
         try {
             localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
             // update "last updated" timestamp with current time
@@ -210,11 +184,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var storageHash = localStorage.getItem(storageHashKey);
         if (storageHash !== this.storageHash) {
             try {
-                // mark cache to update the new query filter on first successful splits fetch
-                this.updateNewFilter = true;
                 // if there is cache, clear it
                 if (this.checkCache())
                     this.clear();
+                this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
+                localStorage.setItem(storageHashKey, this.storageHash);
             }
             catch (e) {
                 this.log.error(LOG_PREFIX + e);
@@ -230,41 +204,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            var flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-            flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-        });
-    };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
-        var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-        if (!flagSetFromLocalStorage)
-            return;
-        var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            localStorage.removeItem(flagSetKey);
-            return;
-        }
-        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));
 export { SplitsCacheInLocal };

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

@@ -97,7 +97,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
     }
     /** Returns true if at least one split was updated */
     function isThereUpdate(flagsChange) {
-        var added = flagsChange[1], removed = flagsChange[2];
+        var added = flagsChange[0], removed = flagsChange[1];
         // There is at least one added or modified feature flag
         if (added && added.some(function (update) { return update; }))
             return true;
@@ -125,36 +125,38 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
-                startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
                 log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
                 // Write into storage
-                // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
-                return Promise.all([
-                    // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-                    splits.setChangeNumber(splitChanges.till),
-                    splits.addSplits(mutation.added),
-                    splits.removeSplits(mutation.removed),
-                    segments.registerSegments(mutation.segments)
-                ]).then(function (flagsChange) {
-                    if (splitsEventEmitter) {
-                        // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
-                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                            .then(function (emitSplitsArrivedEvent) {
-                            // emit SDK events
-                            if (emitSplitsArrivedEvent)
-                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
-                            return true;
-                        });
-                    }
-                    return true;
+                // Wrap into a promise to handle LOCALSTORAGE exceptions and REDIS rejected promises uniformly
+                return Promise.resolve().then(function () {
+                    return Promise.all([
+                        splits.addSplits(mutation.added),
+                        splits.removeSplits(mutation.removed),
+                        segments.registerSegments(mutation.segments)
+                    ]).then(function (flagsChange) {
+                        splits.setChangeNumber(splitChanges.till);
+                        startingUp = false;
+                        if (splitsEventEmitter) {
+                            // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+                            return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+                                .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
+                                .then(function (emitSplitsArrivedEvent) {
+                                // emit SDK events
+                                if (emitSplitsArrivedEvent)
+                                    splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
+                                return true;
+                            });
+                        }
+                        return true;
+                    });
                 });
             })
                 .catch(function (error) {
                 log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
+                console.log('startingUp', startingUp, 'retriesOnFailureBeforeReady', retriesOnFailureBeforeReady, 'retry', retry);
                 if (startingUp && retriesOnFailureBeforeReady > retry) {
                     retry += 1;
                     log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);

package/package.json

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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,7 +4,7 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISet, _Set, setToArray } from '../../utils/lang/sets';
+import { ISet, _Set } from '../../utils/lang/sets';
 import { ISettings } from '../../types';
 import { getStorageHash } from '../KeyBuilder';
 
@@ -18,7 +18,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private readonly storageHash: string;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
-  private updateNewFilter?: boolean;
 
   /**
    * @param {KeyBuilderCS} keys
@@ -102,39 +101,29 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   addSplit(name: string, split: ISplit) {
-    try {
-      const splitKey = this.keys.buildSplitKey(name);
-      const splitFromLocalStorage = localStorage.getItem(splitKey);
-      const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
+    const splitKey = this.keys.buildSplitKey(name);
+    const splitFromLocalStorage = localStorage.getItem(splitKey);
+    const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
 
-      localStorage.setItem(splitKey, JSON.stringify(split));
+    localStorage.setItem(splitKey, JSON.stringify(split));
 
-      this._incrementCounts(split);
-      this._decrementCounts(previousSplit);
+    this._incrementCounts(split);
+    this._decrementCounts(previousSplit);
 
-      if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-      this.addToFlagSets(split);
+    // if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+    // this.addToFlagSets(split);
 
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
+    return true;
   }
 
   removeSplit(name: string): boolean {
-    try {
-      const split = this.getSplit(name);
-      localStorage.removeItem(this.keys.buildSplitKey(name));
+    const split = this.getSplit(name);
+    localStorage.removeItem(this.keys.buildSplitKey(name));
 
-      this._decrementCounts(split);
-      if (split) this.removeFromFlagSets(split.name, split.sets);
+    this._decrementCounts(split);
+    // if (split) this.removeFromFlagSets(split.name, split.sets);
 
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
+    return true;
   }
 
   getSplit(name: string) {
@@ -143,19 +132,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   setChangeNumber(changeNumber: number): boolean {
-
-    // when using a new split query, we must update it at the store
-    if (this.updateNewFilter) {
-      this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
-      const storageHashKey = this.keys.buildHashKey();
-      try {
-        localStorage.setItem(storageHashKey, this.storageHash);
-      } catch (e) {
-        this.log.error(LOG_PREFIX + e);
-      }
-      this.updateNewFilter = false;
-    }
-
     try {
       localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
@@ -246,12 +222,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
     if (storageHash !== this.storageHash) {
       try {
-        // mark cache to update the new query filter on first successful splits fetch
-        this.updateNewFilter = true;
-
         // if there is cache, clear it
         if (this.checkCache()) this.clear();
 
+        this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
+        localStorage.setItem(storageHashKey, this.storageHash);
+
       } catch (e) {
         this.log.error(LOG_PREFIX + e);
       }
@@ -268,48 +244,48 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     });
   }
 
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
+  // private addToFlagSets(featureFlag: ISplit) {
+  //   if (!featureFlag.sets) return;
 
-    featureFlag.sets.forEach(featureFlagSet => {
+  //   featureFlag.sets.forEach(featureFlagSet => {
 
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
+  //     if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
 
-      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
+  //     const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
 
-      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+  //     const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      const flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-      flagSetCache.add(featureFlag.name);
+  //     const flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+  //     flagSetCache.add(featureFlag.name);
 
-      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    });
-  }
+  //     localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+  //   });
+  // }
 
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
-    if (!flagSets) return;
+  // private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
+  //   if (!flagSets) return;
 
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
+  //   flagSets.forEach(flagSet => {
+  //     this.removeNames(flagSet, featureFlagName);
+  //   });
+  // }
 
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
+  // private removeNames(flagSetName: string, featureFlagName: string) {
+  //   const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
 
-    const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+  //   const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-    if (!flagSetFromLocalStorage) return;
+  //   if (!flagSetFromLocalStorage) return;
 
-    const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-    flagSetCache.delete(featureFlagName);
+  //   const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+  //   flagSetCache.delete(featureFlagName);
 
-    if (flagSetCache.size === 0) {
-      localStorage.removeItem(flagSetKey);
-      return;
-    }
+  //   if (flagSetCache.size === 0) {
+  //     localStorage.removeItem(flagSetKey);
+  //     return;
+  //   }
 
-    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-  }
+  //   localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+  // }
 
 }

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -129,8 +129,8 @@ export function splitChangesUpdaterFactory(
   }
 
   /** Returns true if at least one split was updated */
-  function isThereUpdate(flagsChange: [boolean | void, void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
-    const [, added, removed] = flagsChange;
+  function isThereUpdate(flagsChange: [void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
+    const [added, removed] = flagsChange;
     // There is at least one added or modified feature flag
     if (added && added.some((update: boolean) => update)) return true;
     // There is at least one removed feature flag
@@ -158,8 +158,6 @@ export function splitChangesUpdaterFactory(
         splitChangesFetcher(since, noCache, till, _promiseDecorator)
       )
         .then((splitChanges: ISplitChangesResponse) => {
-          startingUp = false;
-
           const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
 
           log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
@@ -167,29 +165,33 @@ export function splitChangesUpdaterFactory(
           log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
 
           // Write into storage
-          // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
-          return Promise.all([
-            // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-            splits.setChangeNumber(splitChanges.till),
-            splits.addSplits(mutation.added),
-            splits.removeSplits(mutation.removed),
-            segments.registerSegments(mutation.segments)
-          ]).then((flagsChange) => {
-            if (splitsEventEmitter) {
-              // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
-                .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                .then(emitSplitsArrivedEvent => {
-                  // emit SDK events
-                  if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
-                  return true;
-                });
-            }
-            return true;
+          // Wrap into a promise to handle LOCALSTORAGE exceptions and REDIS rejected promises uniformly
+          return Promise.resolve().then(() => {
+            return Promise.all([
+              splits.addSplits(mutation.added),
+              splits.removeSplits(mutation.removed),
+              segments.registerSegments(mutation.segments)
+            ]).then((flagsChange) => {
+              splits.setChangeNumber(splitChanges.till);
+              startingUp = false;
+
+              if (splitsEventEmitter) {
+                // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+                return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+                  .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
+                  .then(emitSplitsArrivedEvent => {
+                    // emit SDK events
+                    if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);
+                    return true;
+                  });
+              }
+              return true;
+            });
           });
         })
         .catch(error => {
           log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
+          console.log('startingUp', startingUp, 'retriesOnFailureBeforeReady', retriesOnFailureBeforeReady, 'retry', retry);
 
           if (startingUp && retriesOnFailureBeforeReady > retry) {
             retry += 1;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -12,7 +12,6 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     private readonly storageHash;
     private readonly flagSetsFilter;
     private hasSync?;
-    private updateNewFilter?;
     /**
      * @param {KeyBuilderCS} keys
      * @param {number | undefined} expirationTimestamp
@@ -49,7 +48,4 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     private _checkExpiration;
     private _checkFilterQuery;
     getNamesByFlagSets(flagSets: string[]): ISet<string>[];
-    private addToFlagSets;
-    private removeFromFlagSets;
-    private removeNames;
 }