@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/storages/pluggable/ImpressionsCachePluggable.js

@@ -1,45 +0,0 @@
-import { impressionsToJSON } from '../utils';
-var ImpressionsCachePluggable = /** @class */ (function () {
-    function ImpressionsCachePluggable(log, key, wrapper, metadata) {
-        this.log = log;
-        this.key = key;
-        this.wrapper = wrapper;
-        this.metadata = metadata;
-    }
-    /**
-     * Push given impressions to the storage.
-     * @param impressions -  List of impresions to push.
-     * @returns  A promise that is resolved if the push operation succeeded
-     * or rejected if the wrapper operation fails.
-     */
-    ImpressionsCachePluggable.prototype.track = function (impressions) {
-        return this.wrapper.pushItems(this.key, impressionsToJSON(impressions, this.metadata));
-    };
-    /**
-     * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
-     * The promise will never be rejected.
-     */
-    ImpressionsCachePluggable.prototype.count = function () {
-        return this.wrapper.getItemsCount(this.key).catch(function () { return 0; });
-    };
-    /**
-     * Removes the given number of impressions from the store. If a number is not provided, it deletes all items.
-     * The returned promise rejects if the wrapper operation fails.
-     */
-    ImpressionsCachePluggable.prototype.drop = function (count) {
-        if (!count)
-            return this.wrapper.del(this.key);
-        return this.wrapper.popItems(this.key, count).then(function () { });
-    };
-    /**
-     * Pop the given number of impressions from the store.
-     * The returned promise rejects if the wrapper operation fails.
-     */
-    ImpressionsCachePluggable.prototype.popNWithMetadata = function (count) {
-        return this.wrapper.popItems(this.key, count).then(function (items) {
-            return items.map(function (item) { return JSON.parse(item); });
-        });
-    };
-    return ImpressionsCachePluggable;
-}());
-export { ImpressionsCachePluggable };

package/esm/storages/pluggable/RBSegmentsCachePluggable.js

@@ -1,61 +0,0 @@
-import { isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-var RBSegmentsCachePluggable = /** @class */ (function () {
-    function RBSegmentsCachePluggable(log, keys, wrapper) {
-        this.log = log;
-        this.keys = keys;
-        this.wrapper = wrapper;
-    }
-    RBSegmentsCachePluggable.prototype.get = function (name) {
-        return this.wrapper.get(this.keys.buildRBSegmentKey(name))
-            .then(function (maybeRBSegment) { return maybeRBSegment && JSON.parse(maybeRBSegment); });
-    };
-    RBSegmentsCachePluggable.prototype.getNames = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildRBSegmentKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
-    };
-    RBSegmentsCachePluggable.prototype.contains = function (names) {
-        var namesArray = setToArray(names);
-        return this.getNames().then(function (namesInStorage) {
-            return namesArray.every(function (name) { return namesInStorage.includes(name); });
-        });
-    };
-    RBSegmentsCachePluggable.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (toAdd) {
-                var key = _this.keys.buildRBSegmentKey(toAdd.name);
-                var stringifiedNewRBSegment = JSON.stringify(toAdd);
-                return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
-            })),
-            Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
-                return _this.wrapper.del(key);
-            }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    RBSegmentsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
-        return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-    };
-    RBSegmentsCachePluggable.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.wrapper.get(this.keys.buildRBSegmentsTillKey()).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
-    RBSegmentsCachePluggable.prototype.clear = function () {
-        return Promise.resolve();
-    };
-    return RBSegmentsCachePluggable;
-}());
-export { RBSegmentsCachePluggable };

package/esm/storages/pluggable/SegmentsCachePluggable.js

@@ -1,77 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-unused-vars */
-import { isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-/**
- * ISegmentsCacheAsync implementation for pluggable storages.
- */
-var SegmentsCachePluggable = /** @class */ (function () {
-    function SegmentsCachePluggable(log, keys, wrapper) {
-        this.log = log;
-        this.keys = keys;
-        this.wrapper = wrapper;
-    }
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        return Promise.all([
-            addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
-            removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
-            this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-        ]).then(function () {
-            return addedKeys.length > 0 || removedKeys.length > 0;
-        });
-    };
-    /**
-     * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
-     * Promise can be rejected if wrapper operation fails.
-     */
-    SegmentsCachePluggable.prototype.isInSegment = function (name, key) {
-        return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
-    };
-    /**
-     * 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.
-     */
-    SegmentsCachePluggable.prototype.getChangeNumber = function (name) {
-        var _this = this;
-        return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
-            var i = parseInt(value, 10);
-            return isNaNNumber(i) ? undefined : i;
-        }).catch(function (e) {
-            _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return undefined;
-        });
-    };
-    /**
-     * Add the given segment names to the set of registered segments.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.registerSegments = function (segments) {
-        if (segments.length) {
-            return this.wrapper.addItems(this.keys.buildRegisteredSegmentsKey(), segments);
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    /**
-     * Returns a promise that resolves with the set of registered segments in a list,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.getRegisteredSegments = function () {
-        return this.wrapper.getItems(this.keys.buildRegisteredSegmentsKey());
-    };
-    // @TODO implement if required by DataLoader or Producer mode
-    SegmentsCachePluggable.prototype.clear = function () {
-        return Promise.resolve(true);
-    };
-    return SegmentsCachePluggable;
-}());
-export { SegmentsCachePluggable };

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 " + 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 " + trafficType + " due to an error: " + 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/storages/pluggable/TelemetryCachePluggable.js

@@ -1,138 +0,0 @@
-import { findLatencyIndex } from '../findLatencyIndex';
-import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
-import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
-import { isString, isNaNNumber } from '../../utils/lang';
-import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
-import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
-var TelemetryCachePluggable = /** @class */ (function () {
-    /**
-     * Create a Telemetry cache that uses a storage wrapper.
-     * @param log -  Logger instance.
-     * @param keys -  Key builder.
-     * @param wrapper -  Adapted wrapper storage.
-     */
-    function TelemetryCachePluggable(log, keys, wrapper) {
-        this.log = log;
-        this.keys = keys;
-        this.wrapper = wrapper;
-    }
-    TelemetryCachePluggable.prototype.recordLatency = function (method, latencyMs) {
-        return this.wrapper.incr(this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)))
-            .catch(function () { });
-    };
-    TelemetryCachePluggable.prototype.recordException = function (method) {
-        return this.wrapper.incr(this.keys.buildExceptionKey(method))
-            .catch(function () { });
-    };
-    TelemetryCachePluggable.prototype.recordConfig = function () {
-        var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_PLUGGABLE));
-        return this.wrapper.set(this.keys.buildInitKey(), value).catch(function () { });
-    };
-    /**
-     * Pop telemetry latencies.
-     * The returned promise rejects if wrapper operations fail.
-     */
-    TelemetryCachePluggable.prototype.popLatencies = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
-            return latencyKeys.length ?
-                _this.wrapper.getMany(latencyKeys).then(function (latencies) {
-                    var result = new Map();
-                    for (var i = 0; i < latencyKeys.length; i++) {
-                        var field = latencyKeys[i].split('::')[1];
-                        var parsedField = parseLatencyField(field);
-                        if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
-                            continue;
-                        }
-                        // @ts-ignore
-                        var count = parseInt(latencies[i]);
-                        if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
-                            continue;
-                        }
-                        var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
-                        if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
-                            continue;
-                        }
-                        var methodLatencies = result.get(metadata) || {};
-                        methodLatencies[method] = methodLatencies[method] || newBuckets();
-                        methodLatencies[method][bucket] = count;
-                        result.set(metadata, methodLatencies);
-                    }
-                    return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
-                }) :
-                // If latencyKeys is empty, return an empty map.
-                new Map();
-        });
-    };
-    /**
-     * Pop telemetry exceptions.
-     * The returned promise rejects if wrapper operations fail.
-     */
-    TelemetryCachePluggable.prototype.popExceptions = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
-            return exceptionKeys.length ?
-                _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
-                    var result = new Map();
-                    for (var i = 0; i < exceptionKeys.length; i++) {
-                        var field = exceptionKeys[i].split('::')[1];
-                        var parsedField = parseExceptionField(field);
-                        if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
-                            continue;
-                        }
-                        // @ts-ignore
-                        var count = parseInt(exceptions[i]);
-                        if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
-                            continue;
-                        }
-                        var metadata = parsedField[0], method = parsedField[1];
-                        if (!result.has(metadata))
-                            result.set(metadata, {});
-                        result.get(metadata)[method] = count;
-                    }
-                    return Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
-                }) :
-                // If exceptionKeys is empty, return an empty map.
-                new Map();
-        });
-    };
-    /**
-     * Pop telemetry configs.
-     * The returned promise rejects if wrapper operations fail.
-     */
-    TelemetryCachePluggable.prototype.popConfigs = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
-            return configKeys.length ?
-                _this.wrapper.getMany(configKeys).then(function (configs) {
-                    var result = new Map();
-                    for (var i = 0; i < configKeys.length; i++) {
-                        var field = configKeys[i].split('::')[1];
-                        var parsedField = parseMetadata(field);
-                        if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
-                            continue;
-                        }
-                        var metadata = parsedField[0];
-                        try { // @ts-ignore
-                            var config = JSON.parse(configs[i]);
-                            result.set(metadata, config);
-                        }
-                        catch (e) {
-                            _this.log.error("Ignoring invalid config: " + configs[i]);
-                        }
-                    }
-                    return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
-                }) :
-                // If configKeys is empty, return an empty map.
-                new Map();
-        });
-    };
-    return TelemetryCachePluggable;
-}());
-export { TelemetryCachePluggable };

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -1,59 +0,0 @@
-import { __extends } from "tslib";
-import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-var UniqueKeysCachePluggable = /** @class */ (function (_super) {
-    __extends(UniqueKeysCachePluggable, _super);
-    function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
-        if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
-        var _this = _super.call(this, uniqueKeysQueueSize) || this;
-        _this.log = log;
-        _this.key = key;
-        _this.wrapper = wrapper;
-        _this.refreshRate = refreshRate;
-        _this.onFullQueue = function () { _this.storeUniqueKeys(); };
-        return _this;
-    }
-    UniqueKeysCachePluggable.prototype.storeUniqueKeys = function () {
-        var _this = this;
-        var featureNames = Object.keys(this.uniqueKeysTracker);
-        if (!featureNames.length)
-            return Promise.resolve(false);
-        var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
-            var uniqueKeysPayload = {
-                f: featureName,
-                ks: featureKeys
-            };
-            return JSON.stringify(uniqueKeysPayload);
-        });
-        this.clear();
-        return this.wrapper.pushItems(this.key, uniqueKeysArray)
-            .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
-            return false;
-        });
-    };
-    UniqueKeysCachePluggable.prototype.start = function () {
-        this.intervalId = setInterval(this.storeUniqueKeys.bind(this), this.refreshRate);
-    };
-    UniqueKeysCachePluggable.prototype.stop = function () {
-        clearInterval(this.intervalId);
-        return this.storeUniqueKeys();
-    };
-    /**
-     * Async consumer API, used by synchronizer.
-     * @param count - number of items to pop from the queue. If not provided or equal 0, all items will be popped.
-     */
-    UniqueKeysCachePluggable.prototype.popNRaw = function (count) {
-        var _this = this;
-        if (count === void 0) { count = 0; }
-        return Promise.resolve(count || this.wrapper.getItemsCount(this.key))
-            .then(function (count) { return _this.wrapper.popItems(_this.key, count); })
-            .then(function (uniqueKeyItems) { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
-    };
-    return UniqueKeysCachePluggable;
-}(UniqueKeysCacheInMemory));
-export { UniqueKeysCachePluggable };

package/esm/storages/pluggable/constants.js

@@ -1 +0,0 @@
-export var LOG_PREFIX = 'storage:pluggable: ';