@splitsoftware/splitio-commons 1.1.1-rc.0 → 1.2.1-rc.2

package/esm/utils/lang/index.js

@@ -1,4 +1,4 @@
-import { __spreadArrays } from "tslib";
+import { __spreadArray } from "tslib";
 /**
  * Checks if the target string ends with the sub string.
  */
@@ -179,21 +179,10 @@ export function merge(target, source) {
     });
     if (rest && rest.length) {
         var nextSource = rest.splice(0, 1)[0];
-        res = merge.apply(void 0, __spreadArrays([res, nextSource], rest));
+        res = merge.apply(void 0, __spreadArray([res, nextSource], rest, false));
     }
     return res;
 }
-/**
- * Shallow clone an object
- */
-export 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;
-}
 /**
  * Checks if the target string starts with the sub string.
  */

package/esm/utils/murmur3/legacy.js

@@ -0,0 +1,39 @@
+// Deprecated hashing function, used for split bucketing. Replaced by murmur3
+//
+// 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;
+    }
+}
+export 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);
+}
+export function bucket(str, seed) {
+    return Math.abs(hash(str, seed) % 100) + 1;
+}

package/esm/utils/promise/timeout.js

@@ -3,7 +3,7 @@ export 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/utils/settingsValidation/index.js

@@ -64,10 +64,6 @@ var base = {
         impressionsMode: OPTIMIZED,
         localhostMode: undefined
     },
-    runtime: {
-        ip: false,
-        hostname: false
-    },
     // Logger
     log: undefined
 };
@@ -114,8 +110,7 @@ export function settingsValidation(config, validationParams) {
     }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
-    if (runtime)
-        withDefaults.runtime = runtime(withDefaults);
+    withDefaults.runtime = runtime(withDefaults);
     // ensure a valid list of integrations.
     // `integrations` returns an array of valid integration items.
     // @ts-ignore, modify readonly prop

package/esm/utils/settingsValidation/runtime/browser.js

@@ -0,0 +1,6 @@
+export function validateRuntime() {
+    return {
+        ip: false,
+        hostname: false
+    };
+}

package/esm/utils/settingsValidation/runtime/node.js

@@ -0,0 +1,17 @@
+import osFunction from 'os';
+import ipFunction from 'ip';
+import { UNKNOWN, NA, CONSUMER_MODE } from '../../constants';
+export function validateRuntime(settings) {
+    var isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
+    var isConsumerMode = settings.mode === CONSUMER_MODE;
+    // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
+    var ip = ipFunction.address() || (isConsumerMode ? UNKNOWN : false);
+    var hostname = osFunction.hostname() || (isConsumerMode ? UNKNOWN : false);
+    if (!isIPAddressesEnabled) { // If IPAddresses setting is not enabled, set as false (for standalone) or "NA" (for consumer mode, to  be used on Redis keys)
+        ip = hostname = isConsumerMode ? NA : false;
+    }
+    return {
+        ip: ip,
+        hostname: hostname
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.1.1-rc.0",
+  "version": "1.2.1-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -20,8 +20,8 @@
     "check:lint": "eslint src --ext .js,.ts",
     "check:types": "tsc --noEmit",
     "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types --importHelpers",
-    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs --importHelpers",
+    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
+    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
@@ -44,11 +44,12 @@
   "bugs": "https://github.com/splitio/javascript-commons/issues",
   "homepage": "https://github.com/splitio/javascript-commons#readme",
   "dependencies": {
-    "tslib": "^2.1.0"
+    "tslib": "^2.3.1"
   },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
     "@types/ioredis": "^4.28.0",
+    "@types/ip": "^1.1.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
     "@typescript-eslint/eslint-plugin": "^4.2.0",
@@ -58,17 +59,17 @@
     "eslint": "^7.32.0",
     "eslint-plugin-compat": "3.7.0",
     "eslint-plugin-import": "^2.25.3",
-    "fetch-mock": "^9.10.7",
+    "fetch-mock": "^9.11.0",
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "js-yaml": "^3.14.0",
     "lodash": "^4.17.21",
-    "node-fetch": "^2.6.1",
+    "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.0.5",
-    "typescript": "^4.0.2"
+    "typescript": "4.4.4"
   },
   "sideEffects": false
 }

package/src/evaluator/matchers/ew.ts

@@ -1,13 +1,13 @@
 import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
-import { endsWith as strEndsWith } from '../../utils/lang';
+import { endsWith } from '../../utils/lang';
 
 export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function endsWithMatcher(runtimeAttr: string): boolean {
-    let endsWith = ruleAttr.some(e => strEndsWith(runtimeAttr, e));
+    let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
 
-    log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, endsWith]);
+    log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
 
