@splitsoftware/splitio-commons 1.10.1-rc.4 → 1.12.0-rc.0

package/esm/evaluator/index.js

@@ -2,7 +2,8 @@ import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { setToArray } from '../utils/lang/sets';
+import { setToArray, returnSetsUnion, _Set } from '../utils/lang/sets';
+import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 var treatmentException = {
     treatment: CONTROL,
     label: LabelsConstants.EXCEPTION,
@@ -50,8 +51,23 @@ export function evaluateFeatures(log, key, splitNames, attributes, storage) {
         }) :
         getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
-export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage) {
+export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
     var storedFlagNames;
+    function evaluate(featureFlagsByFlagSets) {
+        var featureFlags = new _Set();
+        for (var i = 0; i < flagSets.length; i++) {
+            var featureFlagByFlagSet = featureFlagsByFlagSets[i];
+            if (featureFlagByFlagSet.size) {
+                featureFlags = returnSetsUnion(featureFlags, featureFlagByFlagSet);
+            }
+            else {
+                log.warn(WARN_FLAGSET_WITHOUT_FLAGS, [method, flagSets[i]]);
+            }
+        }
+        return featureFlags.size ?
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
+            {};
+    }
     // get features by flag sets
     try {
         storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
@@ -62,8 +78,11 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
     }
     // evaluate related features
     return thenable(storedFlagNames) ?
-        storedFlagNames.then(function (splitNames) { return evaluateFeatures(log, key, setToArray(splitNames), attributes, storage); }) :
-        evaluateFeatures(log, key, setToArray(storedFlagNames), attributes, storage);
+        storedFlagNames.then(function (storedFlagNames) { return evaluate(storedFlagNames); })
+            .catch(function () {
+            return {};
+        }) :
+        evaluate(storedFlagNames);
 }
 function getEvaluation(log, splitJSON, key, attributes, storage) {
     var evaluation = {

package/esm/logger/constants.js

@@ -89,14 +89,16 @@ export var WARN_NOT_EXISTENT_SPLIT = 215;
 export var WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export var WARN_NOT_EXISTENT_TT = 217;
 export var WARN_INTEGRATION_INVALID = 218;
+export var WARN_SPLITS_FILTER_IGNORED = 219;
 export var WARN_SPLITS_FILTER_INVALID = 220;
 export var WARN_SPLITS_FILTER_EMPTY = 221;
 export var WARN_SDK_KEY = 222;
 export var STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export var STREAMING_PARSING_SPLIT_UPDATE = 224;
-export var WARN_SPLITS_FILTER_INVALID_SET = 225;
-export var WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export var WARN_INVALID_FLAGSET = 225;
+export var WARN_LOWERCASE_FLAGSET = 226;
 export var WARN_FLAGSET_NOT_CONFIGURED = 227;
+export var WARN_FLAGSET_WITHOUT_FLAGS = 228;
 export var ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export var ERROR_LOGLEVEL_INVALID = 301;
 export var ERROR_CLIENT_LISTENER = 302;

package/esm/logger/messages/warn.js

@@ -23,14 +23,16 @@ export var codesWarn = codesError.concat([
     [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
     [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
     [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split user interface.'],
-    [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: : you passed %s wich is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
+    [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: you passed %s which is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
     // initialization / settings validation
     [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],
+    [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS + ': feature flag filters are not applicable for Consumer modes where the SDK does not keep rollout data in sync. Filters were discarded'],
     [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
     [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/esm/sdkClient/client.js

@@ -1,10 +1,10 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
-import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
+import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 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 } from '../utils/constants';
+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';
 var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
@@ -21,12 +21,13 @@ 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;
-    function getTreatment(key, featureFlagName, attributes, withConfig) {
+    function getTreatment(key, featureFlagName, attributes, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
+        if (methodName === void 0) { methodName = GET_TREATMENT; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, "getTreatment" + (withConfig ? 'withConfig' : ''), queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatment;
@@ -39,16 +40,17 @@ export function clientFactory(params) {
         return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
     function getTreatmentWithConfig(key, featureFlagName, attributes) {
-        return getTreatment(key, featureFlagName, attributes, true);
+        return getTreatment(key, featureFlagName, attributes, true, GET_TREATMENT_WITH_CONFIG);
     }
-    function getTreatments(key, featureFlagNames, attributes, withConfig) {
+    function getTreatments(key, featureFlagNames, attributes, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
+        if (methodName === void 0) { methodName = GET_TREATMENTS; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, "getTreatments" + (withConfig ? 'withConfig' : ''), queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].label);
@@ -62,36 +64,37 @@ export function clientFactory(params) {
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfig(key, featureFlagNames, attributes) {
-        return getTreatments(key, featureFlagNames, attributes, true);
+        return getTreatments(key, featureFlagNames, attributes, true, GET_TREATMENTS_WITH_CONFIG);
     }
-    function getTreatmentsByFlagSets(key, flagSetNames, attributes, withConfig, method) {
+    function getTreatmentsByFlagSets(key, flagSetNames, attributes, withConfig, method, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (method === void 0) { method = TREATMENTS_BY_FLAGSETS; }
+        if (methodName === void 0) { methodName = GET_TREATMENTS_BY_FLAG_SETS; }
         var stopTelemetryTracker = telemetryTracker.trackEval(method);
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
             var evaluations = evaluationResults;
             Object.keys(evaluations).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, "getTreatmentsByFlagSets" + (withConfig ? 'WithConfig' : ''), queue);
+                treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatments;
         };
         var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage) :
+            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
             isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes) {
-        return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS);
+        return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
     }
     function getTreatmentsByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET);
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
     }
     function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET);
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
     function processEvaluation(evaluation, featureFlagName, key, attributes, withConfig, invokingMethodName, queue) {
@@ -99,7 +102,7 @@ export function clientFactory(params) {
         var bucketingKey = getBucketing(key);
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-        if (validateSplitExistance(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+        if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
             log.info(IMPRESSION_QUEUEING);
             queue.push({
                 feature: featureFlagName,
@@ -133,7 +136,7 @@ export function clientFactory(params) {
             properties: properties
         };
         // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-        validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+        validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
         var result = eventTracker.track(eventData, size);
         if (thenable(result)) {
             return result.then(function (result) {

package/esm/sdkClient/clientInputValidation.js

@@ -1,9 +1,9 @@
 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 } from '../utils/constants';
+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 { 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.
@@ -15,7 +15,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
      * Avoid repeating this validations code
      */
     function validateEvaluationParams(maybeKey, maybeFeatureFlagNameOrNames, maybeAttributes, methodName, maybeFlagSetNameOrNames) {
-        var multi = startsWith(methodName, 'getTreatments');
+        var multi = startsWith(methodName, GET_TREATMENTS);
         var key = validateKey(log, maybeKey, methodName);
         var splitOrSplits = false;
         var flagSetOrFlagSets = [];
@@ -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;
@@ -41,7 +41,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         return isSync ? value : Promise.resolve(value);
     }
     function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatment');
+        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT);
         if (params.valid) {
             return client.getTreatment(params.key, params.splitOrSplits, params.attributes);
         }
@@ -50,7 +50,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatmentWithConfig');
+        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT_WITH_CONFIG);
         if (params.valid) {
             return client.getTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);
         }
@@ -59,7 +59,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatments');
+        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS);
         if (params.valid) {
             return client.getTreatments(params.key, params.splitOrSplits, params.attributes);
         }
@@ -71,7 +71,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatmentsWithConfig');
+        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS_WITH_CONFIG);
         if (params.valid) {
             return client.getTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
         }
@@ -83,7 +83,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_BY_FLAG_SETS, maybeFlagSets);
         if (params.valid) {
             return client.getTreatmentsByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
         }
@@ -92,7 +92,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeFlagSets);
         if (params.valid) {
             return client.getTreatmentsWithConfigByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
         }
@@ -101,7 +101,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_BY_FLAG_SET, [maybeFlagSet]);
         if (params.valid) {
             return client.getTreatmentsByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
         }
@@ -110,7 +110,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, [maybeFlagSet]);
         if (params.valid) {
             return client.getTreatmentsWithConfigByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
         }
@@ -119,12 +119,12 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         }
     }
     function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        var key = validateKey(log, maybeKey, 'track');
-        var tt = validateTrafficType(log, maybeTT, 'track');
-        var event = validateEvent(log, maybeEvent, 'track');
-        var eventValue = validateEventValue(log, maybeEventValue, 'track');
-        var _a = validateEventProperties(log, maybeProperties, 'track'), properties = _a.properties, size = _a.size;
-        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, 'track');
+        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+        var tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+        var event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+        var eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
         if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
             return client.track(key, tt, event, eventValue, properties, size);
         }

package/esm/sdkFactory/index.js

@@ -63,7 +63,7 @@ export function sdkFactory(params) {
     ctx.signalListener = signalListener;
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     syncManager && syncManager.start();
     signalListener && signalListener.start();
     log.info(NEW_FACTORY);

package/esm/sdkManager/index.js

@@ -1,10 +1,9 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
-var SPLIT_FN_LABEL = 'split';
-var SPLITS_FN_LABEL = 'splits';
-var NAMES_FN_LABEL = 'names';
+import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 function collectTreatments(splitObject) {
     var conditions = splitObject.conditions;
     // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
@@ -38,8 +37,10 @@ function objectsToViews(splitObjects) {
     });
     return views;
 }
-export function sdkManagerFactory(log, splits, _a) {
+export function sdkManagerFactory(settings, splits, _a) {
     var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus), {
@@ -49,16 +50,16 @@ export function sdkManagerFactory(log, 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 null;
+                return isSync ? null : Promise.resolve(null);
             }
             var split = splits.getSplit(splitName);
             if (thenable(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    validateSplitExistance(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+                    validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            validateSplitExistance(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+            validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**
@@ -66,7 +67,7 @@ export function sdkManagerFactory(log, splits, _a) {
          */
         splits: function () {
             if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var currentSplits = splits.getAll();
             return thenable(currentSplits) ?
@@ -78,7 +79,7 @@ export function sdkManagerFactory(log, splits, _a) {
          */
         names: function () {
             if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var splitNames = splits.getSplitNames();
             return thenable(splitNames) ?

package/esm/storages/KeyBuilder.js

@@ -13,7 +13,7 @@ var KeyBuilder = /** @class */ (function () {
         return this.prefix + ".trafficType." + trafficType;
     };
     KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return this.prefix + ".flagset." + flagSet;
+        return this.prefix + ".flagSet." + flagSet;
     };
     KeyBuilder.prototype.buildSplitKey = function (splitName) {
         return this.prefix + ".split." + splitName;

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
-import { _Set, returnSetsUnion, setToArray } from '../../utils/lang/sets';
+import { _Set, setToArray } from '../../utils/lang/sets';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -228,16 +228,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        var toReturn = new _Set([]);
-        flagSets.forEach(function (flagSet) {
+        return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (flagSetFromLocalStorage) {
-                var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-                toReturn = returnSetsUnion(toReturn, flagSetCache);
-            }
+            return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
         });
-        return toReturn;
     };
     SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
         var _this = this;
@@ -248,9 +243,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 return;
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (!flagSetFromLocalStorage)
-                flagSetFromLocalStorage = '[]';
-            var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+            var flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
             localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
         });

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { _Set, returnSetsUnion } from '../../utils/lang/sets';
+import { _Set } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -9,14 +9,13 @@ import { _Set, returnSetsUnion } from '../../utils/lang/sets';
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     __extends(SplitsCacheInMemory, _super);
     function SplitsCacheInMemory(splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
         var _this = _super.call(this) || this;
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
         _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
-        _this.flagSetsFilter = splitFiltersValidation.groupedFilters.bySet;
+        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
     }
     SplitsCacheInMemory.prototype.clear = function () {
@@ -93,14 +92,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        var toReturn = new _Set([]);
-        flagSets.forEach(function (flagSet) {
-            var featureFlagNames = _this.flagSetsCache[flagSet];
-            if (featureFlagNames) {
-                toReturn = returnSetsUnion(toReturn, featureFlagNames);
-            }
-        });
-        return toReturn;
+        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new _Set(); });
     };
     SplitsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
         var _this = this;

package/esm/storages/inRedis/RedisAdapter.js

@@ -6,7 +6,8 @@ import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
+var METHODS_TO_PROMISE_WRAP_EXEC = ['pipeline'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,
@@ -24,6 +25,7 @@ var DEFAULT_LIBRARY_OPTIONS = {
 var RedisAdapter = /** @class */ (function (_super) {
     __extends(RedisAdapter, _super);
     function RedisAdapter(log, storageSettings) {
+        if (storageSettings === void 0) { storageSettings = {}; }
         var _this = this;
         var options = RedisAdapter._defineOptions(storageSettings);
         // Call the ioredis constructor
@@ -55,14 +57,15 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (method) {
-            var originalMethod = instance[method];
-            instance[method] = function () {
+        var wrapCommand = function (originalMethod, methodName) {
+            // The value of "this" in this function should be the instance actually executing the method. It might be the instance referred (the base one)
+            // or it can be the instance of a Pipeline object.
+            return function () {
                 var params = arguments;
+                var caller = this;
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + ("Executing " + method + "."));
-                    // Return original method
-                    var result = originalMethod.apply(instance, params);
+                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
+                    var result = originalMethod.apply(caller, params);
                     if (thenable(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
                         // On sync commands there's no need, only thenables.
@@ -73,7 +76,7 @@ var RedisAdapter = /** @class */ (function (_super) {
                         // Both success and error remove from queue.
                         result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
                         return timeout(instance._options.operationTimeout, result).catch(function (err) {
-                            instance.log.error(LOG_PREFIX + (method + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err));
+                            instance.log.error("" + LOG_PREFIX + methodName + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err);
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -81,12 +84,12 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return result;
                 }
                 if (instance._notReadyCommandsQueue) {
-                    return new Promise(function (res, rej) {
+                    return new Promise(function (resolve, reject) {
                         instance._notReadyCommandsQueue.unshift({
-                            resolve: res,
-                            reject: rej,
+                            resolve: resolve,
+                            reject: reject,
                             command: commandWrapper,
-                            name: method.toUpperCase()
+                            name: methodName.toUpperCase()
                         });
                     });
                 }
@@ -94,6 +97,22 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return commandWrapper();
                 }
             };
+        };
+        // Wrap regular async methods to track timeouts and queue when Redis is not yet executing commands.
+        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
+            var originalFn = instance[methodName];
+            instance[methodName] = wrapCommand(originalFn, methodName);
+        });
+        // Special handling for pipeline~like methods. We need to wrap the async trigger, which is exec, but return the Pipeline right away.
+        METHODS_TO_PROMISE_WRAP_EXEC.forEach(function (methodName) {
+            var originalFn = instance[methodName];
+            // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
+            instance[methodName] = function () {
+                var res = originalFn.apply(instance, arguments);
+                var originalExec = res.exec;
+                res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+                return res;
+            };
         });
     };
     RedisAdapter.prototype._setDisconnectWrapper = function () {
@@ -104,7 +123,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 params[_i] = arguments[_i];
             }
-            setTimeout(function deferedDisconnect() {
+            setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
                     instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
                     Promise.all(setToArray(instance._runningCommands))

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -51,9 +51,9 @@ var SegmentsCacheInRedis = /** @class */ (function () {
     SegmentsCacheInRedis.prototype.getRegisteredSegments = function () {
         return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
     };
-    // @TODO remove/review. It is not being used.
+    // @TODO remove or implement. It is not being used.
     SegmentsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     return SegmentsCacheInRedis;
 }());