@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBSegmentsCacheInMemory = void 0;
-var sets_1 = require("../../utils/lang/sets");
-var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
-var RBSegmentsCacheInMemory = /** @class */ (function () {
-    function RBSegmentsCacheInMemory() {
-        this.cache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-    }
-    RBSegmentsCacheInMemory.prototype.clear = function () {
-        this.cache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-    };
-    RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        this.changeNumber = changeNumber;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
-    };
-    RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
-        var name = rbSegment.name;
-        var previous = this.get(name);
-        if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
-            this.segmentsCount--;
-        this.cache[name] = rbSegment;
-        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-            this.segmentsCount++;
-        return true;
-    };
-    RBSegmentsCacheInMemory.prototype.remove = function (name) {
-        var rbSegment = this.get(name);
-        if (!rbSegment)
-            return false;
-        delete this.cache[name];
-        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
-            this.segmentsCount--;
-        return true;
-    };
-    RBSegmentsCacheInMemory.prototype.getNames = function () {
-        return Object.keys(this.cache);
-    };
-    RBSegmentsCacheInMemory.prototype.get = function (name) {
-        return this.cache[name] || null;
-    };
-    RBSegmentsCacheInMemory.prototype.contains = function (names) {
-        var namesArray = (0, sets_1.setToArray)(names);
-        var namesInStorage = this.getNames();
-        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
-    };
-    RBSegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.changeNumber;
-    };
-    RBSegmentsCacheInMemory.prototype.usesSegments = function () {
-        return this.segmentsCount > 0;
-    };
-    return RBSegmentsCacheInMemory;
-}());
-exports.RBSegmentsCacheInMemory = RBSegmentsCacheInMemory;

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SegmentsCacheInMemory = void 0;
-var lang_1 = require("../../utils/lang");
-/**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
- */
-var SegmentsCacheInMemory = /** @class */ (function () {
-    function SegmentsCacheInMemory() {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
-    }
-    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var keySet = this.segmentCache[name] || new Set();
-        addedKeys.forEach(function (k) { return keySet.add(k); });
-        removedKeys.forEach(function (k) { return keySet.delete(k); });
-        this.segmentCache[name] = keySet;
-        this.segmentChangeNumber[name] = changeNumber;
-        return addedKeys.length > 0 || removedKeys.length > 0;
-    };
-    SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
-        var segmentValues = this.segmentCache[name];
-        if (segmentValues) {
-            return segmentValues.has(key);
-        }
-        return false;
-    };
-    SegmentsCacheInMemory.prototype.clear = function () {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
-    };
-    SegmentsCacheInMemory.prototype._registerSegment = function (name) {
-        if (!this.segmentCache[name]) {
-            this.segmentCache[name] = new Set();
-        }
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.registerSegments = function (names) {
-        for (var i = 0; i < names.length; i++) {
-            this._registerSegment(names[i]);
-        }
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
-        return Object.keys(this.segmentCache);
-    };
-    SegmentsCacheInMemory.prototype.getKeysCount = function () {
-        var _this = this;
-        return Object.keys(this.segmentCache).reduce(function (acum, segmentName) {
-            return acum + _this.segmentCache[segmentName].size;
-        }, 0);
-    };
-    SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
-        var value = this.segmentChangeNumber[name];
-        return (0, lang_1.isIntegerNumber)(value) ? value : undefined;
-    };
-    // No-op. Not used in server-side
-    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
-    return SegmentsCacheInMemory;
-}());
-exports.SegmentsCacheInMemory = SegmentsCacheInMemory;

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SplitsCacheInMemory = void 0;
-var tslib_1 = require("tslib");
-var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
-var lang_1 = require("../../utils/lang");
-/**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- */
-var SplitsCacheInMemory = /** @class */ (function (_super) {
-    (0, tslib_1.__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 ((0, AbstractSplitsCacheSync_1.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 ((0, AbstractSplitsCacheSync_1.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 ((0, AbstractSplitsCacheSync_1.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 (0, lang_1.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_1.AbstractSplitsCacheSync));
-exports.SplitsCacheInMemory = SplitsCacheInMemory;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,207 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = exports.newBuckets = exports.MAX_LATENCY_BUCKET_COUNT = void 0;
-var constants_1 = require("../../utils/constants");
-var findLatencyIndex_1 = require("../findLatencyIndex");
-var MAX_STREAMING_EVENTS = 20;
-var MAX_TAGS = 10;
-exports.MAX_LATENCY_BUCKET_COUNT = 23;
-function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23
-    // Not using Array.fill for old browsers compatibility
-    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-}
-exports.newBuckets = newBuckets;
-var ACCEPTANCE_RANGE = 0.001;
-/**
- * Record telemetry if mode is not localhost.
- * All factory instances track telemetry on server-side, and 0.1% on client-side.
- */
-function shouldRecordTelemetry(_a) {
-    var settings = _a.settings;
-    return settings.mode !== constants_1.LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
-}
-exports.shouldRecordTelemetry = shouldRecordTelemetry;
-var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
-        this.splits = splits;
-        this.segments = segments;
-        this.largeSegments = largeSegments;
-        // isEmpty flag
-        this.e = true;
-        this.notReadyUsage = 0;
-        /** Usage stats */
-        this.impressionStats = [0, 0, 0];
-        this.eventStats = [0, 0];
-        this.lastSync = {};
-        this.httpErrors = {};
-        this.httpLatencies = {};
-        this.authRejections = 0;
-        this.tokenRefreshes = 0;
-        this.streamingEvents = [];
-        this.tags = [];
-        this.exceptions = {};
-        this.latencies = {};
-        this.updatesFromSSE = {};
-    }
-    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
-    TelemetryCacheInMemory.prototype.clear = function () { };
-    TelemetryCacheInMemory.prototype.pop = function () {
-        this.e = true;
-        return {
-            lS: this.getLastSynchronization(),
-            mL: this.popLatencies(),
-            mE: this.popExceptions(),
-            hE: this.popHttpErrors(),
-            hL: this.popHttpLatencies(),
-            tR: this.popTokenRefreshes(),
-            aR: this.popAuthRejections(),
-            iQ: this.getImpressionStats(constants_1.QUEUED),
-            iDe: this.getImpressionStats(constants_1.DEDUPED),
-            iDr: this.getImpressionStats(constants_1.DROPPED),
-            spC: this.splits && this.splits.getSplitNames().length,
-            seC: this.segments && this.segments.getRegisteredSegments().length,
-            skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
-            sL: this.getSessionLength(),
-            eQ: this.getEventStats(constants_1.QUEUED),
-            eD: this.getEventStats(constants_1.DROPPED),
-            sE: this.popStreamingEvents(),
-            t: this.popTags(),
-            ufs: this.popUpdatesFromSSE(),
-        };
-    };
-    TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
-        return this.timeUntilReady;
-    };
-    TelemetryCacheInMemory.prototype.recordTimeUntilReady = function (ms) {
-        this.timeUntilReady = ms;
-    };
-    TelemetryCacheInMemory.prototype.getTimeUntilReadyFromCache = function () {
-        return this.timeUntilReadyFromCache;
-    };
-    TelemetryCacheInMemory.prototype.recordTimeUntilReadyFromCache = function (ms) {
-        this.timeUntilReadyFromCache = ms;
-    };
-    TelemetryCacheInMemory.prototype.getNonReadyUsage = function () {
-        return this.notReadyUsage;
-    };
-    TelemetryCacheInMemory.prototype.recordNonReadyUsage = function () {
-        this.notReadyUsage++;
-    };
-    TelemetryCacheInMemory.prototype.getImpressionStats = function (type) {
-        return this.impressionStats[type];
-    };
-    TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
-        this.impressionStats[type] += count;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getEventStats = function (type) {
-        return this.eventStats[type];
-    };
-    TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
-        this.eventStats[type] += count;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
-        return this.lastSync;
-    };
-    TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
-        this.lastSync[resource] = timeMs;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popHttpErrors = function () {
-        var result = this.httpErrors;
-        this.httpErrors = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
-        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
-        statusErrors[status] = (statusErrors[status] || 0) + 1;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
-        var result = this.httpLatencies;
-        this.httpLatencies = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
-        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
-        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popAuthRejections = function () {
-        var result = this.authRejections;
-        this.authRejections = 0;
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
-        this.authRejections++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
-        var result = this.tokenRefreshes;
-        this.tokenRefreshes = 0;
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
-        this.tokenRefreshes++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
-        return this.streamingEvents.splice(0);
-    };
-    TelemetryCacheInMemory.prototype.recordStreamingEvents = function (streamingEvent) {
-        if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
-            this.streamingEvents.push(streamingEvent);
-        }
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popTags = function () {
-        return this.tags.splice(0);
-    };
-    TelemetryCacheInMemory.prototype.addTag = function (tag) {
-        if (this.tags.length < MAX_TAGS) {
-            this.tags.push(tag);
-        }
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.getSessionLength = function () {
-        return this.sessionLength;
-    };
-    TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
-        this.sessionLength = ms;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popExceptions = function () {
-        var result = this.exceptions;
-        this.exceptions = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordException = function (method) {
-        this.exceptions[method] = (this.exceptions[method] || 0) + 1;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popLatencies = function () {
-        var result = this.latencies;
-        this.latencies = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
-        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
-        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
-        this.e = false;
-    };
-    TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
-        var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
-        return result;
-    };
-    TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
-        this.e = false;
-    };
-    return TelemetryCacheInMemory;
-}());
-exports.TelemetryCacheInMemory = TelemetryCacheInMemory;

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniqueKeysCacheInMemory = exports.fromUniqueKeysCollector = void 0;
-var constants_1 = require("../inRedis/constants");
-var sets_1 = require("../../utils/lang/sets");
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-function fromUniqueKeysCollector(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var userKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: userKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-exports.fromUniqueKeysCollector = fromUniqueKeysCollector;
-var UniqueKeysCacheInMemory = /** @class */ (function () {
-    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-        this.maxStorage = uniqueKeysQueueSize;
-    }
-    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
-        this.onFullQueue = cb;
-    };
-    /**
-     * Store unique keys per feature.
-     */
-    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
-        if (!this.uniqueKeysTracker[featureName])
-            this.uniqueKeysTracker[featureName] = new Set();
-        var tracker = this.uniqueKeysTracker[featureName];
-        if (!tracker.has(userKey)) {
-            tracker.add(userKey);
-            this.uniqueTrackerSize++;
-        }
-        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
-            this.onFullQueue();
-        }
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    UniqueKeysCacheInMemory.prototype.clear = function () {
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    UniqueKeysCacheInMemory.prototype.pop = function () {
-        var data = this.uniqueKeysTracker;
-        this.clear();
-        return fromUniqueKeysCollector(data);
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
-        return Object.keys(this.uniqueKeysTracker).length === 0;
-    };
-    return UniqueKeysCacheInMemory;
-}());
-exports.UniqueKeysCacheInMemory = UniqueKeysCacheInMemory;

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniqueKeysCacheInMemoryCS = void 0;
-var constants_1 = require("../inRedis/constants");
-var sets_1 = require("../../utils/lang/sets");
-var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
-    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {
-        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-        this.maxStorage = uniqueKeysQueueSize;
-    }
-    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {
-        this.onFullQueue = cb;
-    };
-    /**
-     * Store unique keys per feature.
-     */
-    UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {
-        if (!this.uniqueKeysTracker[userKey])
-            this.uniqueKeysTracker[userKey] = new Set();
-        var tracker = this.uniqueKeysTracker[userKey];
-        if (!tracker.has(featureName)) {
-            tracker.add(featureName);
-            this.uniqueTrackerSize++;
-        }
-        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
-            this.onFullQueue();
-        }
-    };
-    /**
-     * Clear the data stored on the cache.
-     */
-    UniqueKeysCacheInMemoryCS.prototype.clear = function () {
-        this.uniqueTrackerSize = 0;
-        this.uniqueKeysTracker = {};
-    };
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    UniqueKeysCacheInMemoryCS.prototype.pop = function () {
-        var data = this.uniqueKeysTracker;
-        this.clear();
-        return this.fromUniqueKeysCollector(data);
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {
-        return Object.keys(this.uniqueKeysTracker).length === 0;
-    };
-    /**
-     * Converts `uniqueKeys` data from cache into request payload.
-     */
-    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
-        var payload = [];
-        var userKeys = Object.keys(uniqueKeys);
-        for (var k = 0; k < userKeys.length; k++) {
-            var userKey = userKeys[k];
-            var featureNames = (0, sets_1.setToArray)(uniqueKeys[userKey]);
-            var uniqueKeysPayload = {
-                k: userKey,
-                fs: featureNames
-            };
-            payload.push(uniqueKeysPayload);
-        }
-        return { keys: payload };
-    };
-    return UniqueKeysCacheInMemoryCS;
-}());
-exports.UniqueKeysCacheInMemoryCS = UniqueKeysCacheInMemoryCS;

