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

package/esm/sdkClient/clientInputValidation.js

@@ -1,7 +1,7 @@
 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';
 /**
@@ -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 = [];
@@ -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

@@ -2,9 +2,8 @@ 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';
-var SPLIT_FN_LABEL = 'split';
-var SPLITS_FN_LABEL = 'splits';
-var NAMES_FN_LABEL = 'names';
+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,7 +50,7 @@ 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)) {
@@ -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/inRedis/ImpressionCountsCacheInRedis.js

@@ -20,7 +20,11 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var keys = Object.keys(counts);
         if (!keys.length)
             return Promise.resolve(false);
-        return this.redis.pipelineExec(keys.map(function (key) { return ['hincrby', _this.key, key, counts[key]]; }))
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        return pipeline.exec()
             .then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
             if (data.length && data.length === keys.length) {

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', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
+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
@@ -37,9 +39,6 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this._setDisconnectWrapper();
         return _this;
     }
-    RedisAdapter.prototype.pipelineExec = function (commands) {
-        return this.pipeline(commands).exec();
-    };
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
         this.once('ready', function () {
@@ -58,13 +57,15 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
-            var originalMethod = instance[methodName];
-            instance[methodName] = 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 " + methodName + ".");
-                    var result = originalMethod.apply(instance, params);
+                    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.
@@ -83,10 +84,10 @@ 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: methodName.toUpperCase()
                         });
@@ -96,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 () {
@@ -157,7 +174,7 @@ var RedisAdapter = /** @class */ (function (_super) {
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout, operationTimeout = _b.operationTimeout, url = _b.url, host = _b.host, port = _b.port, db = _b.db, pass = _b.pass, tls = _b.tls;
+        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,

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;
 }());

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -168,7 +168,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -186,11 +186,11 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     /**
      * Get list of feature flag names related to a given list of flag set names.
      * The returned promise is resolved with the list of feature flag names per flag set,
-     * or rejected if the pipelined redis operation fails.
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
             .then(function (results) { return results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
@@ -225,13 +225,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             return true;
         });
     };
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
+    // @TODO remove or implement. It is not being used.
     SplitsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     /**
      * Fetches multiple splits definitions.

package/esm/utils/constants/index.js

@@ -29,6 +29,20 @@ export var STORAGE_PLUGGABLE = 'PLUGGABLE';
 export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
 export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
 export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions
+// Client method names
+export var GET_TREATMENT = 'getTreatment';
+export var GET_TREATMENTS = 'getTreatments';
+export var GET_TREATMENT_WITH_CONFIG = 'getTreatmentWithConfig';
+export var GET_TREATMENTS_WITH_CONFIG = 'getTreatmentsWithConfig';
+export var GET_TREATMENTS_BY_FLAG_SET = 'getTreatmentsByFlagSet';
+export var GET_TREATMENTS_BY_FLAG_SETS = 'getTreatmentsByFlagSets';
+export var GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'getTreatmentsWithConfigByFlagSet';
+export var GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'getTreatmentsWithConfigByFlagSets';
+export var TRACK_FN_LABEL = 'track';
+// Manager method names
+export var SPLIT_FN_LABEL = 'split';
+export var SPLITS_FN_LABEL = 'splits';
+export var NAMES_FN_LABEL = 'names';
 // Telemetry
 export var QUEUED = 0;
 export var DROPPED = 1;

package/esm/utils/redis/RedisMock.js

@@ -6,16 +6,22 @@ function asyncFunction(data) {
     return Promise.resolve(data);
 }
 var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
+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;
 }());

package/package.json

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

package/src/sdkClient/client.ts

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 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 { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
@@ -29,12 +29,12 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
 
-  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  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);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].label);
@@ -51,17 +51,17 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   }
 
   function getTreatmentWithConfig(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatment(key, featureFlagName, attributes, true);
+    return getTreatment(key, featureFlagName, attributes, true, GET_TREATMENT_WITH_CONFIG);
   }
 
-  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, methodName = GET_TREATMENTS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       Object.keys(evaluationResults).forEach(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);
 
@@ -79,18 +79,18 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   }
 
   function getTreatmentsWithConfig(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined) {
-    return getTreatments(key, featureFlagNames, attributes, true);
+    return getTreatments(key, featureFlagNames, attributes, true, GET_TREATMENTS_WITH_CONFIG);
   }
 
-  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS) {
+  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
-    const wrapUp = (evaluationResults: Record<string,IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       const evaluations = evaluationResults;
       Object.keys(evaluations).forEach(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);
 
@@ -99,22 +99,22 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, method) :
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
   function getTreatmentsWithConfigByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined) {
-    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: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    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: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    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
@@ -171,7 +171,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     // 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.
-    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
 
     const result = eventTracker.track(eventData, size);
 

package/src/sdkClient/clientInputValidation.ts

@@ -12,7 +12,7 @@ import {
   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 { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
@@ -32,7 +32,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
    * Avoid repeating this validations code
    */
   function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[] | undefined, maybeAttributes: SplitIO.Attributes | undefined, methodName: string, maybeFlagSetNameOrNames?: string[]) {
-    const multi = startsWith(methodName, 'getTreatments');
+    const multi = startsWith(methodName, GET_TREATMENTS);
     const key = validateKey(log, maybeKey, methodName);
     let splitOrSplits: string | string[] | false = false;
     let flagSetOrFlagSets: string[] = [];
@@ -63,7 +63,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatment');
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT);
 
     if (params.valid) {
       return client.getTreatment(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
@@ -73,7 +73,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatmentWithConfig');
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT_WITH_CONFIG);
 
     if (params.valid) {
       return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
@@ -83,7 +83,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatments');
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS);
 
     if (params.valid) {
       return client.getTreatments(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
@@ -96,7 +96,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatmentsWithConfig');
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS_WITH_CONFIG);
 
     if (params.valid) {
       return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
@@ -109,7 +109,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_BY_FLAG_SETS, maybeFlagSets);
 
     if (params.valid) {
       return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
@@ -119,7 +119,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeFlagSets);
 
     if (params.valid) {
       return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
@@ -129,7 +129,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_BY_FLAG_SET, [maybeFlagSet]);
 
     if (params.valid) {
       return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
@@ -139,7 +139,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, [maybeFlagSet]);
 
     if (params.valid) {
       return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
@@ -149,12 +149,12 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
-    const key = validateKey(log, maybeKey, 'track');
-    const tt = validateTrafficType(log, maybeTT, 'track');
-    const event = validateEvent(log, maybeEvent, 'track');
-    const eventValue = validateEventValue(log, maybeEventValue, 'track');
-    const { properties, size } = validateEventProperties(log, maybeProperties, 'track');
-    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, 'track');
+    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+    const tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+    const event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+    const eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+    const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
+    const 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/src/sdkFactory/index.ts

@@ -83,7 +83,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
-  const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
+  const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
   syncManager && syncManager.start();
   signalListener && signalListener.start();

package/src/sdkFactory/types.ts

@@ -1,9 +1,9 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
+import type { sdkManagerFactory } from '../sdkManager';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
+import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
@@ -87,11 +87,7 @@ export interface ISdkFactoryParams {
   syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager,
 
   // Sdk manager factory
-  sdkManagerFactory: (
-    log: ILogger,
-    splits: ISplitsCacheSync | ISplitsCacheAsync,
-    sdkReadinessManager: ISdkReadinessManager
-  ) => SplitIO.IManager | SplitIO.IAsyncManager,
+  sdkManagerFactory: typeof sdkManagerFactory,
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).