@splitsoftware/splitio-commons 1.1.0 → 1.2.1-rc.1

package/CHANGES.txt

@@ -1,3 +1,6 @@
+1.2.0 (January 19, 2022)
+ - Added support to SDK clients on browser to optionally bind attributes to the client, keeping these loaded within the SDK along with the user ID, for easier usage when requesting flag.
+
 1.1.0 (January 11, 2022)
  - Added support for the SDK to run in "consumer" and "partial consumer" modes, with a pluggable implementation of it's internal storage, enabling
   customers to implement this caching with any storage technology of choice and connect it to the SDK instance to be used instead of its default in-memory storage.

package/cjs/evaluator/matchers/ew.js

@@ -5,9 +5,9 @@ var constants_1 = require("../../logger/constants");
 var lang_1 = require("../../utils/lang");
 function endsWithMatcherContext(log, ruleAttr) {
     return function endsWithMatcher(runtimeAttr) {
-        var endsWith = ruleAttr.some(function (e) { return lang_1.endsWith(runtimeAttr, e); });
-        log.debug(constants_1.ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, endsWith]);
-        return endsWith;
+        var strEndsWith = ruleAttr.some(function (e) { return lang_1.endsWith(runtimeAttr, e); });
+        log.debug(constants_1.ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
+        return strEndsWith;
     };
 }
 exports.endsWithMatcherContext = endsWithMatcherContext;

package/cjs/logger/messages/info.js