-    return endsWith;
+    return strEndsWith;
   };
 }

package/src/logger/messages/info.ts

@@ -23,10 +23,10 @@ export const codesInfo: [number, string][] = 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/src/logger/types.ts

@@ -9,11 +9,15 @@ export interface ILoggerOptions {
 export interface ILogger {
   setLogLevel(logLevel: LogLevel): void
 
+  debug(msg: unknown): void
   debug(msg: string | number, args?: any[]): void
 
+  info(msg: unknown): void
   info(msg: string | number, args?: any[]): void
 
+  warn(msg: unknown): void
   warn(msg: string | number, args?: any[]): void
 
+  error(msg: unknown): void
   error(msg: string | number, args?: any[]): void
 }

package/src/sdkClient/client.ts

@@ -123,6 +123,7 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
-    track
+    track,
+    isBrowserClient: false
   } as SplitIO.IClient | SplitIO.IAsyncClient;
 }

package/src/sdkClient/clientCS.ts

@@ -23,6 +23,8 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
 
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-    track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key)
+    track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+
+    isBrowserClient: true
   }) as SplitIO.ICsClient;
 }

package/src/services/splitHttpClient.ts

@@ -49,7 +49,7 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
         return response;
       })
       .catch(error => {
-        const resp = error.response;
+        const resp = error && error.response;
         let msg = '';
 
         if (resp) { // An HTTP error

package/src/sync/offline/splitsParser/splitsParserFromFile.ts

@@ -82,7 +82,7 @@ export function splitsParserFromFileFactory(): ISplitsParser {
     try {
       data = fs.readFileSync(filePath, 'utf-8');
     } catch (e) {
-      log.error(e.message);
+      log.error(e && (e as Error).message);
 
       return {};
     }

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -6,9 +6,10 @@ import { IMySegmentsFetcher } from './types';
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments, userMatchingKey: string): IMySegmentsFetcher {
+export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher {
 
   return function mySegmentsFetcher(
+    userMatchingKey: string,
     noCache?: boolean,
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>

package/src/sync/polling/fetchers/types.ts

@@ -15,6 +15,7 @@ export type ISegmentChangesFetcher = (
 ) => Promise<ISegmentChangesResponse[]>
 
 export type IMySegmentsFetcher = (
+  userMatchingKey: string,
   noCache?: boolean,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<string[]>

package/src/sync/polling/pollingManagerCS.ts

@@ -1,26 +1,23 @@
 import { ISegmentsSyncTask, ISplitsSyncTask, IPollingManagerCS } from './types';
 import { forOwn } from '../../utils/lang';
 import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
-import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { ISyncManagerFactoryParams } from '../types';
 
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(
-  splitApi: ISplitApi,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
+  params: ISyncManagerFactoryParams
 ): IPollingManagerCS {
 
+  const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
   const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);

package/src/sync/polling/pollingManagerSS.ts

@@ -1,23 +1,18 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
-import { ISettings } from '../../types';
 import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
 import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
+import { ISyncManagerFactoryParams } from '../types';
 
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
 export function pollingManagerSSFactory(
-  splitApi: ISplitApi,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings
+  params: ISyncManagerFactoryParams
 ): IPollingManager {
 
+  const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
   const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -21,12 +21,13 @@ export function mySegmentsSyncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
-      mySegmentsFetcherFactory(fetchMySegments, matchingKey),
+      mySegmentsFetcherFactory(fetchMySegments),
       storage.splits,
       storage.segments,
       readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
+      matchingKey
     ),
     settings.scheduler.segmentsRefreshRate,
     'mySegmentsUpdater',

package/src/sync/polling/types.ts

@@ -1,7 +1,5 @@
 import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
 import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 
@@ -23,13 +21,3 @@ export interface IPollingManagerCS extends IPollingManager {
   remove(matchingKey: string): void;
   get(matchingKey: string): ISegmentsSyncTask | undefined
 }
-
-/**
- * Signature of polling manager factory/constructor
- */
-export type IPollingManagerFactoryParams = [
-  splitApi: ISplitApi,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
-]

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -23,6 +23,7 @@ export function mySegmentsUpdaterFactory(
   segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
+  matchingKey: string
 ): IMySegmentsUpdater {
 
   let readyOnAlreadyExistentState = true;
@@ -69,7 +70,7 @@ export function mySegmentsUpdaterFactory(
       // If segmentsData is provided, there is no need to fetch mySegments
       new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
-      mySegmentsFetcher(noCache, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 

package/src/sync/streaming/AuthClient/index.ts

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

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -19,7 +19,7 @@ export class SegmentsUpdateWorker implements IUpdateWorker {
    * @param {Object} segmentsCache segments data cache
    * @param {Object} segmentsSyncTask task for syncing segments data
    */
-  constructor(segmentsCache: ISegmentsCacheSync, segmentsSyncTask: ISegmentsSyncTask) {
+  constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync) {
     this.segmentsCache = segmentsCache;
     this.segmentsSyncTask = segmentsSyncTask;
     this.maxChangeNumbers = {};

package/src/sync/streaming/pushManager.ts

@@ -1,7 +1,5 @@
-import { IPushEventEmitter, IPushManagerCS } from './types';
+import { IPushEventEmitter, IPushManager } from './types';
 import { ISSEClient } from './SSEClient/types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
 import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { Backoff } from '../../utils/Backoff';
@@ -12,17 +10,15 @@ import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
 import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { IPlatform } from '../../sdkFactory/types';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
 import { KeyList, UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { ISyncManagerFactoryParams } from '../types';
 
 /**
  * PushManager factory:
@@ -30,17 +26,15 @@ import { IAuthTokenPushEnabled } from './AuthClient/types';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(
+  params: ISyncManagerFactoryParams,
   pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings,
-): IPushManagerCS | undefined {
+): IPushManager | undefined {
+
+  const { settings, storage, splitApi, readiness, platform } = params;
 
   // `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.
-  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined; //
+  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
   const log = settings.log;
 
   let sseClient: ISSEClient;
@@ -51,7 +45,7 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(fetchAuth);
+  const authenticate = authenticateFactory(splitApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
@@ -59,7 +53,8 @@ export function pushManagerFactory(
   sseClient.setEventHandler(sseHandler);
 
   // init workers
-  const segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+  // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+  const segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
   const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
 
@@ -68,11 +63,6 @@ export function pushManagerFactory(
   // [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.
   const clients: Record<string, { hash64: Hash64, worker: MySegmentsUpdateWorker }> = {};
-  if (userKey) {
-    const hash = hashUserKey(userKey);
-    userKeyHashes[hash] = userKey;
-    clients[userKey] = { hash64: hash64(userKey), worker: segmentsUpdateWorker as MySegmentsUpdateWorker };
-  }
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -176,7 +166,7 @@ export function pushManagerFactory(
   function stopWorkers() {
     splitsUpdateWorker.backoff.reset();
     if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
-    else segmentsUpdateWorker.backoff.reset();
+    else (segmentsUpdateWorker as SegmentsUpdateWorker).backoff.reset();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
@@ -306,37 +296,40 @@ export function pushManagerFactory(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter),
     {
-      // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
-
+      // Stop/pause push mode
+      stop() {
+        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() {
         // 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(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
-        clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
-
         const 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 the user is creating several clients 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 multiple clients are created in the current cycle.
+          setTimeout(function checkForReconnect() {
+            if (connectForNewClient) {
+              connectForNewClient = false;
+              connectPush();
+            }
+          }, 0);
+        }
       },
       // [Only for client-side]
       remove(userKey: string) {

package/src/sync/streaming/types.ts

@@ -1,11 +1,7 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { IEventEmitter, ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -45,26 +41,10 @@ export interface IPushEventEmitter extends IEventEmitter {
 }
 
 /**
- * PushManager for server-side
+ * PushManager
  */
-export interface IPushManager extends ITask, IPushEventEmitter { }
-
-/**
- * PushManager for client-side with support for multiple clients
- */
-export interface IPushManagerCS extends IPushManager {
+export interface IPushManager extends ITask, IPushEventEmitter {
+  // Methods used in client-side, to support multiple clients
   add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void,
   remove(userKey: string): void
 }
-
-/**
- * Signature of push manager factory/constructor
- */
-export type IPushManagerFactoryParams = [
-  pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings
-]

package/src/sync/submitters/submitterManager.ts

@@ -2,15 +2,11 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
+import { ISyncManagerFactoryParams } from '../types';
 
-export function submitterManagerFactory(
-  settings: ISettings,
-  storage: IStorageSync,
-  splitApi: ISplitApi,
-) {
+export function submitterManagerFactory(params: ISyncManagerFactoryParams) {
+
+  const { settings, storage, splitApi } = params;
   const log = settings.log;
   const submitters = [
     impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),