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

package/cjs/utils/inputValidation/splits.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplits = void 0;
-var constants_1 = require("../../logger/constants");
-var lang_1 = require("../lang");
-var split_1 = require("./split");
-function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = (0, split_1.validateSplit)(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return (0, lang_1.uniq)(validatedArray_1);
-    }
-    log.error(constants_1.ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}
-exports.validateSplits = validateSplits;

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,48 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheAsync = /** @class */ (function () {
-    function AbstractSplitsCacheAsync() {
-    }
-    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-                var newSplit = objectAssign({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-export { AbstractSplitsCacheAsync };

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,71 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheSync = /** @class */ (function () {
-    function AbstractSplitsCacheSync() {
-    }
-    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
-        this.setChangeNumber(changeNumber);
-        return updated;
-    };
-    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
-        var _this = this;
-        var splits = {};
-        names.forEach(function (name) {
-            splits[name] = _this.getSplit(name);
-        });
-        return splits;
-    };
-    AbstractSplitsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var split = this.getSplit(name);
-        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-            var newSplit = objectAssign({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-export { AbstractSplitsCacheSync };
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export function usesSegments(ruleEntity) {
-    var conditions = ruleEntity.conditions || [];
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-export function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -1,191 +0,0 @@
-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/inMemory/SplitsCacheInMemory.js

@@ -1,118 +0,0 @@
-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/pluggable/SplitsCachePluggable.js

@@ -1,209 +0,0 @@
-import { __extends, __spreadArray } from "tslib";
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { returnDifference } from '../../utils/lang/sets';
-/**
- * ISplitsCacheAsync implementation for pluggable storages.
- */
-var SplitsCachePluggable = /** @class */ (function (_super) {
-    __extends(SplitsCachePluggable, _super);
-    /**
-     * Create a SplitsCache that uses a storage wrapper.
-     * @param log -  Logger instance.
-     * @param keys -  Key builder.
-     * @param wrapper -  Adapted wrapper storage.
-     */
-    function SplitsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _this.log = log;
-        _this.keys = keys;
-        _this.wrapper = wrapper;
-        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-        return _this;
-    }
-    SplitsCachePluggable.prototype._decrementCounts = function (split) {
-        var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.wrapper.decr(ttKey).then(function (count) {
-            if (count === 0)
-                return _this.wrapper.del(ttKey);
-        });
-    };
-    SplitsCachePluggable.prototype._incrementCounts = function (split) {
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.wrapper.incr(ttKey);
-    };
-    SplitsCachePluggable.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
-        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 items = [featureFlagName];
-        return Promise.all(__spreadArray(__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.wrapper.removeItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.wrapper.addItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
-    };
-    /**
-     * Add a given split.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., wrapper operation fails)
-     */
-    SplitsCachePluggable.prototype.addSplit = function (split) {
-        var _this = this;
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        return this.wrapper.get(splitKey).then(function (splitFromStorage) {
-            // handling parsing error
-            var parsedPreviousSplit, stringifiedNewSplit;
-            try {
-                parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                stringifiedNewSplit = JSON.stringify(split);
-            }
-            catch (e) {
-                throw new Error('Error parsing feature flag definition: ' + e);
-            }
-            return _this.wrapper.set(splitKey, stringifiedNewSplit).then(function () {
-                // avoid unnecessary increment/decrement operations
-                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
-                    return;
-                // update traffic type counts
-                return _this._incrementCounts(split).then(function () {
-                    if (parsedPreviousSplit)
-                        return _this._decrementCounts(parsedPreviousSplit);
-                });
-            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
-        }).then(function () { return true; });
-    };
-    /**
-     * Remove a given split.
-     * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SplitsCachePluggable.prototype.removeSplit = 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); });
-            }
-        }).then(function () {
-            return _this.wrapper.del(_this.keys.buildSplitKey(name));
-        });
-    };
-    /**
-     * Get split.
-     * The returned promise is resolved with the split definition or null if it's not defined,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name))
-            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
-    };
-    /**
-     * Get list of splits.
-     * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplits = function (names) {
-        var _this = this;
-        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
-        return this.wrapper.getMany(keys).then(function (splitDefinitions) {
-            var splits = {};
-            names.forEach(function (name, idx) {
-                var split = splitDefinitions[idx];
-                splits[name] = split && JSON.parse(split);
-            });
-            return Promise.resolve(splits);
-        });
-    };
-    /**
-     * Get list of all split definitions.
-     * The returned promise is resolved with the list of split definitions,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getAll = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
-            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
-            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
-            return JSON.parse(splitDefinition);
-        }); });
-    };
-    /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplitNames = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).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.
-     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
-     */
-    SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return Promise.all(flagSets.map(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
-    };
-    /**
-     * 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.
-     */
-    SplitsCachePluggable.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).
-     */
-    SplitsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
-        return this.wrapper.set(this.keys.buildSplitsTillKey(), 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.
-     */
-    SplitsCachePluggable.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.wrapper.get(this.keys.buildSplitsTillKey()).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
-    SplitsCachePluggable.prototype.clear = function () {
-        return Promise.resolve(true);
-    };
-    return SplitsCachePluggable;
-}(AbstractSplitsCacheAsync));
-export { SplitsCachePluggable };

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -1,9 +0,0 @@
-import { syncTaskFactory } from '../../syncTask';
-import { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';
-import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
-/**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
- */
-export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges, settings, storage), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
-}