@splitsoftware/splitio-commons 3.1.1-rc.0 → 3.1.1-rc.10

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -0,0 +1,191 @@
+import { __extends } from "tslib";
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
+import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+var SplitsCacheInLocal = /** @class */ (function (_super) {
+    __extends(SplitsCacheInLocal, _super);
+    function SplitsCacheInLocal(settings, keys, storage) {
+        var _this = _super.call(this) || this;
+        _this.keys = keys;
+        _this.log = settings.log;
+        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+        _this.storage = storage;
+        return _this;
+    }
+    SplitsCacheInLocal.prototype._decrementCount = function (key) {
+        var count = toNumber(this.storage.getItem(key)) - 1;
+        if (count > 0)
+            this.storage.setItem(key, count + '');
+        else
+            this.storage.removeItem(key);
+    };
+    SplitsCacheInLocal.prototype._decrementCounts = function (split) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            this._decrementCount(ttKey);
+            if (usesSegments(split)) {
+                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+                this._decrementCount(segmentsCountKey);
+            }
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+        }
+    };
+    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
+            if (usesSegments(split)) {
+                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
+            }
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+        }
+    };
+    /**
+     * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
+     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
+     */
+    SplitsCacheInLocal.prototype.clear = function () {
+        var _this = this;
+        // collect item keys
+        var len = this.storage.length;
+        var accum = [];
+        for (var cur = 0; cur < len; cur++) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isSplitsCacheKey(key))
+                accum.push(key);
+        }
+        // remove items
+        accum.forEach(function (key) {
+            _this.storage.removeItem(key);
+        });
+        this.hasSync = false;
+    };
+    SplitsCacheInLocal.prototype.addSplit = function (split) {
+        var name = split.name;
+        var splitKey = this.keys.buildSplitKey(name);
+        var splitFromStorage = this.storage.getItem(splitKey);
+        var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
+        if (previousSplit) {
+            this._decrementCounts(previousSplit);
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+        }
+        this.storage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this.addToFlagSets(split);
+        return true;
+    };
+    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+        var split = this.getSplit(name);
+        if (!split)
+            return false;
+        this.storage.removeItem(this.keys.buildSplitKey(name));
+        this._decrementCounts(split);
+        this.removeFromFlagSets(split.name, split.sets);
+        return true;
+    };
+    SplitsCacheInLocal.prototype.getSplit = function (name) {
+        var item = this.storage.getItem(this.keys.buildSplitKey(name));
+        return item && JSON.parse(item);
+    };
+    SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
+        try {
+            this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+            // update "last updated" timestamp with current time
+            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            this.hasSync = true;
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
+        }
+    };
+    SplitsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = this.storage.getItem(this.keys.buildSplitsTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return isNaNNumber(value) ? n : value;
+        }
+        return n;
+    };
+    SplitsCacheInLocal.prototype.getSplitNames = function () {
+        var len = this.storage.length;
+        var accum = [];
+        var cur = 0;
+        while (cur < len) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isSplitKey(key))
+                accum.push(this.keys.extractKey(key));
+            cur++;
+        }
+        return accum;
+    };
+    SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
+        var ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        return isFiniteNumber(ttCount) && ttCount > 0;
+    };
+    SplitsCacheInLocal.prototype.usesSegments = function () {
+        // If cache hasn't been synchronized with the cloud, assume we need them.
+        if (!this.hasSync)
+            return true;
+        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+        return isFiniteNumber(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
+            true;
+    };
+    SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return flagSets.map(function (flagSet) {
+            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
+            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+        });
+    };
+    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 flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            if (flagSetCache.has(featureFlag.name))
+                return;
+            flagSetCache.add(featureFlag.name);
+            _this.storage.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 flagSetFromStorage = this.storage.getItem(flagSetKey);
+        if (!flagSetFromStorage)
+            return;
+        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
+        flagSetCache.delete(featureFlagName);
+        if (flagSetCache.size === 0) {
+            this.storage.removeItem(flagSetKey);
+            return;
+        }
+        this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    };
+    return SplitsCacheInLocal;
+}(AbstractSplitsCacheSync));
+export { SplitsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -4,7 +4,7 @@ import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
-import { DefinitionsCacheInLocal } from './DefinitionsCacheInLocal';
+import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
@@ -41,24 +41,24 @@ export function InLocalStorage(options) {
             return InMemoryStorageCSFactory(params);
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
-        var definitions = new DefinitionsCacheInLocal(settings, keys, storage);
+        var splits = new SplitsCacheInLocal(settings, keys, storage);
         var rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
         var segments = new MySegmentsCacheInLocal(log, keys, storage);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
         var validateCachePromise;
         return {
-            definitions: definitions,
+            splits: splits,
             rbSegments: rbSegments,
             segments: segments,
             largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: new ImpressionCountsCacheInMemory(),
             events: new EventsCacheInMemory(eventsQueueSize),
-            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
+            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
                 if (!validateCachePromise) {
-                    validateCachePromise = validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments);
+                    validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
                 }
                 return validateCachePromise;
             },
@@ -71,7 +71,7 @@ export function InLocalStorage(options) {
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
-                    definitions: this.definitions,
+                    splits: this.splits,
                     rbSegments: this.rbSegments,
                     segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
                     largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),

package/esm/storages/inLocalStorage/validateCache.js

@@ -54,16 +54,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns Metadata object with `initialCacheLoad` (true if is fresh install, false if is ready from cache) and `lastUpdateTimestamp` (timestamp of last cache update or undefined)
  */
-export function validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments) {
+export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
-        var isThereCache = definitions.getChangeNumber() > -1;
+        var isThereCache = splits.getChangeNumber() > -1;
         // Get lastUpdateTimestamp from storage
         var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
         var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : undefined;
         var lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== undefined) ? lastUpdatedTimestamp : undefined;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            definitions.clear();