package/cjs/storages/inRedis/EventsCacheInRedis.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventsCacheInRedis = void 0;
-var constants_1 = require("./constants");
-var EventsCacheInRedis = /** @class */ (function () {
-    function EventsCacheInRedis(log, key, redis, metadata) {
-        this.log = log;
-        this.key = key;
-        this.redis = redis;
-        this.metadata = metadata;
-    }
-    /**
-     * Add a new event object into the queue.
-     * Unlike `impressions::track`, result promise is never rejected.
-     */
-    EventsCacheInRedis.prototype.track = function (eventData) {
-        var _this = this;
-        return this.redis.rpush(this.key, this._toJSON(eventData))
-            // We use boolean values to signal successful queueing
-            .then(function () { return true; })
-            .catch(function (err) {
-            _this.log.error(constants_1.LOG_PREFIX + "Error adding event to queue: " + err + ".");
-            return false;
-        });
-    };
-    /**
-     * Generates the JSON as we'll store it on Redis.
-     */
-    EventsCacheInRedis.prototype._toJSON = function (eventData) {
-        return JSON.stringify({
-            m: this.metadata,
-            e: eventData
-        });
-    };
-    EventsCacheInRedis.prototype.count = function () {
-        return this.redis.llen(this.key).catch(function () { return 0; });
-    };
-    EventsCacheInRedis.prototype.drop = function (count) {
-        if (!count)
-            return this.redis.del(this.key);
-        return this.redis.ltrim(this.key, count, -1);
-    };
-    /**
-     * Pop the given number of events from the storage.
-     * The returned promise rejects if the redis operation fails.
-     *
-     * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
-     * It is the submitter responsability to handle that.
-     */
-    EventsCacheInRedis.prototype.popNWithMetadata = function (count) {
-        var _this = this;
-        return this.redis.lrange(this.key, 0, count - 1).then(function (items) {
-            return _this.redis.ltrim(_this.key, items.length, -1).then(function () {
-                return items.map(function (item) { return JSON.parse(item); });
-            });
-        });
-    };
-    return EventsCacheInRedis;
-}());
-exports.EventsCacheInRedis = EventsCacheInRedis;