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

package/cjs/utils/lang/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uniqueId = exports.uniqAsStrings = exports.uniq = exports.toString = exports.toNumber = exports.startsWith = exports.shallowClone = exports.merge = exports.isString = exports.isObject = exports.isNaNNumber = exports.isIntegerNumber = exports.isFiniteNumber = exports.isBoolean = exports.groupBy = exports.get = exports.forOwn = exports.findIndex = exports.find = exports.endsWith = void 0;
+exports.uniqueId = exports.uniqAsStrings = exports.uniq = exports.toString = exports.toNumber = exports.startsWith = exports.merge = exports.isString = exports.isObject = exports.isNaNNumber = exports.isIntegerNumber = exports.isFiniteNumber = exports.isBoolean = exports.groupBy = exports.get = exports.forOwn = exports.findIndex = exports.find = exports.endsWith = void 0;
 var tslib_1 = require("tslib");
 /**
  * Checks if the target string ends with the sub string.
@@ -199,18 +199,6 @@ function merge(target, source) {
     return res;
 }
 exports.merge = merge;
-/**
- * Shallow clone an object
- */
-function shallowClone(obj) {
-    var keys = Object.keys(obj);
-    var output = {};
-    for (var i = 0; i < keys.length; i++) {
-        output[keys[i]] = obj[keys[i]];
-    }
-    return output;
-}
-exports.shallowClone = shallowClone;
 /**
  * Checks if the target string starts with the sub string.
  */

package/cjs/utils/murmur3/legacy.js

@@ -0,0 +1,44 @@
+"use strict";
+// Deprecated hashing function, used for split bucketing. Replaced by murmur3
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucket = exports.hash = void 0;
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+function ToInteger(x) {
+    x = Number(x);
+    return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+function modulo(a, b) {
+    return a - Math.floor(a / b) * b;
+}
+function ToUint32(x) {
+    return modulo(ToInteger(x), Math.pow(2, 32));
+}
+function ToInt32(x) {
+    var uint32 = ToUint32(x);
+    if (uint32 >= Math.pow(2, 31)) {
+        return uint32 - Math.pow(2, 32);
+    }
+    else {
+        return uint32;
+    }
+}
+function hash(str, seed) {
+    var h = 0;
+    for (var i = 0; i < str.length; i++) {
+        h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+    }
+    return ToInt32(h ^ seed);
+}
+exports.hash = hash;
+function bucket(str, seed) {
+    return Math.abs(hash(str, seed) % 100) + 1;
+}
+exports.bucket = bucket;

package/cjs/utils/promise/timeout.js

@@ -6,7 +6,7 @@ function timeout(ms, promise) {
         return promise;
     return new Promise(function (resolve, reject) {
         var tid = setTimeout(function () {
-            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + "ms."));
+            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + " ms."));
         }, ms);
         promise.then(function (res) {
             clearTimeout(tid);

package/esm/evaluator/matchers/ew.js

@@ -1,9 +1,9 @@
 import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
-import { endsWith as strEndsWith } from '../../utils/lang';
+import { endsWith } from '../../utils/lang';
 export function endsWithMatcherContext(log, ruleAttr) {
     return function endsWithMatcher(runtimeAttr) {
-        var endsWith = ruleAttr.some(function (e) { return strEndsWith(runtimeAttr, e); });
-        log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, endsWith]);
-        return endsWith;
+        var strEndsWith = ruleAttr.some(function (e) { return endsWith(runtimeAttr, e); });
+        log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
+        return strEndsWith;
     };
 }

package/esm/logger/messages/info.js

@@ -20,10 +20,10 @@ export var codesInfo = 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/esm/sdkClient/client.js

@@ -95,6 +95,7 @@ export function clientFactory(params) {
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
-        track: track
+        track: track,
+        isBrowserClient: false
     };
 }

package/esm/sdkClient/clientAttributesDecoration.js

@@ -0,0 +1,104 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { objectAssign } from '../utils/lang/objectAssign';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export function clientAttributesDecoration(log, client) {
+    var attributeStorage = new 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({}, storedAttributes, maybeAttributes);
+        }
+        return maybeAttributes;
+    }
+    return 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 (!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 (!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();
+        }
+    });
+}

package/esm/sdkClient/clientCS.js

@@ -1,4 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
  *
@@ -6,14 +7,16 @@ import { objectAssign } from '../utils/lang/objectAssign';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(client, key, trafficType) {
-    return objectAssign(client, {
+export function clientCSDecorator(log, client, key, trafficType) {
+    var clientCS = clientAttributesDecoration(log, client);
+    return 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
     });
 }

package/esm/sdkClient/sdkClientMethodCS.js

@@ -20,7 +20,7 @@ export 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 = validateKey(log, key, method);
-    var mainClientInstance = clientCSDecorator(sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
     validKey);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -55,7 +55,7 @@ export 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] = clientCSDecorator(sdkClientFactory(objectAssign({}, params, {
+            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -26,7 +26,7 @@ export function sdkClientMethodCSFactory(params) {
     if (trafficType !== undefined) {
         validTrafficType = validateTrafficType(log, trafficType, method);
     }
-    var mainClientInstance = clientCSDecorator(sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
     validKey, validTrafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
@@ -68,7 +68,7 @@ export 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] = clientCSDecorator(sdkClientFactory(objectAssign({}, params, {
+            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/esm/services/splitHttpClient.js

@@ -43,7 +43,7 @@ export 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/esm/storages/inMemory/AttributesCacheInMemory.js

@@ -0,0 +1,67 @@
+import { objectAssign } from '../../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(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;
+}());
+export { AttributesCacheInMemory };

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

@@ -2,8 +2,8 @@
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMySegments, userMatchingKey) {
-    return function mySegmentsFetcher(noCache, 
+export 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/esm/sync/polling/pollingManagerCS.js

@@ -8,7 +8,8 @@ import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
+export function pollingManagerCSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     // Map of matching keys to their corresponding MySegmentsSyncTask.

package/esm/sync/polling/pollingManagerSS.js

@@ -5,7 +5,8 @@ import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logg
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(splitApi, storage, readiness, settings) {
+export function pollingManagerSSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     var segmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);

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

@@ -5,5 +5,5 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments, matchingKey), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }

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

@@ -7,7 +7,7 @@ import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -51,7 +51,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
             // 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/esm/sync/streaming/AuthClient/index.js

@@ -13,8 +13,7 @@ export 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/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -7,7 +7,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/esm/sync/streaming/pushManager.js

@@ -19,10 +19,11 @@ import { hash64 } from '../../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
  */
-export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+export 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 ? getMatching(settings.core.key) : undefined; //
+    var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
     var log = settings.log;
     var sseClient;
     try {
@@ -33,13 +34,14 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(fetchAuth);
+    var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
     // init workers
-    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+    // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = new 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
@@ -47,11 +49,6 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     // [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 = hashUserKey(userKey);
-        userKeyHashes[hash] = userKey;
-        clients[userKey] = { hash64: 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.
@@ -258,33 +255,40 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     return 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: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
+                clients[userKey] = { hash64: hash64(userKey), worker: new 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/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,8 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-export function submitterManagerFactory(settings, storage, splitApi) {
+export function submitterManagerFactory(params) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
     var log = settings.log;
     var submitters = [
         impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/esm/sync/syncManagerOnline.js

@@ -13,26 +13,25 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
     /**
      * 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 = submitterManagerFactory(settings, storage, splitApi);
+        var submitter = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
-            if (!pollingManager.isRunning()) {
-                log.info(SYNC_START_POLLING);
-                pollingManager.start();
+            if (pollingManager.isRunning()) {
+                log.info(SYNC_CONTINUE_POLLING);
             }
             else {
-                log.info(SYNC_CONTINUE_POLLING);
+                log.info(SYNC_START_POLLING);
+                pollingManager.start();
             }
         }
         function stopPollingAndSyncAll() {
@@ -70,7 +69,8 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                submitter && submitter.start();
+                if (submitter)
+                    submitter.start();
                 running = true;
             },
             /**

package/esm/utils/inputValidation/attribute.js

@@ -0,0 +1,16 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+export function validateAttribute(log, attributeKey, attributeValue, method) {
+    if (!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 = isString(attributeValue);
+    var isFiniteVal = isFiniteNumber(attributeValue);
+    var isBoolVal = 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;
+}