+            splits.clear();
             rbSegments.clear();
             segments.clear();
             largeSegments.clear();

package/esm/storages/inMemory/InMemoryStorage.js

@@ -1,4 +1,4 @@
-import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
+import { SplitsCacheInMemory } from './SplitsCacheInMemory';
 import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -14,17 +14,17 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  */
 export function InMemoryStorageFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
+    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new SegmentsCacheInMemory();
     var storage = {
-        definitions: definitions,
+        splits: splits,
         rbSegments: rbSegments,
         segments: segments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory(eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemory(),
         destroy: function () { }
     };

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -1,4 +1,4 @@
-import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
+import { SplitsCacheInMemory } from './SplitsCacheInMemory';
 import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -14,25 +14,25 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  */
 export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
+    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
-        definitions: definitions,
+        splits: splits,
         rbSegments: rbSegments,
         segments: segments,
         largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory(eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
-                definitions: this.definitions,
+                splits: this.splits,
                 rbSegments: this.rbSegments,
                 segments: new MySegmentsCacheInMemory(),
                 largeSegments: new MySegmentsCacheInMemory(),

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -1,5 +1,5 @@
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractDefinitionsCacheSync';
+import { usesSegments } from '../AbstractSplitsCacheSync';
 var RBSegmentsCacheInMemory = /** @class */ (function () {
     function RBSegmentsCacheInMemory() {
         this.cache = {};
@@ -14,7 +14,7 @@ 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;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.changeNumber = changeNumber;
         return updated;
     };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,6 +1,6 @@
 import { isIntegerNumber } from '../../utils/lang';
 /**
- * Default IDefinitionsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
 var SegmentsCacheInMemory = /** @class */ (function () {
     function SegmentsCacheInMemory() {

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -0,0 +1,118 @@
+import { __extends } from "tslib";
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
+import { isFiniteNumber } from '../../utils/lang';
+/**
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ */
+var SplitsCacheInMemory = /** @class */ (function (_super) {
+    __extends(SplitsCacheInMemory, _super);
+    function SplitsCacheInMemory(splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.splitsCache = {};
+        _this.ttCache = {};
+        _this.changeNumber = -1;
+        _this.segmentsCount = 0;
+        _this.flagSetsCache = {};
+        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    SplitsCacheInMemory.prototype.clear = function () {
+        this.splitsCache = {};
+        this.ttCache = {};
+        this.changeNumber = -1;
+        this.segmentsCount = 0;
+        this.flagSetsCache = {};
+    };
+    SplitsCacheInMemory.prototype.addSplit = function (split) {
+        var name = split.name;
+        var previousSplit = this.getSplit(name);
+        if (previousSplit) { // We had this Split already
+            var previousTtName = previousSplit.trafficTypeName;
+            this.ttCache[previousTtName]--;
+            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--;
+        }
+        // Store the Split.
+        this.splitsCache[name] = split;
+        // Update TT cache
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+        this.addToFlagSets(split);
+        // Add to segments count for the new version of the Split
+        if (usesSegments(split))
+            this.segmentsCount++;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.removeSplit = function (name) {
+        var split = this.getSplit(name);
+        if (!split)
+            return false;
+        // Delete the Split
+        delete this.splitsCache[name];
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName]--; // Update tt cache
+        if (!this.ttCache[ttName])
+            delete this.ttCache[ttName];
+        this.removeFromFlagSets(split.name, split.sets);
+        // Update the segments count.
+        if (usesSegments(split))
+            this.segmentsCount--;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.getSplit = function (name) {
+        return this.splitsCache[name] || null;
+    };
+    SplitsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
+        this.changeNumber = changeNumber;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.changeNumber;
+    };
+    SplitsCacheInMemory.prototype.getSplitNames = function () {
+        return Object.keys(this.splitsCache);
+    };
+    SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
+        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
+    };
+    SplitsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+    };
+    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new Set(); });
+    };
+    SplitsCacheInMemory.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;
+            if (!_this.flagSetsCache[featureFlagSet])
+                _this.flagSetsCache[featureFlagSet] = new Set([]);
+            _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
+        });
+    };
+    SplitsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
+        var _this = this;
+        if (!flagSets)
+            return;
+        flagSets.forEach(function (flagSet) {
+            _this.removeNames(flagSet, featureFlagName);
+        });
+    };
+    SplitsCacheInMemory.prototype.removeNames = function (flagSetName, featureFlagName) {
+        if (!this.flagSetsCache[flagSetName])
+            return;
+        this.flagSetsCache[flagSetName].delete(featureFlagName);
+        if (this.flagSetsCache[flagSetName].size === 0)
+            delete this.flagSetsCache[flagSetName];
+    };
+    return SplitsCacheInMemory;
+}(AbstractSplitsCacheSync));
+export { SplitsCacheInMemory };

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -15,12 +15,12 @@ var ACCEPTANCE_RANGE = 0.001;
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
 export function shouldRecordTelemetry(_a) {
-    var settings = _a.settings, disableTelemetry = _a.disableTelemetry;
-    return !disableTelemetry && settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
+    var settings = _a.settings;
+    return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(definitions, segments, largeSegments) {
-        this.definitions = definitions;
+    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+        this.splits = splits;
         this.segments = segments;
         this.largeSegments = largeSegments;
         this.name = 'telemetry stats';
@@ -56,7 +56,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             iQ: this.getImpressionStats(QUEUED),
             iDe: this.getImpressionStats(DEDUPED),
             iDr: this.getImpressionStats(DROPPED),
-            spC: this.definitions && this.definitions.getNames().length,
+            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,

package/esm/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -31,7 +31,7 @@ var RBSegmentsCacheInRedis = /** @class */ (function () {
                 return _this.redis.set(key, stringifiedNewRBSegment).then(function () { return true; });
             })),
             Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove);