@@ -24,10 +24,10 @@ exports.codesInfo = warn_1.codesWarn.concat([
     [c.SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full events queue and reseting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
-    [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect in %s seconds.'],
-    [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting to streaming.'],
+    [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],
+    [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting streaming.'],
     [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given Api key. Switching to polling mode.'],
-    [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting from streaming.'],
+    [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting streaming.'],
     [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],
     [c.SYNC_CONTINUE_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming couldn\'t connect. Continue polling.'],
     [c.SYNC_STOP_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming (re)connected. Syncing and stopping polling.'],

package/cjs/sdkClient/client.js

@@ -98,7 +98,8 @@ function clientFactory(params) {
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
-        track: track
+        track: track,
+        isBrowserClient: false
     };
 }
 exports.clientFactory = clientFactory;

package/cjs/sdkClient/clientAttributesDecoration.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientAttributesDecoration = void 0;
+var AttributesCacheInMemory_1 = require("../storages/inMemory/AttributesCacheInMemory");
+var attributes_1 = require("../utils/inputValidation/attributes");
+var objectAssign_1 = require("../utils/lang/objectAssign");
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+function clientAttributesDecoration(log, client) {
+    var attributeStorage = new AttributesCacheInMemory_1.AttributesCacheInMemory();
+    // Keep a reference to the original methods
+    var clientGetTreatment = client.getTreatment;
+    var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+    var clientGetTreatments = client.getTreatments;
+    var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+    var clientTrack = client.track;
+    function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+    }
+    function combineAttributes(maybeAttributes) {
+        var storedAttributes = attributeStorage.getAll();
+        if (Object.keys(storedAttributes).length > 0) {
+            return objectAssign_1.objectAssign({}, storedAttributes, maybeAttributes);
+        }
+        return maybeAttributes;
+    }
+    return objectAssign_1.objectAssign(client, {
+        getTreatment: getTreatment,
+        getTreatmentWithConfig: getTreatmentWithConfig,
+        getTreatments: getTreatments,
+        getTreatmentsWithConfig: getTreatmentsWithConfig,
+        track: track,
+        /**
+         * Add an attribute to client's in memory attributes storage
+         *
+         * @param {string} attributeName Attrinute name
+         * @param {string, number, boolean, list} attributeValue Attribute value
+         * @returns {boolean} true if the attribute was stored and false otherways
+         */
+        setAttribute: function (attributeName, attributeValue) {
+            var attribute = {};
+            attribute[attributeName] = attributeValue;
+            if (!attributes_1.validateAttributesDeep(log, attribute, 'setAttribute'))
+                return false;
+            log.debug("stored " + attributeValue + " for attribute " + attributeName);
+            return attributeStorage.setAttribute(attributeName, attributeValue);
+        },
+        /**
+         * Returns the attribute with the given key
+         *
+         * @param {string} attributeName Attribute name
+         * @returns {Object} Attribute with the given key
+         */
+        getAttribute: function (attributeName) {
+            log.debug("retrieved attribute " + attributeName);
+            return attributeStorage.getAttribute(attributeName + '');
+        },
+        /**
+         * Add to client's in memory attributes storage the attributes in 'attributes'
+         *
+         * @param {Object} attributes Object with attributes to store
+         * @returns true if attributes were stored an false otherways
+         */
+        setAttributes: function (attributes) {
+            if (!attributes_1.validateAttributesDeep(log, attributes, 'setAttributes'))
+                return false;
+            return attributeStorage.setAttributes(attributes);
+        },
+        /**
+         * Return all the attributes stored in client's in memory attributes storage
+         *
+         * @returns {Object} returns all the stored attributes
+         */
+        getAttributes: function () {
+            return attributeStorage.getAll();
+        },
+        /**
+         * Removes from client's in memory attributes storage the attribute with the given key
+         *
+         * @param {string} attributeName
+         * @returns {boolean} true if attribute was removed and false otherways
+         */
+        removeAttribute: function (attributeName) {
+            log.debug("removed attribute " + attributeName);
+            return attributeStorage.removeAttribute(attributeName + '');
+        },
+        /**
+         * Remove all the stored attributes in the client's in memory attribute storage
+         */
+        clearAttributes: function () {
+            return attributeStorage.clear();
+        }
+    });
+}
+exports.clientAttributesDecoration = clientAttributesDecoration;

package/cjs/sdkClient/clientCS.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientCSDecorator = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
+var clientAttributesDecoration_1 = require("./clientAttributesDecoration");
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
  *
@@ -9,15 +10,17 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-function clientCSDecorator(client, key, trafficType) {
-    return objectAssign_1.objectAssign(client, {
+function clientCSDecorator(log, client, key, trafficType) {
+    var clientCS = clientAttributesDecoration_1.clientAttributesDecoration(log, client);
+    return objectAssign_1.objectAssign(clientCS, {
         // In the client-side API, we bind a key to the client `getTreatment*` methods
-        getTreatment: client.getTreatment.bind(client, key),
-        getTreatmentWithConfig: client.getTreatmentWithConfig.bind(client, key),
-        getTreatments: client.getTreatments.bind(client, key),
-        getTreatmentsWithConfig: client.getTreatmentsWithConfig.bind(client, key),
+        getTreatment: clientCS.getTreatment.bind(clientCS, key),
+        getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
+        getTreatments: clientCS.getTreatments.bind(clientCS, key),
+        getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-        track: trafficType ? client.track.bind(client, key, trafficType) : client.track.bind(client, key)
+        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+        isBrowserClient: true
     });
 }
 exports.clientCSDecorator = clientCSDecorator;

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -23,7 +23,7 @@ function sdkClientMethodCSFactory(params) {
     // `false` value is used as binded key of the default client, but trafficType is ignored
     // @TODO handle as a non-recoverable error
     var validKey = key_1.validateKey(log, key, method);
-    var mainClientInstance = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(params), // @ts-ignore
     validKey);
     var parsedDefaultKey = key_2.keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -58,7 +58,7 @@ function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
+            clientInstances[instanceId] = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/cjs/sdkClient/sdkClientMethodCSWithTT.js

@@ -29,7 +29,7 @@ function sdkClientMethodCSFactory(params) {
     if (trafficType !== undefined) {
         validTrafficType = trafficType_1.validateTrafficType(log, trafficType, method);
     }
-    var mainClientInstance = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(params), // @ts-ignore
     validKey, validTrafficType);
     var parsedDefaultKey = key_2.keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
@@ -71,7 +71,7 @@ function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
+            clientInstances[instanceId] = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/cjs/services/splitHttpClient.js

@@ -46,7 +46,7 @@ function splitHttpClientFactory(settings, getFetch, getOptions) {
             return response;
         })
             .catch(function (error) {
-            var resp = error.response;
+            var resp = error && error.response;
             var msg = '';
             if (resp) { // An HTTP error
                 switch (resp.status) {

package/cjs/storages/inMemory/AttributesCacheInMemory.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributesCacheInMemory = void 0;
+var objectAssign_1 = require("../../utils/lang/objectAssign");
+var AttributesCacheInMemory = /** @class */ (function () {
+    function AttributesCacheInMemory() {
+        this.attributesCache = {};
+    }
+    /**
+     * Create or update the value for the given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @param {Object} attributeValue attribute value
+     * @returns {boolean} the attribute was stored
+     */
+    AttributesCacheInMemory.prototype.setAttribute = function (attributeName, attributeValue) {
+        this.attributesCache[attributeName] = attributeValue;
+        return true;
+    };
+    /**
+     * Retrieves the value of a given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @returns {Object?} stored attribute value
+     */
+    AttributesCacheInMemory.prototype.getAttribute = function (attributeName) {
+        return this.attributesCache[attributeName];
+    };
+    /**
+     * Create or update all the given attributes
+     *
+     * @param {[string, Object]} attributes attributes to create or update
+     * @returns {boolean} attributes were stored
+     */
+    AttributesCacheInMemory.prototype.setAttributes = function (attributes) {
+        this.attributesCache = objectAssign_1.objectAssign(this.attributesCache, attributes);
+        return true;
+    };
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    AttributesCacheInMemory.prototype.getAll = function () {
+        return this.attributesCache;
+    };
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    AttributesCacheInMemory.prototype.removeAttribute = function (attributeName) {
+        if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+            delete this.attributesCache[attributeName];
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    AttributesCacheInMemory.prototype.clear = function () {
+        this.attributesCache = {};
+        return true;
+    };
+    return AttributesCacheInMemory;
+}());
+exports.AttributesCacheInMemory = AttributesCacheInMemory;

package/cjs/sync/polling/fetchers/mySegmentsFetcher.js

@@ -5,8 +5,8 @@ exports.mySegmentsFetcherFactory = void 0;
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-function mySegmentsFetcherFactory(fetchMySegments, userMatchingKey) {
-    return function mySegmentsFetcher(noCache, 
+function mySegmentsFetcherFactory(fetchMySegments) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, 
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
         var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);

package/cjs/sync/polling/pollingManagerCS.js

@@ -11,7 +11,8 @@ var constants_2 = require("../../logger/constants");
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
+function pollingManagerCSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTask_1.splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     // Map of matching keys to their corresponding MySegmentsSyncTask.

package/cjs/sync/polling/pollingManagerSS.js

@@ -8,7 +8,8 @@ var constants_1 = require("../../logger/constants");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(splitApi, storage, readiness, settings) {
+function pollingManagerSSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTask_1.splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     var segmentsSyncTask = segmentsSyncTask_1.segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);

package/cjs/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -8,6 +8,6 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTask_1.syncTaskFactory(settings.log, mySegmentsUpdater_1.mySegmentsUpdaterFactory(settings.log, mySegmentsFetcher_1.mySegmentsFetcherFactory(fetchMySegments, matchingKey), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+    return syncTask_1.syncTaskFactory(settings.log, mySegmentsUpdater_1.mySegmentsUpdaterFactory(settings.log, mySegmentsFetcher_1.mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -10,7 +10,7 @@ var constants_2 = require("../../../logger/constants");
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -54,7 +54,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
             // If segmentsData is provided, there is no need to fetch mySegments
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
-            mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);

package/cjs/sync/streaming/AuthClient/index.js

@@ -16,8 +16,7 @@ function authenticateFactory(fetchAuth) {
      * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
      */
     return function authenticate(userKeys) {
-        var authPromise = fetchAuth(userKeys); // errors handled by fetchAuth service
-        return authPromise
+        return fetchAuth(userKeys)
             .then(function (resp) { return resp.json(); })
             .then(function (json) {
             if (json.token) { // empty token when `"pushEnabled": false`

package/cjs/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -10,7 +10,7 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {Object} segmentsCache segments data cache
      * @param {Object} segmentsSyncTask task for syncing segments data
      */
-    function SegmentsUpdateWorker(segmentsCache, segmentsSyncTask) {
+    function SegmentsUpdateWorker(segmentsSyncTask, segmentsCache) {
         this.segmentsCache = segmentsCache;
         this.segmentsSyncTask = segmentsSyncTask;
         this.maxChangeNumbers = {};

package/cjs/sync/streaming/pushManager.js

@@ -22,10 +22,11 @@ var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+function pushManagerFactory(params, pollingManager) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
-    var userKey = settings.core.key ? key_1.getMatching(settings.core.key) : undefined; //
+    var userKey = settings.core.key ? key_1.getMatching(settings.core.key) : undefined;
     var log = settings.log;
     var sseClient;
     try {
@@ -36,13 +37,14 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         log.warn(constants_2.STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = AuthClient_1.authenticateFactory(fetchAuth);
+    var authenticate = AuthClient_1.authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandler_1.SSEHandlerFactory(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
     // init workers
-    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker_1.SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+    // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker_1.SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = new SplitsUpdateWorker_1.SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
@@ -50,11 +52,6 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
-    if (userKey) {
-        var hash = AuthClient_1.hashUserKey(userKey);
-        userKeyHashes[hash] = userKey;
-        clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: segmentsUpdateWorker };
-    }
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
     // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
@@ -261,33 +258,40 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     return objectAssign_1.objectAssign(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter), {
-        // Expose functionality for starting and stoping push mode:
-        stop: disconnectPush,
+        // Stop/pause push mode
+        stop: function () {
+            disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
+            if (userKey)
+                this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
+        },
+        // Start/resume push mode
         start: function () {
             // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
             if (disabled || disconnected === false)
                 return;
             disconnected = false;
-            // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
-            setTimeout(connectPush);
+            if (userKey)
+                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+            else
+                setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(mySegmentsSyncTask) };
             var hash = AuthClient_1.hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
+                clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(mySegmentsSyncTask) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
+                // Reconnects in case of a new client.
+                // Run in next event-loop cycle to save authentication calls
+                // in case multiple clients are created in the current cycle.
+                setTimeout(function checkForReconnect() {
+                    if (connectForNewClient) {
+                        connectForNewClient = false;
+                        connectPush();
+                    }
+                }, 0);
             }
-            // Reconnects in case of a new client.
-            // Run in next event-loop cycle to save authentication calls
-            // in case the user is creating several clients in the current cycle.
-            setTimeout(function checkForReconnect() {
-                if (connectForNewClient) {
-                    connectForNewClient = false;
-                    connectPush();
-                }
-            }, 0);
         },
         // [Only for client-side]
         remove: function (userKey) {

package/cjs/sync/submitters/submitterManager.js

@@ -5,7 +5,8 @@ var syncTaskComposite_1 = require("../syncTaskComposite");
 var eventsSyncTask_1 = require("./eventsSyncTask");
 var impressionsSyncTask_1 = require("./impressionsSyncTask");
 var impressionCountsSyncTask_1 = require("./impressionCountsSyncTask");
-function submitterManagerFactory(settings, storage, splitApi) {
+function submitterManagerFactory(params) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
     var log = settings.log;
     var submitters = [
         impressionsSyncTask_1.impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/cjs/sync/syncManagerOnline.js

@@ -16,26 +16,25 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
-    return function (_a) {
-        var settings = _a.settings, platform = _a.platform, splitApi = _a.splitApi, storage = _a.storage, readiness = _a.readiness;
-        var log = settings.log;
+    return function (params) {
+        var _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
-        var pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
-            pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
+        var pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+            pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
         // It is not inyected as push and polling managers, because at the moment it is required
-        var submitter = submitterManager_1.submitterManagerFactory(settings, storage, splitApi);
+        var submitter = submitterManager_1.submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
-            if (!pollingManager.isRunning()) {
-                log.info(constants_2.SYNC_START_POLLING);
-                pollingManager.start();
+            if (pollingManager.isRunning()) {
+                log.info(constants_2.SYNC_CONTINUE_POLLING);
             }
             else {
-                log.info(constants_2.SYNC_CONTINUE_POLLING);
+                log.info(constants_2.SYNC_START_POLLING);
+                pollingManager.start();
             }
         }
         function stopPollingAndSyncAll() {
@@ -73,7 +72,8 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                submitter && submitter.start();
+                if (submitter)
+                    submitter.start();
                 running = true;
             },
             /**

package/cjs/utils/inputValidation/attribute.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAttribute = void 0;
+var lang_1 = require("../../utils/lang");
+function validateAttribute(log, attributeKey, attributeValue, method) {
+    if (!lang_1.isString(attributeKey) || attributeKey.length === 0) {
+        log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+        return false;
+    }
+    var isStringVal = lang_1.isString(attributeValue);
+    var isFiniteVal = lang_1.isFiniteNumber(attributeValue);
+    var isBoolVal = lang_1.isBoolean(attributeValue);
+    var isArrayVal = Array.isArray(attributeValue);
+    if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+        log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+        return false;
+    }
+    return true;
+}
+exports.validateAttribute = validateAttribute;

package/cjs/utils/inputValidation/attributes.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAttributes = void 0;
+exports.validateAttributesDeep = exports.validateAttributes = void 0;
 var lang_1 = require("../lang");
+var attribute_1 = require("./attribute");
 var constants_1 = require("../../logger/constants");
 function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
@@ -11,3 +12,14 @@ function validateAttributes(log, maybeAttrs, method) {
     return false;
 }
 exports.validateAttributes = validateAttributes;
+function validateAttributesDeep(log, maybeAttributes, method) {
+    if (!validateAttributes(log, maybeAttributes, method))
+        return false;
+    var result = true;
+    Object.keys(maybeAttributes).forEach(function (attributeKey) {
+        if (!attribute_1.validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+            result = false;
+    });
+    return result;
+}
+exports.validateAttributesDeep = validateAttributesDeep;

package/cjs/utils/inputValidation/eventProperties.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEventProperties = void 0;
 var lang_1 = require("../lang");
+var objectAssign_1 = require("../lang/objectAssign");
 var constants_1 = require("../../logger/constants");
 var ECMA_SIZES = {
     NULL: 0,
@@ -20,7 +21,8 @@ function validateEventProperties(log, maybeProperties, method) {
         return { properties: false, size: BASE_EVENT_SIZE };
     }
     var keys = Object.keys(maybeProperties);
-    var clone = lang_1.shallowClone(maybeProperties);
+    // Shallow clone
+    var clone = objectAssign_1.objectAssign({}, maybeProperties);
     // To avoid calculating the size twice we'll return it from here.
     var output = {
         properties: clone,