@splitsoftware/splitio-commons 1.12.1-rc.4 → 1.12.1-rc.5

package/esm/sdkClient/client.js

@@ -6,7 +6,7 @@ import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTy
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 function treatmentsNotReady(featureFlagNames) {
     var evaluations = {};
@@ -21,6 +21,7 @@ function treatmentsNotReady(featureFlagNames) {
 export function clientFactory(params) {
     var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
     var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
     function getTreatment(key, featureFlagName, attributes, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (methodName === void 0) { methodName = GET_TREATMENT; }
@@ -34,9 +35,9 @@ export function clientFactory(params) {
         };
         var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
             evaluateFeature(log, key, featureFlagName, attributes, storage) :
-            isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-                treatmentNotReady :
-                Promise.resolve(treatmentNotReady); // Promisify if async
+            isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                Promise.resolve(treatmentNotReady) :
+                treatmentNotReady;
         return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
     function getTreatmentWithConfig(key, featureFlagName, attributes) {
@@ -58,9 +59,9 @@ export function clientFactory(params) {
         };
         var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
             evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-            isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-                treatmentsNotReady(featureFlagNames) :
-                Promise.resolve(treatmentsNotReady(featureFlagNames)); // Promisify if async
+            isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                Promise.resolve(treatmentsNotReady(featureFlagNames)) :
+                treatmentsNotReady(featureFlagNames);
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfig(key, featureFlagNames, attributes) {
@@ -84,7 +85,9 @@ export function clientFactory(params) {
         };
         var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
             evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
-            isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+            isAsync ?
+                Promise.resolve({}) :
+                {};
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes) {

package/esm/sdkClient/clientInputValidation.js

@@ -2,15 +2,15 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
-import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
 export function clientInputValidationDecorator(settings, client, readinessManager) {
-    var log = settings.log;
-    var isSync = isStorageSync(settings);
+    var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
     /**
      * Avoid repeating this validations code
      */
@@ -25,7 +25,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         if (maybeFlagSetNameOrNames) {
-            flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
+            flagSetOrFlagSets = validateFlagSets(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
         }
         validateIfOperational(log, readinessManager, methodName, splitOrSplits);
         var valid = isNotDestroyed && key && (splitOrSplits || flagSetOrFlagSets.length > 0) && attributes !== false;
@@ -38,7 +38,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         };
     }
     function wrapResult(value) {
-        return isSync ? value : Promise.resolve(value);
+        return isAsync ? Promise.resolve(value) : value;
     }
     function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
         var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT);
@@ -129,7 +129,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return client.track(key, tt, event, eventValue, properties, size);
         }
         else {
-            return isSync ? false : Promise.resolve(false);
+            return isAsync ? Promise.resolve(false) : false;
         }
     }
     return {

package/esm/sdkManager/index.js

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
 import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 function collectTreatments(splitObject) {
     var conditions = splitObject.conditions;
@@ -39,8 +39,8 @@ function objectsToViews(splitObjects) {
 }
 export function sdkManagerFactory(settings, splits, _a) {
     var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;
-    var log = settings.log;
-    var isSync = isStorageSync(settings);
+    var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus), {
@@ -50,7 +50,7 @@ export function sdkManagerFactory(settings, splits, _a) {
         split: function (featureFlagName) {
             var splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
             if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-                return isSync ? null : Promise.resolve(null);
+                return isAsync ? Promise.resolve(null) : null;
             }
             var split = splits.getSplit(splitName);
             if (thenable(split)) {
@@ -67,7 +67,7 @@ export function sdkManagerFactory(settings, splits, _a) {
          */
         splits: function () {
             if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-                return isSync ? [] : Promise.resolve([]);
+                return isAsync ? Promise.resolve([]) : [];
             }
             var currentSplits = splits.getAll();
             return thenable(currentSplits) ?
@@ -79,7 +79,7 @@ export function sdkManagerFactory(settings, splits, _a) {
          */
         names: function () {
             if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-                return isSync ? [] : Promise.resolve([]);
+                return isAsync ? Promise.resolve([]) : [];
             }
             var splitNames = splits.getSplitNames();
             return thenable(splitNames) ?

package/esm/storages/KeyBuilder.js

@@ -1,4 +1,5 @@
 import { startsWith } from '../utils/lang';
+import { hash } from '../utils/murmur3/murmur3';
 var everythingAtTheEnd = /[^.]+$/;
 var DEFAULT_PREFIX = 'SPLITIO';
 export function validatePrefix(prefix) {
@@ -54,6 +55,16 @@ var KeyBuilder = /** @class */ (function () {
             throw new Error('Invalid latency key provided');
         }
     };
+    KeyBuilder.prototype.buildHashKey = function () {
+        return this.prefix + ".hash";
+    };
     return KeyBuilder;
 }());
 export { KeyBuilder };
+/**
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
+ * The hash is in hexadecimal format (8 characters max, 32 bits).
+ */
+export function getStorageHash(settings) {
+    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString).toString(16);
+}

package/esm/storages/KeyBuilderCS.js

@@ -6,7 +6,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     function KeyBuilderCS(prefix, matchingKey) {
         var _this = _super.call(this, prefix) || this;
         _this.matchingKey = matchingKey;
-        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType)\\.");
+        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.");
         return _this;
     }
     /**
@@ -36,9 +36,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
         return this.regexSplitsCacheKey.test(key);
     };
-    KeyBuilderCS.prototype.buildSplitsFilterQueryKey = function () {
-        return this.prefix + ".splits.filterQuery";
-    };
     return KeyBuilderCS;
 }(KeyBuilder));
 export { KeyBuilderCS };

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,6 +3,7 @@ import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSyn
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { _Set, setToArray } from '../../utils/lang/sets';
+import { getStorageHash } from '../KeyBuilder';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -13,13 +14,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @param {number | undefined} expirationTimestamp
      * @param {ISplitFiltersValidation} splitFiltersValidation
      */
-    function SplitsCacheInLocal(log, keys, expirationTimestamp, splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
+    function SplitsCacheInLocal(settings, keys, expirationTimestamp) {
         var _this = _super.call(this) || this;
-        _this.log = log;
         _this.keys = keys;
-        _this.splitFiltersValidation = splitFiltersValidation;
-        _this.flagSetsFilter = _this.splitFiltersValidation.groupedFilters.bySet;
+        _this.log = settings.log;
+        _this.storageHash = getStorageHash(settings);
+        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
         _this._checkExpiration(expirationTimestamp);
         _this._checkFilterQuery();
         return _this;
@@ -123,14 +123,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
-            this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');
-            var queryKey = this.keys.buildSplitsFilterQueryKey();
-            var queryString = this.splitFiltersValidation.queryString;
+            this.log.info(LOG_PREFIX + 'SDK key or feature flag filter criteria was modified. Updating cache.');
+            var storageHashKey = this.keys.buildHashKey();
             try {
-                if (queryString)
-                    localStorage.setItem(queryKey, queryString);
-                else
-                    localStorage.removeItem(queryKey);
+                localStorage.setItem(storageHashKey, this.storageHash);
             }
             catch (e) {
                 this.log.error(LOG_PREFIX + e);
@@ -208,11 +204,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 this.clear();
         }
     };
+    // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
     SplitsCacheInLocal.prototype._checkFilterQuery = function () {
-        var queryString = this.splitFiltersValidation.queryString;
-        var queryKey = this.keys.buildSplitsFilterQueryKey();
-        var currentQueryString = localStorage.getItem(queryKey);
-        if (currentQueryString !== queryString) {
+        var storageHashKey = this.keys.buildHashKey();
+        var storageHash = localStorage.getItem(storageHashKey);
+        if (storageHash !== this.storageHash) {
             try {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;

package/esm/storages/inLocalStorage/index.js

@@ -31,7 +31,7 @@ export function InLocalStorage(options) {
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        var splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+        var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
         return {
             splits: splits,

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnListDifference } from '../../utils/lang/sets';
+import { _Set, returnDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -49,8 +49,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     };
     SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
         var _this = this;
-        var removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        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; });

package/esm/storages/inRedis/index.js

@@ -36,7 +36,7 @@ export function InRedisStorage(options) {
             telemetry.recordConfig();
         });
         return {
-            splits: new SplitsCacheInRedis(log, keys, redisClient),
+            splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             impressionCounts: impressionCountsCache,

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnListDifference } from '../../utils/lang/sets';
+import { _Set, returnDifference } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -36,8 +36,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
     };
     SplitsCachePluggable.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
         var _this = this;
-        var removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        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; });

package/esm/storages/pluggable/index.js

@@ -6,7 +6,7 @@ import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
-import { validatePrefix } from '../KeyBuilder';
+import { getStorageHash, validatePrefix } from '../KeyBuilder';
 import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
@@ -73,15 +73,26 @@ export function PluggableStorage(options) {
             undefined;
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
-            onReadyCb();
-            // Start periodic flush of async storages if not running synchronizer (producer mode)
-            if (!isSyncronizer) {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var currentHash = getStorageHash(settings);
+                    if (hash !== currentHash) {
+                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(onReadyCb);
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
                 if (impressionCountsCache && impressionCountsCache.start)
                     impressionCountsCache.start();
                 if (uniqueKeysCache && uniqueKeysCache.start)
                     uniqueKeysCache.start();
                 if (telemetry && telemetry.recordConfig)
                     telemetry.recordConfig();
+                onReadyCb();
             }
         }).catch(function (e) {
             e = e || new Error('Error connecting wrapper');

package/esm/trackers/eventTracker.js

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
-import { isStorageSync } from './impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
@@ -10,8 +10,8 @@ import { isStorageSync } from './impressionObserver/utils';
  * @param integrationsManager optional event handler used for integrations
  */
 export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
-    var log = settings.log;
-    var isSync = isStorageSync(settings);
+    var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
@@ -38,7 +38,7 @@ export function eventTrackerFactory(settings, eventsCache, integrationsManager,
     return {
         track: function (eventData, size) {
             if (settings.userConsent === CONSENT_DECLINED) {
-                return isSync ? false : Promise.resolve(false);
+                return isAsync ? Promise.resolve(false) : false;
             }
             var tracked = eventsCache.track(eventData, size);
             if (thenable(tracked)) {

package/esm/utils/lang/sets.js

@@ -102,7 +102,7 @@ export function returnSetsUnion(set, set2) {
     });
     return result;
 }
-export function returnListDifference(list, list2) {
+export function returnDifference(list, list2) {
     if (list === void 0) { list = []; }
     if (list2 === void 0) { list2 = []; }
     var result = new _Set(list);

package/esm/utils/settingsValidation/index.js

@@ -1,5 +1,5 @@
 import { merge, get } from '../lang';
-import { mode } from './mode';
+import { validateMode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
@@ -123,7 +123,7 @@ export function settingsValidation(config, validationParams) {
     startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
-    withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+    withDefaults.mode = validateMode(withDefaults.core.authorizationKey, withDefaults.mode);
     // ensure a valid Storage based on mode defined.
     // @ts-ignore, modify readonly prop
     if (storage)

package/esm/utils/settingsValidation/mode.js

@@ -1,5 +1,5 @@
 import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
-export function mode(key, mode) {
+export function validateMode(key, mode) {
     // Leaving the comparison as is, in case we change the mode name but not the setting.
     if (key === 'localhost')
         return LOCALHOST_MODE;
@@ -7,3 +7,9 @@ export function mode(key, mode) {
         throw Error('Invalid mode provided');
     return mode;
 }
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isConsumerMode(mode) {
+    return CONSUMER_MODE === mode || CONSUMER_PARTIAL_MODE === mode;
+}

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,8 +1,8 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
+import { isConsumerMode } from './mode';
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 var FILTERS_METADATA = [
@@ -45,7 +45,7 @@ function validateSplitFilter(log, type, values, maxLength) {
     var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
     if (result) {
         if (type === 'bySet') {
-            result = sanitizeFlagSets(log, result);
+            result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
         }
         // check max length
         if (result.length > maxLength)
@@ -78,7 +78,7 @@ function queryStringBuilder(groupedFilters) {
     return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
 }
 /**
- * Sanitizes set names list taking in account:
+ * Sanitizes set names list taking into account:
  *  - It should be lowercase
  *  - Must adhere the following regular expression /^[a-z0-9][_a-z0-9]{0,49}$/ that means
  *   - must start with a letter or number
@@ -88,20 +88,21 @@ function queryStringBuilder(groupedFilters) {
  *
  * @param {ILogger} log
  * @param {string[]} flagSets
+ * @param {string} method
  * @returns sanitized list of set names
  */
-function sanitizeFlagSets(log, flagSets) {
+function sanitizeFlagSets(log, flagSets, method) {
     var sanitizedSets = flagSets
         .map(function (flagSet) {
         if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-            log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+            log.warn(WARN_LOWERCASE_FLAGSET, [method, flagSet]);
             flagSet = flagSet.toLowerCase();
         }
         return flagSet;
     })
         .filter(function (flagSet) {
         if (!VALID_FLAGSET_REGEX.test(flagSet)) {
-            log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
+            log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
             return false;
         }
         if (typeof flagSet !== 'string')
@@ -137,7 +138,7 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     if (!maybeSplitFilters)
         return res;
     // Warn depending on the mode
-    if (mode === CONSUMER_MODE || mode === CONSUMER_PARTIAL_MODE) {
+    if (isConsumerMode(mode)) {
         log.warn(WARN_SPLITS_FILTER_IGNORED);
         return res;
     }
@@ -175,9 +176,9 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]);
     return res;
 }
-export function flagSetsAreValid(log, method, flagSets, flagSetsInConfig) {
+export function validateFlagSets(log, method, flagSets, flagSetsInConfig) {
     var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-    var toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+    var toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
     if (flagSetsInConfig.length > 0) {
         toReturn = toReturn.filter(function (flagSet) {
             if (flagSetsInConfig.indexOf(flagSet) > -1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.12.1-rc.4",
+  "version": "1.12.1-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/constants.ts

@@ -97,8 +97,8 @@ export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
 export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
-export const WARN_SPLITS_FILTER_INVALID_SET = 225;
-export const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export const WARN_INVALID_FLAGSET = 225;
+export const WARN_LOWERCASE_FLAGSET = 226;
 export const WARN_FLAGSET_NOT_CONFIGURED = 227;
 export const WARN_FLAGSET_WITHOUT_FLAGS = 228;
 

package/src/logger/messages/warn.ts

@@ -34,7 +34,7 @@ export const codesWarn: [number, string][] = codesError.concat([
 
   [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
   [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
-  [c.WARN_SPLITS_FILTER_INVALID_SET, c.LOG_PREFIX_SETTINGS + ': you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
-  [c.WARN_SPLITS_FILTER_LOWERCASE_SET, c.LOG_PREFIX_SETTINGS + ': flag set %s should be all lowercase - converting string to lowercase.'],
+  [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
+  [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
   [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],
 ]);

package/src/sdkClient/client.ts

@@ -9,7 +9,7 @@ import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
@@ -28,6 +28,7 @@ function treatmentsNotReady(featureFlagNames: string[]) {
 export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
@@ -43,9 +44,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeature(log, key, featureFlagName, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentNotReady :
-        Promise.resolve(treatmentNotReady); // Promisify if async
+      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        Promise.resolve(treatmentNotReady) :
+        treatmentNotReady;
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
@@ -71,9 +72,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentsNotReady(featureFlagNames) :
-        Promise.resolve(treatmentsNotReady(featureFlagNames)); // Promisify if async
+      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        Promise.resolve(treatmentsNotReady(featureFlagNames)) :
+        treatmentsNotReady(featureFlagNames);
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
@@ -100,7 +101,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
-      isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+      isAsync ?
+        Promise.resolve({}) :
+        {};
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }