@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.1

package/esm/storages/inRedis/{SplitsCacheInRedis.js → DefinitionsCacheInRedis.js}

@@ -1,7 +1,7 @@
 import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
 import { returnDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
@@ -14,17 +14,17 @@ function processPipelineAnswer(results) {
     }, []) : [];
 }
 /**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
+ * IDefinitionsCacheAsync implementation that stores definitions in Redis.
  * Supported by Node.js
  */
-var SplitsCacheInRedis = /** @class */ (function (_super) {
-    __extends(SplitsCacheInRedis, _super);
-    function SplitsCacheInRedis(log, keys, redis, splitFiltersValidation) {
+var DefinitionsCacheInRedis = /** @class */ (function (_super) {
+    __extends(DefinitionsCacheInRedis, _super);
+    function DefinitionsCacheInRedis(log, keys, redis, splitFiltersValidation) {
         var _this = _super.call(this) || this;
         _this.log = log;
         _this.redis = redis;
         _this.keys = keys;
-        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
         // But it is done just to avoid getting the ioredis message `Unhandled error event`.
         _this.redis.on('error', function (e) {
@@ -35,104 +35,104 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         });
         return _this;
     }
-    SplitsCacheInRedis.prototype._decrementCounts = function (split) {
+    DefinitionsCacheInRedis.prototype._decrementCounts = function (definition) {
         var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
         return this.redis.decr(ttKey).then(function (count) {
             if (count === 0)
                 return _this.redis.del(ttKey);
         });
     };
-    SplitsCacheInRedis.prototype._incrementCounts = function (split) {
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    DefinitionsCacheInRedis.prototype._incrementCounts = function (definition) {
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
         return this.redis.incr(ttKey);
     };
-    SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
+    DefinitionsCacheInRedis.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
         var _this = this;
-        var removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-        if (this.flagSetsFilter.length > 0) {
-            addToFlagSets = addToFlagSets.filter(function (flagSet) {
-                return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });
+        var removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+        var addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+        if (this.setsFilter.length > 0) {
+            addToSets = addToSets.filter(function (set) {
+                return _this.setsFilter.some(function (filterSet) { return filterSet === set; });
             });
         }
-        var items = [featureFlagName];
-        return Promise.all(__spreadArray(__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.redis.srem(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.redis.sadd(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
+        var items = [definitionName];
+        return Promise.all(__spreadArray(__spreadArray([], removeFromSets.map(function (setName) { return _this.redis.srem(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.redis.sadd(_this.keys.buildSetKey(setName), items); }), true));
     };
     /**
-     * Add a given split.
+     * Add a given definition.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    SplitsCacheInRedis.prototype.addSplit = function (split) {
+    DefinitionsCacheInRedis.prototype.add = function (definition) {
         var _this = this;
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        return this.redis.get(splitKey).then(function (splitFromStorage) {
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        return this.redis.get(definitionKey).then(function (definitionFromStorage) {
             // handling parsing error
-            var parsedPreviousSplit, stringifiedNewSplit;
+            var parsedPreviousDefinition, stringifiedNewDefinition;
             try {
-                parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                stringifiedNewSplit = JSON.stringify(split);
+                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                stringifiedNewDefinition = JSON.stringify(definition);
             }
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return _this.redis.set(splitKey, stringifiedNewSplit).then(function () {
+            return _this.redis.set(definitionKey, stringifiedNewDefinition).then(function () {
                 // avoid unnecessary increment/decrement operations
-                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
+                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
                     return;
                 // update traffic type counts
-                return _this._incrementCounts(split).then(function () {
-                    if (parsedPreviousSplit)
-                        return _this._decrementCounts(parsedPreviousSplit);
+                return _this._incrementCounts(definition).then(function () {
+                    if (parsedPreviousDefinition)
+                        return _this._decrementCounts(parsedPreviousDefinition);
                 });
-            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
         }).then(function () { return true; });
     };
     /**
-     * Remove a given split.
-     * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
+     * Remove a given definition.
+     * The returned promise is resolved when the operation success, with true or false indicating if the definition existed (and was removed) or not.
      * or rejected if it fails (e.g., redis operation fails).
      */
-    SplitsCacheInRedis.prototype.removeSplit = function (name) {
+    DefinitionsCacheInRedis.prototype.remove = function (name) {
         var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split) {
-                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
+        return this.get(name).then(function (definition) {
+            if (definition) {
+                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
             }
         }).then(function () {
-            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
+            return _this.redis.del(_this.keys.buildDefinitionKey(name)).then(function (status) { return status === 1; });
         });
     };
     /**
-     * Get split definition or null if it's not defined.
+     * Get definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    SplitsCacheInRedis.prototype.getSplit = function (name) {
+    DefinitionsCacheInRedis.prototype.get = function (name) {
         if (this.redisError) {
             this.log.error(LOG_PREFIX + this.redisError);
             return Promise.reject(this.redisError);
         }
-        return this.redis.get(this.keys.buildSplitKey(name))
-            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
+        return this.redis.get(this.keys.buildDefinitionKey(name))
+            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
     };
     /**
      * Set till number.
      * The returned promise is resolved when the operation success,
      * or rejected if it fails.
      */
-    SplitsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+    DefinitionsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
+        return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
     };
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a redis operation fails.
      * The promise will never be rejected.
      */
-    SplitsCacheInRedis.prototype.getChangeNumber = function () {
+    DefinitionsCacheInRedis.prototype.getChangeNumber = function () {
         var _this = this;
-        return this.redis.get(this.keys.buildSplitsTillKey()).then(function (value) {
+        return this.redis.get(this.keys.buildDefinitionsTillKey()).then(function (value) {
             var i = parseInt(value, 10);
             return isNaNNumber(i) ? -1 : i;
         }).catch(function (e) {
@@ -141,44 +141,44 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         });
     };
     /**
-     * Get list of all split definitions.
-     * The returned promise is resolved with the list of split definitions,
+     * Get list of all definitions.
+     * The returned promise is resolved with the list of definitions,
      * or rejected if redis operation fails.
      */
     // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
-    SplitsCacheInRedis.prototype.getAll = function () {
+    DefinitionsCacheInRedis.prototype.getAll = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys())
+        return this.redis.keys(this.keys.searchPatternForDefinitionKeys())
             .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
             .then(processPipelineAnswer)
-            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
-            return JSON.parse(splitDefinition);
+            .then(function (definitions) { return definitions.map(function (definition) {
+            return JSON.parse(definition);
         }); });
     };
     /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
+     * Get list of definition names.
+     * The returned promise is resolved with the list of names,
      * or rejected if redis operation fails.
      */
-    SplitsCacheInRedis.prototype.getSplitNames = function () {
+    DefinitionsCacheInRedis.prototype.getNames = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+        return this.redis.keys(this.keys.searchPatternForDefinitionKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of feature flag names related to a given list of flag set names.
-     * The returned promise is resolved with the list of feature flag names per flag set,
+     * Get list of definition names related to a given list of set names.
+     * The returned promise is resolved with the list of names per set,
      * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
-    SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
+    DefinitionsCacheInRedis.prototype.getNamesBySets = function (sets) {
         var _this = this;
-        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
+        return this.redis.pipeline(sets.map(function (set) { return ['smembers', _this.keys.buildSetKey(set)]; })).exec()
             .then(function (results) { return results ? results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
                 return value;
-            _this.log.error(LOG_PREFIX + "Could not read result from get members of flag set ".concat(flagSets[index], " due to an error: ").concat(e));
+            _this.log.error(LOG_PREFIX + "Could not read result from get members of set ".concat(sets[index], " due to an error: ").concat(e));
         }) : []; })
-            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
+            .then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
     };
     /**
      * Check traffic type existence.
@@ -186,7 +186,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
      * It will never be rejected.
      */
-    SplitsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
+    DefinitionsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
         var _this = this;
         // If there is a number there should be > 0, otherwise the TT is considered as not existent.
         return this.redis.get(this.keys.buildTrafficTypeKey(trafficType))
@@ -207,34 +207,34 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         });
     };
     // @TODO remove or implement. It is not being used.
-    SplitsCacheInRedis.prototype.clear = function () {
+    DefinitionsCacheInRedis.prototype.clear = function () {
         return Promise.resolve();
     };
     /**
-     * Fetches multiple splits definitions.
+     * Fetches multiple definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    SplitsCacheInRedis.prototype.getSplits = function (names) {
+    DefinitionsCacheInRedis.prototype.getMany = function (names) {
         var _a;
         var _this = this;
         if (this.redisError) {
             this.log.error(LOG_PREFIX + this.redisError);
             return Promise.reject(this.redisError);
         }
-        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
-        return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
-            var splits = {};
+        var keys = names.map(function (name) { return _this.keys.buildDefinitionKey(name); });
+        return (_a = this.redis).mget.apply(_a, keys).then(function (stringifiedDefinitions) {
+            var definitions = {};
             names.forEach(function (name, idx) {
-                var split = splitDefinitions[idx];
-                splits[name] = split && JSON.parse(split);
+                var definition = stringifiedDefinitions[idx];
+                definitions[name] = definition && JSON.parse(definition);
             });
-            return Promise.resolve(splits);
+            return Promise.resolve(definitions);
         })
             .catch(function (e) {
             _this.log.error(LOG_PREFIX + "Could not grab feature flags due to an error: ".concat(e, "."));
             return Promise.reject(e);
         });
     };
-    return SplitsCacheInRedis;
-}(AbstractSplitsCacheAsync));
-export { SplitsCacheInRedis };
+    return DefinitionsCacheInRedis;
+}(AbstractDefinitionsCacheAsync));
+export { DefinitionsCacheInRedis };

package/esm/storages/inRedis/index.js

@@ -1,6 +1,6 @@
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCacheInRedis } from './SplitsCacheInRedis';
+import { DefinitionsCacheInRedis } from './DefinitionsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
@@ -45,7 +45,7 @@ export function InRedisStorage(options) {
             telemetry.recordConfig();
         });
         return {
-            splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),

package/esm/storages/pluggable/DefinitionsCachePluggable.js

@@ -0,0 +1,209 @@
+import { __extends, __spreadArray } from "tslib";
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { LOG_PREFIX } from './constants';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
+import { returnDifference } from '../../utils/lang/sets';
+/**
+ * IDefinitionsCacheAsync implementation for pluggable storages.
+ */
+var DefinitionsCachePluggable = /** @class */ (function (_super) {
+    __extends(DefinitionsCachePluggable, _super);
+    /**
+     * Create a DefinitionsCache that uses a storage wrapper.
+     * @param log -  Logger instance.
+     * @param keys -  Key builder.
+     * @param wrapper -  Adapted wrapper storage.
+     */
+    function DefinitionsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.log = log;
+        _this.keys = keys;
+        _this.wrapper = wrapper;
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    DefinitionsCachePluggable.prototype._decrementCounts = function (definition) {
+        var _this = this;
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.wrapper.del(ttKey);
+        });
+    };
+    DefinitionsCachePluggable.prototype._incrementCounts = function (definition) {
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.incr(ttKey);
+    };
+    DefinitionsCachePluggable.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
+        var _this = this;
+        var removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+        var addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+        if (this.setsFilter.length > 0) {
+            addToSets = addToSets.filter(function (set) {
+                return _this.setsFilter.some(function (filterSet) { return filterSet === set; });
+            });
+        }
+        var items = [definitionName];
+        return Promise.all(__spreadArray(__spreadArray([], removeFromSets.map(function (setName) { return _this.wrapper.removeItems(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.wrapper.addItems(_this.keys.buildSetKey(setName), items); }), true));
+    };
+    /**
+     * Add a given definition.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., wrapper operation fails)
+     */
+    DefinitionsCachePluggable.prototype.add = function (definition) {
+        var _this = this;
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        return this.wrapper.get(definitionKey).then(function (definitionFromStorage) {
+            // handling parsing error
+            var parsedPreviousDefinition, stringifiedNewDefinition;
+            try {
+                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                stringifiedNewDefinition = JSON.stringify(definition);
+            }
+            catch (e) {
+                throw new Error('Error parsing feature flag definition: ' + e);
+            }
+            return _this.wrapper.set(definitionKey, stringifiedNewDefinition).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(definition).then(function () {
+                    if (parsedPreviousDefinition)
+                        return _this._decrementCounts(parsedPreviousDefinition);
+                });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
+        }).then(function () { return true; });
+    };
+    /**
+     * Remove a given definition.
+     * The returned promise is resolved when the operation success, with a boolean indicating if the definition existed or not.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.remove = function (name) {
+        var _this = this;
+        return this.get(name).then(function (definition) {
+            if (definition) {
+                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
+            }
+        }).then(function () {
+            return _this.wrapper.del(_this.keys.buildDefinitionKey(name));
+        });
+    };
+    /**
+     * Get definition.
+     * The returned promise is resolved with the definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.get = function (name) {
+        return this.wrapper.get(this.keys.buildDefinitionKey(name))
+            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
+    };
+    /**
+     * Get list of definitions.
+     * The returned promise is resolved with a map of names to their definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getMany = function (names) {
+        var _this = this;
+        var keys = names.map(function (name) { return _this.keys.buildDefinitionKey(name); });
+        return this.wrapper.getMany(keys).then(function (stringifiedDefinitions) {
+            var definitions = {};
+            names.forEach(function (name, idx) {
+                var definition = stringifiedDefinitions[idx];
+                definitions[name] = definition && JSON.parse(definition);
+            });
+            return Promise.resolve(definitions);
+        });
+    };
+    /**
+     * Get list of all definitions.
+     * The returned promise is resolved with the list of definitions,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getAll = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (definitions) { return definitions.map(function (definition) {
+            return JSON.parse(definition);
+        }); });
+    };
+    /**
+     * Get list of definition names.
+     * The returned promise is resolved with the list of names,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getNames = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+    };
+    /**
+     * Get list of definition names related to a given list of set names.
+     * The returned promise is resolved with the list of names per set.
+     * It never rejects (If there is a wrapper error for some set, an empty set is returned for it).
+     */
+    DefinitionsCachePluggable.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return Promise.all(sets.map(function (set) {
+            var setKey = _this.keys.buildSetKey(set);
+            return _this.wrapper.getItems(setKey).catch(function () { return []; });
+        })).then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
+    };
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    DefinitionsCachePluggable.prototype.trafficTypeExists = function (trafficType) {
+        var _this = this;
+        // If there is a number there should be > 0, otherwise the TT is considered as not existent.
+        return this.wrapper.get(this.keys.buildTrafficTypeKey(trafficType))
+            .then(function (ttCount) {
+            if (ttCount === null)
+                return false; // if entry doesn't exist, means that TT doesn't exist
+            ttCount = parseInt(ttCount, 10);
+            if (!isFiniteNumber(ttCount) || ttCount < 0) {
+                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
+                return false;
+            }
+            return ttCount > 0;
+        }).catch(function (e) {
+            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
+            // If there is an error, bypass the validation so the event can get tracked.
+            return true;
+        });
+    };
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
+        return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+    };
+    /**
+     * Get till number or -1 if it's not defined.
+     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
+     * The promise will never be rejected.
+     */
+    DefinitionsCachePluggable.prototype.getChangeNumber = function () {
+        var _this = this;
+        return this.wrapper.get(this.keys.buildDefinitionsTillKey()).then(function (value) {
+            var i = parseInt(value, 10);
+            return isNaNNumber(i) ? -1 : i;
+        }).catch(function (e) {
+            _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+            return -1;
+        });
+    };
+    // @TODO implement if required by DataLoader or producer mode
+    DefinitionsCachePluggable.prototype.clear = function () {
+        return Promise.resolve(true);
+    };
+    return DefinitionsCachePluggable;
+}(AbstractDefinitionsCacheAsync));
+export { DefinitionsCachePluggable };

package/esm/storages/pluggable/index.js

@@ -1,6 +1,6 @@
 import { __assign } from "tslib";
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCachePluggable } from './SplitsCachePluggable';
+import { DefinitionsCachePluggable } from './DefinitionsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
 import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
@@ -103,7 +103,7 @@ export function PluggableStorage(options) {
             return e; // Propagate error for shared clients
         });
         return {
-            splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/esm/storages/setRolloutPlan.js

@@ -20,16 +20,16 @@ export function validateRolloutPlan(log, settings) {
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 export function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
     var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
     log.debug("storage: set feature flags and segments".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
-    if (splits && ff) {
-        splits.clear();
-        splits.update(ff.d, [], ff.t);
+    if (definitions && ff) {
+        definitions.clear();
+        definitions.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();
-        rbSegments.update(rbs.d, [], rbs.t);
+        rbSegments.update(rbs.d || [], [], rbs.t);
     }
     var segmentChanges = rolloutPlan.segmentChanges;
     if (matchingKey) { // add memberships data (client-side)

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

@@ -1,13 +1,13 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 export function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log, splitsCache = storage.splits;
+    var log = settings.log, definitions = storage.definitions;
     var startingUp = true;
     return function objectUpdater() {
         var splits = [];
@@ -36,16 +36,16 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 });
             });
             return Promise.all([
-                splitsCache.clear(),
-                splitsCache.update(splits, [], Date.now())
+                definitions.clear(),
+                definitions.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
+                readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
                     Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                         // Emits SDK_READY
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });

package/esm/sync/polling/fetchers/splitChangesFetcher.js

@@ -58,7 +58,7 @@ export function splitChangesFetcherFactory(params) {
                 lastProxyCheckTimestamp = undefined;
                 return splitChangesFetcher(-1, undefined, undefined, -1)
                     .then(function (splitChangesResponse) {
-                    return Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+                    return Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
                         .then(function () { return splitChangesResponse; });
                 });
             }

package/esm/sync/polling/pollingManagerCS.js

@@ -2,9 +2,9 @@ import { forOwn } from '../../utils/lang';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { getMatching } from '../../utils/key';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -29,7 +29,7 @@ export function pollingManagerCSFactory(params, definitionChangesFetcher) {
         });
     }
     // smart pausing
-    readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
+    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
         if (!definitionsSyncTask.isRunning())
             return; // noop if not doing polling
         var usingSegments = usesSegmentsSync(storage);
@@ -53,7 +53,7 @@ export function pollingManagerCSFactory(params, definitionChangesFetcher) {
         if (!usesSegmentsSync(storage))
             setTimeout(smartReady, 0);
         else
-            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+            readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
         mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
         return mySegmentsSyncTask;
     }