@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.11

package/esm/storages/pluggable/index.js

@@ -7,10 +7,16 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { validatePrefix } from '../KeyBuilder';
-import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { TelemetryCachePluggable } from './TelemetryCachePluggable';
+import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable';
+import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**
@@ -27,15 +33,6 @@ function validatePluggableStorageOptions(options) {
     if (missingMethods.length)
         throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
 }
-// subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper, onReadyCb) {
-    wrapper.connect().then(function () {
-        onReadyCb();
-        // At the moment, we don't synchronize config with pluggable storage
-    }).catch(function (e) {
-        onReadyCb(e || new Error('Error connecting wrapper'));
-    });
-}
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
 function promisifyEventsTrack(events) {
@@ -51,28 +48,60 @@ function promisifyEventsTrack(events) {
 export function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = validatePrefix(options.prefix);
-    function PluggableStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, impressionsQueueSize = _a.impressionsQueueSize, optimize = _a.optimize;
+    function PluggableStorageFactory(params) {
+        var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, impressionsMode = params.impressionsMode, matchingKey = params.matchingKey;
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
+        var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
+        var telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
+            isPartialConsumer ?
+                new TelemetryCacheInMemory() :
+                new TelemetryCachePluggable(log, keys, wrapper) :
+            undefined;
+        var impressionCountsCache = impressionsMode !== DEBUG || isSyncronizer ?
+            isPartialConsumer ?
+                new ImpressionCountsCacheInMemory() :
+                new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+            undefined;
+        var uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
+            isPartialConsumer ?
+                matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+                new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
-        wrapperConnect(wrapper, onReadyCb);
+        var connectPromise = wrapper.connect().then(function () {
+            onReadyCb();
+            // Start periodic flush of async storages
+            if (impressionCountsCache && impressionCountsCache.start)
+                impressionCountsCache.start();
+            if (uniqueKeysCache && uniqueKeysCache.start)
+                uniqueKeysCache.start();
+            if (telemetry && telemetry.recordConfig && !isSyncronizer)
+                telemetry.recordConfig();
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e;
+        });
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-            impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
+            impressionCounts: impressionCountsCache,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
-            // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
+            telemetry: telemetry,
+            uniqueKeys: uniqueKeysCache,
             // Disconnect the underlying storage
             destroy: function () {
-                return wrapper.disconnect();
+                return Promise.all([
+                    impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
+                    uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
+                ]).then(function () { return wrapper.disconnect(); });
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                wrapperConnect(wrapper, onReadyCb);
+                connectPromise.then(onReadyCb);
                 return __assign(__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

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

@@ -24,8 +24,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
             log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             forOwn(splitsMock, function (val, name) {
                 splits.push([
-                    name,
-                    JSON.stringify({
+                    name, {
                         name: name,
                         status: 'ACTIVE',
                         killed: false,
@@ -34,7 +33,7 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                         conditions: val.conditions || [],
                         configurations: val.configurations,
                         trafficTypeName: val.trafficTypeName
-                    })
+                    }
                 ]);
             });
             return Promise.all([

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -37,7 +37,7 @@ export function computeSplitsMutation(entries) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE') {
-            accum.added.push([split.name, JSON.stringify(split)]);
+            accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,11 +1,12 @@
 var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { objectAssign } from '../../utils/lang/objectAssign';
+import { isStorageSync } from '../../trackers/impressionObserver/utils';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -26,9 +27,9 @@ export function telemetryCacheStatsAdapter(telemetry, splits, segments) {
                 iQ: telemetry.getImpressionStats(QUEUED),
                 iDe: telemetry.getImpressionStats(DEDUPED),
                 iDr: telemetry.getImpressionStats(DROPPED),
-                spC: splits.getSplitNames().length,
-                seC: segments.getRegisteredSegments().length,
-                skC: segments.getKeysCount(),
+                spC: splits && splits.getSplitNames().length,
+                seC: segments && segments.getRegisteredSegments().length,
+                skC: segments && segments.getKeysCount(),
                 sL: telemetry.getSessionLength(),
                 eQ: telemetry.getEventStats(QUEUED),
                 eD: telemetry.getEventStats(DROPPED),
@@ -46,6 +47,7 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
+    _b[NONE] = NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[CONSENT_UNKNOWN] = 1,
@@ -119,7 +121,9 @@ export function telemetrySubmitterFactory(params) {
         return; // No submitter created if telemetry cache is not defined
     var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, 
+    // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
+    isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -1,64 +1,23 @@
-import { setToArray } from '../../utils/lang/sets';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { submitterFactory } from './submitter';
-/**
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys) {
-    var featureNames = Object.keys(uniqueKeys);
-    var inverted = {};
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        for (var j = 0; j < featureKeys.length; j++) {
-            var featureKey = featureKeys[j];
-            if (!inverted[featureKey])
-                inverted[featureKey] = [];
-            inverted[featureKey].push(featureName);
-        }
-    }
-    return inverted;
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-export function fromUniqueKeysCollectorCs(uniqueKeys) {
-    var payload = [];
-    var featuresPerKey = invertUniqueKeys(uniqueKeys);
-    var keys = Object.keys(featuresPerKey);
-    for (var k = 0; k < keys.length; k++) {
-        var key = keys[k];
-        var uniqueKeysPayload = {
-            k: key,
-            fs: featuresPerKey[key]
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export function fromUniqueKeysCollectorSs(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: featureKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
+var DATA_NAME = 'unique keys';
+var UNIQUE_KEYS_RATE = 900000; // 15 minutes
 /**
  * Submitter that periodically posts impression counts
  */
 export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
-    return submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
+    // register unique keys submitter to be executed when uniqueKeys cache is full
+    uniqueKeys.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }

package/esm/trackers/impressionsTracker.js

@@ -20,21 +20,23 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
             var impressionsCount = impressions.length;
             var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
             var impressionsToListenerCount = impressionsToListener.length;
-            var res = impressionsCache.track(impressionsToStore);
-            // If we're on an async storage, handle error and log it.
-            if (thenable(res)) {
-                res.then(function () {
-                    log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                }).catch(function (err) {
-                    log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                });
-            }
-            else {
-                // Record when impressionsCache is sync only (standalone mode)
-                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                if (telemetryCache) {
-                    telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(DEDUPED, deduped);
+            if (impressionsToStore.length > 0) {
+                var res = impressionsCache.track(impressionsToStore);
+                // If we're on an async storage, handle error and log it.
+                if (thenable(res)) {
+                    res.then(function () {
+                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                    }).catch(function (err) {
+                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                    });
+                }
+                else {
+                    // Record when impressionsCache is sync only (standalone mode)
+                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                    if (telemetryCache) {
+                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(DEDUPED, deduped);
+                    }
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor

package/esm/trackers/strategy/strategyNone.js

@@ -13,7 +13,7 @@ export function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
                 // Increments impression counter per featureName
                 impressionsCounter.track(impression.feature, now, 1);
                 // Keep track by unique key
-                uniqueKeysTracker.track(impression.feature, impression.keyName);
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
             });
             return {
                 impressionsToStore: [],

package/esm/trackers/strategy/strategyOptimized.js

@@ -14,7 +14,8 @@ export function strategyOptimizedFactory(impressionsObserver, impressionsCounter
                 impression.pt = impressionsObserver.testAndSet(impression);
                 var now = Date.now();
                 // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
+                if (impression.pt)
+                    impressionsCounter.track(impression.feature, now, 1);
                 // Checks if the impression should be added in queue to be sent
                 if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
                     impressionsToStore.push(impression);

package/esm/trackers/telemetryTracker.js

@@ -46,6 +46,11 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -56,6 +61,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }

package/esm/trackers/uniqueKeysTracker.js

@@ -1,65 +1,34 @@
 import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
-import { _Set } from '../utils/lang/sets';
 var noopFilterAdapter = {
     add: function () { return true; },
     contains: function () { return true; },
     clear: function () { }
 };
-var DEFAULT_CACHE_SIZE = 30000;
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
-export function uniqueKeysTrackerFactory(log, filterAdapter, cacheSize) {
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
-    if (cacheSize === void 0) { cacheSize = DEFAULT_CACHE_SIZE; }
-    var uniqueKeysTracker = {};
-    var uniqueTrackerSize = 0;
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
-        track: function (featureName, key) {
-            if (!filterAdapter.add(featureName, key)) {
+        track: function (key, featureName) {
+            if (!filterAdapter.add(key, featureName)) {
                 log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
                 return;
             }
-            if (!uniqueKeysTracker[featureName])
-                uniqueKeysTracker[featureName] = new _Set();
-            var tracker = uniqueKeysTracker[featureName];
-            if (!tracker.has(key)) {
-                tracker.add(key);
-                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "Key " + key + " added to feature " + featureName);
-                uniqueTrackerSize++;
-            }
-            if (uniqueTrackerSize >= cacheSize) {
-                log.warn(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The UniqueKeysTracker size reached the maximum limit");
-                // @TODO trigger event to submitter to send mtk
-                uniqueTrackerSize = 0;
-            }
-        },
-        /**
-         * Pop the collected data, used as payload for posting.
-         */
-        pop: function () {
-            var data = uniqueKeysTracker;
-            uniqueKeysTracker = {};
-            return data;
-        },
-        /**
-         * Clear the data stored on the cache.
-         */
-        clear: function () {
-            uniqueKeysTracker = {};
+            uniqueKeysCache.track(key, featureName);
         },
-        /**
-         * Check if the cache is empty.
-         */
-        isEmpty: function () {
-            return Object.keys(uniqueKeysTracker).length === 0;
+        stop: function () {
+            clearInterval(intervalId);
         }
     };
 }

package/esm/utils/constants/index.js

@@ -38,6 +38,7 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
+export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/lang/maps.js

@@ -37,13 +37,6 @@ var MapPoly = /** @class */ (function () {
         this.__mapKeysData__.length = 0;
         this.__mapValuesData__.length = 0;
     };
-    MapPoly.prototype.set = function (key, value) {
-        var index = this.__mapKeysData__.indexOf(key);
-        if (index === -1)
-            index = this.__mapKeysData__.push(key) - 1;
-        this.__mapValuesData__[index] = value;
-        return this;
-    };
     MapPoly.prototype.delete = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
@@ -52,12 +45,27 @@ var MapPoly = /** @class */ (function () {
         this.__mapValuesData__.splice(index, 1);
         return true;
     };
+    MapPoly.prototype.forEach = function (callbackfn, thisArg) {
+        for (var i = 0; i < this.__mapKeysData__.length; i++) {
+            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);
+        }
+    };
     MapPoly.prototype.get = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
             return;
         return this.__mapValuesData__[index];
     };
+    MapPoly.prototype.has = function (key) {
+        return this.__mapKeysData__.indexOf(key) !== -1;
+    };
+    MapPoly.prototype.set = function (key, value) {
+        var index = this.__mapKeysData__.indexOf(key);
+        if (index === -1)
+            index = this.__mapKeysData__.push(key) - 1;
+        this.__mapValuesData__[index] = value;
+        return this;
+    };
     Object.defineProperty(MapPoly.prototype, "size", {
         get: function () {
             return this.__mapKeysData__.length;

package/esm/utils/redis/RedisMock.js

@@ -0,0 +1,28 @@
+//@ts-nocheck
+function identityFunction(data) {
+    return data;
+}
+function asyncFunction(data) {
+    return Promise.resolve(data);
+}
+var IDENTITY_METHODS = [];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var RedisMock = /** @class */ (function () {
+    function RedisMock() {
+        var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
+        IDENTITY_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(identityFunction);
+        });
+        ASYNC_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(asyncFunction);
+        });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
+    }
+    return RedisMock;
+}());
+export { RedisMock };

package/esm/utils/settingsValidation/index.js

@@ -31,8 +31,6 @@ export var base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -111,7 +109,6 @@ export function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.1",
+  "version": "1.6.2-rc.11",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -70,7 +70,6 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

package/src/evaluator/index.ts

@@ -29,19 +29,19 @@ export function evaluateFeature(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
-  let stringifiedSplit;
+  let parsedSplit;
 
   try {
-    stringifiedSplit = storage.splits.getSplit(splitName);
+    parsedSplit = storage.splits.getSplit(splitName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentException;
   }
 
-  if (thenable(stringifiedSplit)) {
-    return stringifiedSplit.then((result) => getEvaluation(
+  if (thenable(parsedSplit)) {
+    return parsedSplit.then((split) => getEvaluation(
       log,
-      result,
+      split,
       key,
       attributes,
       storage,
@@ -54,7 +54,7 @@ export function evaluateFeature(
 
   return getEvaluation(
     log,
-    stringifiedSplit,
+    parsedSplit,
     key,
     attributes,
     storage,
@@ -68,28 +68,28 @@ export function evaluateFeatures(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
+  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,7 +124,7 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
+  splits: Record<string, ISplit | null>,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,