+                var key = _this.keys.buildRBSegmentKey(toRemove.name);
                 return _this.redis.del(key).then(function (status) { return status === 1; });
             }))
         ]).then(function (_a) {

package/esm/storages/inRedis/RedisAdapter.js

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
 // Dynamically require ioredis to prevent strict TypeScript binding
-// and handle module export differences between v4 and v5.
+// and handle module export differences between v4 and later major versions.
 var RedisConstructor;
 try {
     var ioredisLib = require('ioredis');
@@ -8,7 +8,7 @@ try {
 }
 catch (e) {
     // If we reach here, the peer dependency is missing
-    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+    throw new Error('ioredis is missing. Please install ioredis v4, v5 or v6.');
 }
 import { merge, isString } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
@@ -28,13 +28,16 @@ var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
     lazyConnect: false,
-    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
-    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    // CRITICAL: v5 and v6 default this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 and v6 work like v4.
     slotsRefreshInterval: 5000,
+    // v6 defaults to RESP3 (`protocol: 3`). The SDK doesn't use any RESP3 feature,
+    // so we stick to RESP2 to keep the v4 and v5 behavior. Ignored by v4 and v5.
+    protocol: 2,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- * Refactored to use Composition instead of Inheritance to support both v4 and v5.
+ * Refactored to use Composition instead of Inheritance to support v4, v5 and v6.
  */
 var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {