@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1

package/esm/storages/dataLoader.js

@@ -42,6 +42,6 @@ export function dataLoaderFactory(preloadedData) {
                 return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        storage.segments.resetSegments(mySegmentsData);
     };
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
-import { isNaNNumber } from '../../utils/lang';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
@@ -11,11 +10,19 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
-    MySegmentsCacheInLocal.prototype.addSegment = function (name) {
+    /**
+     * Removes list of segments from localStorage
+     * @NOTE this method is not being used at the moment.
+     */
+    MySegmentsCacheInLocal.prototype.clear = function () {
+        this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
+        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+        // We could optimize next sentence, since it implies iterating over all localStorage items
+        this.resetSegments([]);
+    };
+    MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) === DEFINED)
-                return false;
             localStorage.setItem(segmentKey, DEFINED);
             return true;
         }
@@ -24,11 +31,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             return false;
         }
     };
-    MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) !== DEFINED)
-                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -40,22 +45,30 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     *
+     * @param {string[]} segmentNames list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {
         var _this = this;
+        var isDiff = false;
+        var index;
         // Scan current values from localStorage
-        return Object.keys(localStorage).reduce(function (accum, key) {
+        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName) {
                 accum.push(segmentName);
             }
             else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey)) {
+                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
                             localStorage.setItem(newSegmentKey, DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -69,30 +82,40 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-    };
-    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
-        return 1;
-    };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            if (changeNumber)
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            else
-                localStorage.removeItem(this.keys.buildTillKey());
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentNames.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentNames.length !== names.length) {
+            isDiff = true;
+            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+            names.forEach(function (name) { return _this.addToSegment(name); });
         }
-        catch (e) {
-            this.log.error(e);
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+                names.forEach(function (name) { return _this.addToSegment(name); });
+            }
         }
+        return isDiff;
     };
-    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = localStorage.getItem(this.keys.buildTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+        var _this = this;
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
+            if (segmentName)
+                accum.push(segmentName);
+            return accum;
+        }, []);
+    };
+    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
+        return 1;
     };
     return MySegmentsCacheInLocal;
-}(AbstractMySegmentsCacheSync));
+}(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -2,7 +2,7 @@ import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -33,11 +33,9 @@ export function InLocalStorage(options) {
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
-        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
         return {
             splits: splits,
             segments: segments,
-            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(eventsQueueSize),
@@ -47,7 +45,6 @@ export function InLocalStorage(options) {
                 var _a;
                 this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory();
-                this.largeSegments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -55,10 +52,10 @@ export function InLocalStorage(options) {
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
+                var childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+                    segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -66,7 +63,6 @@ export function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory();
-                        this.largeSegments = new MySegmentsCacheInMemory();
                     }
                 };
             },

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -15,11 +15,9 @@ export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
-    var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
-        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(eventsQueueSize),
@@ -29,7 +27,6 @@ export function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
-            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
@@ -40,7 +37,6 @@ export function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -49,13 +45,12 @@ export function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
-                    this.largeSegments.clear();
                 }
             };
         },
     };
     // @TODO revisit storage logic in localhost mode
-    // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
+    // No tracking data in localhost mode to avoid memory leaks
     if (params.settings.mode === LOCALHOST_MODE) {
         var noopTrack = function () { return true; };
         storage.impressions.track = noopTrack;

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -1,5 +1,5 @@
 import { __extends } from "tslib";
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
@@ -11,26 +11,57 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.addSegment = function (name) {
-        if (this.segmentCache[name])
-            return false;
+    MySegmentsCacheInMemory.prototype.clear = function () {
+        this.segmentCache = {};
+    };
+    MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
         this.segmentCache[name] = true;
         return true;
     };
-    MySegmentsCacheInMemory.prototype.removeSegment = function (name) {
-        if (!this.segmentCache[name])
-            return false;
+    MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.cn = changeNumber;
-    };
-    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.cn || -1;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInMemory.prototype.resetSegments = function (names) {
+        var _this = this;
+        var isDiff = false;
+        var index;
+        var storedSegmentKeys = Object.keys(this.segmentCache);
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentKeys.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentKeys.length !== names.length) {
+            isDiff = true;
+            this.segmentCache = {};
+            names.forEach(function (s) {
+                _this.addToSegment(s);
+            });
+        }
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                this.segmentCache = {};
+                names.forEach(function (s) {
+                    _this.addToSegment(s);
+                });
+            }
+        }
+        return isDiff;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);
@@ -39,5 +70,5 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         return 1;
     };
     return MySegmentsCacheInMemory;
-}(AbstractMySegmentsCacheSync));
+}(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInMemory };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,20 +1,32 @@
+import { __extends } from "tslib";
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
-var SegmentsCacheInMemory = /** @class */ (function () {
+var SegmentsCacheInMemory = /** @class */ (function (_super) {
+    __extends(SegmentsCacheInMemory, _super);
     function SegmentsCacheInMemory() {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.segmentCache = {};
+        _this.segmentChangeNumber = {};
+        return _this;
     }
-    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var keySet = this.segmentCache[name] || new _Set();
-        addedKeys.forEach(function (k) { return keySet.add(k); });
-        removedKeys.forEach(function (k) { return keySet.delete(k); });
+    SegmentsCacheInMemory.prototype.addToSegment = function (name, segmentKeys) {
+        var values = this.segmentCache[name];
+        var keySet = values ? values : new _Set();
+        segmentKeys.forEach(function (k) { return keySet.add(k); });
         this.segmentCache[name] = keySet;
-        this.segmentChangeNumber[name] = changeNumber;
-        return addedKeys.length > 0 || removedKeys.length > 0;
+        return true;
+    };
+    SegmentsCacheInMemory.prototype.removeFromSegment = function (name, segmentKeys) {
+        var values = this.segmentCache[name];
+        var keySet = values ? values : new _Set();
+        segmentKeys.forEach(function (k) { return keySet.delete(k); });
+        this.segmentCache[name] = keySet;
+        return true;
     };
     SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
         var segmentValues = this.segmentCache[name];
@@ -48,12 +60,14 @@ var SegmentsCacheInMemory = /** @class */ (function () {
             return acum + _this.segmentCache[segmentName].size;
         }, 0);
     };
+    SegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
+        this.segmentChangeNumber[name] = changeNumber;
+        return true;
+    };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return isIntegerNumber(value) ? value : -1;
+        return isIntegerNumber(value) ? value : undefined;
     };
-    // No-op. Not used in server-side
-    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
     return SegmentsCacheInMemory;
-}());
+}(AbstractSegmentsCacheSync));
 export { SegmentsCacheInMemory };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -4,6 +4,7 @@ import { isFiniteNumber } from '../../utils/lang';
 import { _Set } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     __extends(SplitsCacheInMemory, _super);
@@ -12,7 +13,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.segmentsCount = 0;
+        _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -21,7 +22,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.segmentsCount = 0;
+        this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -31,9 +32,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if (usesSegments(previousSplit))
-                this.segmentsCount--;
+            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -44,7 +45,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if (usesSegments(split))
-                this.segmentsCount++;
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -63,7 +64,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if (usesSegments(split))
-                this.segmentsCount--;
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -87,7 +88,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
     SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,10 +18,9 @@ export function shouldRecordTelemetry(_a) {
     return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+    function TelemetryCacheInMemory(splits, segments) {
         this.splits = splits;
         this.segments = segments;
-        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -37,7 +36,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -57,8 +59,6 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(QUEUED),
             eD: this.getEventStats(DROPPED),
@@ -190,11 +190,14 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+        this.updatesFromSSE[type]++;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -6,32 +6,38 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         this.redis = redis;
         this.keys = keys;
     }
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., Redis operation fails).
-     */
-    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
+    SegmentsCacheInRedis.prototype.addToSegment = function (name, segmentKeys) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        return Promise.all([
-            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
-            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
-            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-        ]).then(function () {
-            return addedKeys.length > 0 || removedKeys.length > 0;
-        });
+        if (segmentKeys.length) {
+            return this.redis.sadd(segmentKey, segmentKeys).then(function () { return true; });
+        }
+        else {
+            return Promise.resolve(true);
+        }
+    };
+    SegmentsCacheInRedis.prototype.removeFromSegment = function (name, segmentKeys) {
+        var segmentKey = this.keys.buildSegmentNameKey(name);
+        if (segmentKeys.length) {
+            return this.redis.srem(segmentKey, segmentKeys).then(function () { return true; });
+        }
+        else {
+            return Promise.resolve(true);
+        }
     };
     SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
         return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
     };
+    SegmentsCacheInRedis.prototype.setChangeNumber = function (name, changeNumber) {
+        return this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '').then(function (status) { return status === 'OK'; });
+    };
     SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
+            return isNaNNumber(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/esm/storages/inRedis/index.js

@@ -9,17 +9,23 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 import { metadataBuilder } from '../utils';
+var RD;
+try {
+    // Using `require` to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
+    // Redis storage is not supported with .mjs files.
+    RD = require('./RedisAdapter').RedisAdapter;
+}
+catch (error) { /* empty */ }
 /**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
+ * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
 export function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
-    // Lazy loading to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
-    // Redis storage is not supported with .mjs files.
-    var RD = require('./RedisAdapter').RedisAdapter;
     var prefix = validatePrefix(options.prefix);
     function InRedisStorageFactory(params) {
+        if (!RD)
+            throw new Error('The SDK Redis storage is unavailable. Make sure your runtime environment supports CommonJS (`require`) so the `ioredis` dependency can be imported.');
         var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
         var metadata = metadataBuilder(settings);
         var keys = new KeyBuilderSS(prefix, metadata);
@@ -27,7 +33,7 @@ export function InRedisStorage(options) {
         var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
         var impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
         var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
-        // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
+        // Subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
             if (impressionCountsCache)