@splitsoftware/splitio-commons 2.11.1-rc.2 → 3.0.0-rc.0

package/cjs/platform/getFetch/node.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetch = exports.__setFetch = void 0;
+var nodeFetch;
+try {
+    nodeFetch = require('node-fetch');
+    // Handle node-fetch issue https://github.com/node-fetch/node-fetch/issues/1037
+    if (typeof nodeFetch !== 'function')
+        nodeFetch = nodeFetch.default;
+}
+catch (error) {
+    // Try to access global fetch if `node-fetch` package couldn't be imported (e.g., not in a Node environment)
+    // eslint-disable-next-line no-undef
+    nodeFetch = typeof fetch === 'function' ? fetch : undefined;
+}
+// This function is only exposed for testing purposes.
+function __setFetch(fetch) {
+    nodeFetch = fetch;
+}
+exports.__setFetch = __setFetch;
+/**
+ * Retrieves 'node-fetch', a Fetch API polyfill for Node.js, with fallback to global 'fetch' if available.
+ */
+function getFetch() {
+    return nodeFetch;
+}
+exports.getFetch = getFetch;

package/cjs/platform/getOptions/node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptions = void 0;
+var tslib_1 = require("tslib");
+// @TODO
+// 1- handle multiple protocols automatically
+// 2- destroy it once the sdk is destroyed
+var https_1 = tslib_1.__importDefault(require("https"));
+var lang_1 = require("../../utils/lang");
+var agent = new https_1.default.Agent({
+    keepAlive: true,
+    keepAliveMsecs: 1500
+});
+function getOptions(settings) {
+    // User provided options take precedence
+    if (settings.sync.requestOptions)
+        return settings.sync.requestOptions;
+    // If some URL is not HTTPS, we don't use the agent, to let the SDK connect to HTTP endpoints
+    if ((0, lang_1.find)(settings.urls, function (url) { return !url.startsWith('https:'); }))
+        return;
+    return {
+        agent: agent
+    };
+}
+exports.getOptions = getOptions;

package/cjs/platform/node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platform = void 0;
+var events_1 = require("events");
+var node_1 = require("../platform/getFetch/node");
+var node_2 = require("../platform/getEventSource/node");
+var node_3 = require("../platform/getOptions/node");
+var node_4 = require("../listeners/node");
+var node_5 = require("../utils/timeTracker/now/node");
+exports.platform = {
+    getFetch: node_1.getFetch,
+    getEventSource: node_2.getEventSource,
+    getOptions: node_3.getOptions,
+    EventEmitter: events_1.EventEmitter,
+    now: node_5.now,
+    SignalListener: node_4.NodeSignalListener
+};

package/cjs/readiness/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEGMENTS_UPDATE = exports.FLAGS_UPDATE = exports.SDK_UPDATE = exports.SDK_READY_FROM_CACHE = exports.SDK_READY = exports.SDK_READY_TIMED_OUT = exports.SDK_SEGMENTS_ARRIVED = exports.SDK_SPLITS_CACHE_LOADED = exports.SDK_SPLITS_ARRIVED = void 0;
+exports.CONFIGS_UPDATE = exports.SEGMENTS_UPDATE = exports.FLAGS_UPDATE = exports.SDK_UPDATE = exports.SDK_READY_FROM_CACHE = exports.SDK_READY = exports.SDK_READY_TIMED_OUT = exports.SDK_SEGMENTS_ARRIVED = exports.SDK_SPLITS_CACHE_LOADED = exports.SDK_SPLITS_ARRIVED = void 0;
 // Splits events:
 exports.SDK_SPLITS_ARRIVED = 'state::splits-arrived';
 exports.SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
@@ -14,3 +14,4 @@ exports.SDK_UPDATE = 'state::update';
 // SdkUpdateMetadata types:
 exports.FLAGS_UPDATE = 'FLAGS_UPDATE';
 exports.SEGMENTS_UPDATE = 'SEGMENTS_UPDATE';
+exports.CONFIGS_UPDATE = 'CONFIGS_UPDATE';

package/cjs/sdkClient/client.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientFactory = void 0;
+exports.clientFactory = exports.stringify = void 0;
 var evaluator_1 = require("../evaluator");
 var thenable_1 = require("../utils/promise/thenable");
 var key_1 = require("../utils/key");
-var splitExistence_1 = require("../utils/inputValidation/splitExistence");
-var trafficTypeExistence_1 = require("../utils/inputValidation/trafficTypeExistence");
+var definitionExistence_1 = require("../utils/inputValidation/definitionExistence");
 var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
 var mode_1 = require("../utils/settingsValidation/mode");
+var trackMethod_1 = require("./trackMethod");
 var treatmentNotReady = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
 function treatmentsNotReady(featureFlagNames) {
     var evaluations = {};
@@ -26,11 +26,12 @@ function stringify(options) {
         catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
     }
 }
+exports.stringify = stringify;
 /**
  * Creator of base client with getTreatments and track methods.
  */
 function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker, fallbackTreatmentsCalculator = params.fallbackTreatmentsCalculator;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, telemetryTracker = params.telemetryTracker, fallbackCalculator = params.fallbackCalculator;
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -118,14 +119,13 @@ function clientFactory(params) {
         var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
         var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === constants_1.CONTROL) {
-            var fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+            var fallbackTreatment = fallbackCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
             label = fallbackTreatment.label;
             config = fallbackTreatment.config;
         }
-        log.info(constants_2.IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-        if ((0, splitExistence_1.validateSplitExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-            log.info(constants_2.IMPRESSION_QUEUEING);
+        if ((0, definitionExistence_1.validateDefinitionExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+            log.info(constants_2.IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
             queue.push({
                 imp: {
                     feature: featureFlagName,
@@ -148,33 +148,7 @@ function clientFactory(params) {
         }
         return treatment;
     }
-    function track(key, trafficTypeName, eventTypeId, value, properties, size) {
-        if (size === void 0) { size = 1024; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(constants_1.TRACK);
-        var matchingKey = (0, key_1.getMatching)(key);
-        var timestamp = Date.now();
-        var eventData = {
-            eventTypeId: eventTypeId,
-            trafficTypeName: trafficTypeName,
-            value: value,
-            timestamp: timestamp,
-            key: matchingKey,
-            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.
-        (0, trafficTypeExistence_1.validateTrafficTypeExistence)(log, readinessManager, storage.splits, mode, trafficTypeName, constants_1.TRACK_FN_LABEL);
-        var result = eventTracker.track(eventData, size);
-        if ((0, thenable_1.thenable)(result)) {
-            return result.then(function (result) {
-                stopTelemetryTracker();
-                return result;
-            });
-        }
-        else {
-            stopTelemetryTracker();
-            return result;
-        }
-    }
+    var track = (0, trackMethod_1.trackMethodFactory)(params);
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,

package/cjs/sdkClient/clientAttributesDecoration.js

@@ -69,7 +69,7 @@ function clientAttributesDecoration(log, client) {
             attribute[attributeName] = attributeValue;
             if (!(0, attributes_1.validateAttributesDeep)(log, attribute, 'setAttribute'))
                 return false;
-            log.debug("stored " + attributeValue + " for attribute " + attributeName);
+            log.debug("stored ".concat(attributeValue, " for attribute ").concat(attributeName));
             return attributeStorage.setAttribute(attributeName, attributeValue);
         },
         /**
@@ -79,7 +79,7 @@ function clientAttributesDecoration(log, client) {
          * @returns Attribute with the given name
          */
         getAttribute: function (attributeName) {
-            log.debug("retrieved attribute " + attributeName);
+            log.debug("retrieved attribute ".concat(attributeName));
             return attributeStorage.getAttribute(attributeName + '');
         },
         /**
@@ -108,7 +108,7 @@ function clientAttributesDecoration(log, client) {
          * @returns true if attribute was removed and false otherways
          */
         removeAttribute: function (attributeName) {
-            log.debug("removed attribute " + attributeName);
+            log.debug("removed attribute ".concat(attributeName));
             return attributeStorage.removeAttribute(attributeName + '');
         },
         /**

package/cjs/sdkClient/clientInputValidation.js

@@ -10,7 +10,7 @@ var splitFilters_1 = require("../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.
  */
-function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
+function clientInputValidationDecorator(settings, client, readinessManager, fallbackCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     /**
@@ -21,12 +21,12 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             (0, splitFilters_1.validateFlagSets)(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
             (0, lang_1.startsWith)(methodName, constants_1.GET_TREATMENTS) ?
-                (0, inputValidation_1.validateSplits)(log, maybeNameOrNames, methodName) :
-                (0, inputValidation_1.validateSplit)(log, maybeNameOrNames, methodName);
+                (0, inputValidation_1.validateDefinitions)(log, maybeNameOrNames, methodName) :
+                (0, inputValidation_1.validateDefinition)(log, maybeNameOrNames, methodName);
         var attributes = (0, inputValidation_1.validateAttributes)(log, maybeAttributes, methodName);
         var isNotDestroyed = (0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, methodName);
         var options = (0, inputValidation_1.validateEvaluationOptions)(log, maybeOptions, methodName);
-        (0, inputValidation_1.validateIfReadyFromCache)(log, readinessManager, methodName, nameOrNames);
+        (0, inputValidation_1.validateIfReadyFromCache)(log, readinessManager, methodName);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -37,111 +37,68 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
         };
     }
     function evaluateFallBackTreatment(featureFlagName, withConfig) {
-        var _a = fallbackTreatmentsCalculator.resolve(featureFlagName, ''), treatment = _a.treatment, config = _a.config;
-        if (withConfig) {
-            return {
+        if (Array.isArray(featureFlagName)) {
+            var res_1 = {};
+            featureFlagName.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, withConfig); });
+            return res_1;
+        }
+        var _a = fallbackCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
+        return withConfig ?
+            {
                 treatment: treatment,
                 config: config
-            };
-        }
-        return treatment;
+            } : treatment;
     }
     function wrapResult(value) {
         return isAsync ? Promise.resolve(value) : value;
     }
     function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var result = evaluateFallBackTreatment(params.nameOrNames, false);
-            return wrapResult(result);
-        }
+        return params.valid ?
+            client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames, false));
     }
     function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var result = evaluateFallBackTreatment(params.nameOrNames, true);
-            return wrapResult(result);
-        }
+        return params.valid ?
+            client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames, true));
     }
     function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_1 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, false); });
-            return wrapResult(res_1);
-        }
+        return params.valid ?
+            client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], false));
     }
     function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_2 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_2[split] = evaluateFallBackTreatment(split, true); });
-            return wrapResult(res_2);
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], true));
     }
     function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(constants_1.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        var key = (0, inputValidation_1.validateKey)(log, maybeKey, constants_1.TRACK_FN_LABEL);
-        var tt = (0, inputValidation_1.validateTrafficType)(log, maybeTT, constants_1.TRACK_FN_LABEL);
-        var event = (0, inputValidation_1.validateEvent)(log, maybeEvent, constants_1.TRACK_FN_LABEL);
-        var eventValue = (0, inputValidation_1.validateEventValue)(log, maybeEventValue, constants_1.TRACK_FN_LABEL);
-        var _a = (0, inputValidation_1.validateEventProperties)(log, maybeProperties, constants_1.TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
-        var isNotDestroyed = (0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, constants_1.TRACK_FN_LABEL);
-        if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-            return client.track(key, tt, event, eventValue, properties, size);
-        }
-        else {
-            return isAsync ? Promise.resolve(false) : false;
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
+            wrapResult({});
     }
     return {
         getTreatment: getTreatment,
@@ -152,7 +109,7 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track
+        track: client.track,
     };
 }
 exports.clientInputValidationDecorator = clientInputValidationDecorator;

package/cjs/sdkClient/identity.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildInstanceId = void 0;
 function buildInstanceId(key, trafficType) {
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType ? trafficType : '');
+    return "".concat(key.matchingKey ? key.matchingKey : key, "-").concat(key.bucketingKey ? key.bucketingKey : key, "-").concat(trafficType ? trafficType : '');
 }
 exports.buildInstanceId = buildInstanceId;

package/cjs/sdkClient/sdkClient.js

@@ -2,63 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkClientFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
-var apiKey_1 = require("../utils/inputValidation/apiKey");
 var client_1 = require("./client");
 var clientInputValidation_1 = require("./clientInputValidation");
-var COOLDOWN_TIME_IN_MILLIS = 1000;
+var sdkLifecycle_1 = require("./sdkLifecycle");
 /**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
-    var lastActionTime = 0;
-    function __cooldown(func, time) {
-        var now = Date.now();
-        //get the actual time elapsed in ms
-        var timeElapsed = now - lastActionTime;
-        //check if the time elapsed is less than desired cooldown
-        if (timeElapsed < time) {
-            //if yes, return message with remaining time in seconds
-            settings.log.warn("Flush cooldown, remaining time " + (time - timeElapsed) / 1000 + " seconds");
-            return Promise.resolve();
-        }
-        else {
-            //Do the requested action and re-assign the lastActionTime
-            lastActionTime = now;
-            return func();
-        }
-    }
-    function __flush() {
-        return syncManager ? syncManager.flush() : Promise.resolve();
-    }
+    var sdkReadinessManager = params.sdkReadinessManager, settings = params.settings;
     return (0, objectAssign_1.objectAssign)(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    (0, clientInputValidation_1.clientInputValidationDecorator)(settings, (0, client_1.clientFactory)(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), 
-    // Sdk destroy
-    {
-        flush: function () {
-            // @TODO define cooldown time
-            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-        },
-        destroy: function () {
-            // Mark the SDK as destroyed immediately
-            sdkReadinessManager.readinessManager.destroy();
-            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
-            if (!isSharedClient) {
-                (0, apiKey_1.releaseApiKey)(settings.core.authorizationKey);
-                telemetryTracker.sessionLength();
-                signalListener && signalListener.stop();
-                uniqueKeysTracker.stop();
-            }
-            // Stop background jobs
-            syncManager && syncManager.stop();
-            return __flush().then(function () {
-                // Cleanup storage
-                return storage.destroy();
-            });
-        }
-    });
+    (0, clientInputValidation_1.clientInputValidationDecorator)(settings, (0, client_1.clientFactory)(params), sdkReadinessManager.readinessManager, params.fallbackCalculator), (0, sdkLifecycle_1.sdkLifecycleFactory)(params, isSharedClient));
 }
 exports.sdkClientFactory = sdkClientFactory;

package/cjs/sdkClient/sdkLifecycle.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkLifecycleFactory = void 0;
+var apiKey_1 = require("../utils/inputValidation/apiKey");
+var COOLDOWN_TIME_IN_MILLIS = 1000;
+/**
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
+ */
+function sdkLifecycleFactory(params, isSharedClient) {
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker, platform = params.platform;
+    var hasInit = false;
+    var lastActionTime = 0;
+    var signalListener = platform.SignalListener && new platform.SignalListener(params);
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
+    return {
+        init: function () {
+            if (hasInit)
+                return;
+            hasInit = true;
+            if (!isSharedClient) {
+                (0, apiKey_1.validateAndTrackApiKey)(settings.log, settings.core.authorizationKey);
+                sdkReadinessManager.readinessManager.init();
+                impressionsTracker.start();
+                syncManager && syncManager.start();
+                signalListener && signalListener.start();
+            }
+        },
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
+        destroy: function () {
+            hasInit = false;
+            // Mark the SDK as destroyed immediately
+            sdkReadinessManager.readinessManager.destroy();
+            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+            if (!isSharedClient) {
+                (0, apiKey_1.releaseApiKey)(settings.core.authorizationKey);
+                telemetryTracker.sessionLength();
+                signalListener && signalListener.stop();
+                impressionsTracker.stop();
+            }
+            // Stop background jobs
+            syncManager && syncManager.stop();
+            return __flush().then(function () {
+                // Cleanup storage
+                return storage.destroy();
+            });
+        }
+    };
+}
+exports.sdkLifecycleFactory = sdkLifecycleFactory;

package/cjs/sdkClient/trackMethod.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackMethodFactory = void 0;
+var thenable_1 = require("../utils/promise/thenable");
+var key_1 = require("../utils/key");
+var trafficTypeExistence_1 = require("../utils/inputValidation/trafficTypeExistence");
+var inputValidation_1 = require("../utils/inputValidation");
+var constants_1 = require("../utils/constants");
+var mode_1 = require("../utils/settingsValidation/mode");
+/**
+ * Creates a standalone `track` function with input validation.
+ * Reusable by FF SDK client, Configs SDK, and thin-client SDK.
+ */
+function trackMethodFactory(params, warnTTExistence) {
+    if (warnTTExistence === void 0) { warnTTExistence = true; }
+    var settings = params.settings, splits = params.storage.splits, telemetryTracker = params.telemetryTracker, eventTracker = params.eventTracker, readinessManager = params.sdkReadinessManager.readinessManager;
+    var log = settings.log, mode = settings.mode;
+    var isAsync = (0, mode_1.isConsumerMode)(mode);
+    return function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        // Input validation
+        var key = (0, inputValidation_1.validateKey)(log, maybeKey, constants_1.TRACK_FN_LABEL);
+        var trafficTypeName = (0, inputValidation_1.validateTrafficType)(log, maybeTT, constants_1.TRACK_FN_LABEL);
+        var eventTypeId = (0, inputValidation_1.validateEvent)(log, maybeEvent, constants_1.TRACK_FN_LABEL);
+        var value = (0, inputValidation_1.validateEventValue)(log, maybeEventValue, constants_1.TRACK_FN_LABEL);
+        var _a = (0, inputValidation_1.validateEventProperties)(log, maybeProperties, constants_1.TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = (0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, constants_1.TRACK_FN_LABEL);
+        if (!(isNotDestroyed && key && trafficTypeName && eventTypeId && value !== false && properties !== false)) {
+            return isAsync ? Promise.resolve(false) : false;
+        }
+        // Core logic
+        var stopTelemetryTracker = telemetryTracker.trackEval(constants_1.TRACK);
+        var eventData = {
+            eventTypeId: eventTypeId,
+            trafficTypeName: trafficTypeName,
+            value: value,
+            timestamp: Date.now(),
+            key: (0, key_1.getMatching)(key),
+            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.
+        if (warnTTExistence)
+            (0, trafficTypeExistence_1.validateTrafficTypeExistence)(log, readinessManager, splits, mode, trafficTypeName, constants_1.TRACK_FN_LABEL);
+        var result = eventTracker.track(eventData, size);
+        if ((0, thenable_1.thenable)(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
+    };
+}
+exports.trackMethodFactory = trackMethodFactory;