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

package/esm/utils/inputValidation/attributes.js

@@ -1,4 +1,5 @@
 import { isObject } from '../lang';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 export function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
@@ -7,3 +8,13 @@ export function validateAttributes(log, maybeAttrs, method) {
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
     return false;
 }
+export function validateAttributesDeep(log, maybeAttributes, method) {
+    if (!validateAttributes(log, maybeAttributes, method))
+        return false;
+    var result = true;
+    Object.keys(maybeAttributes).forEach(function (attributeKey) {
+        if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+            result = false;
+    });
+    return result;
+}

package/esm/utils/inputValidation/eventProperties.js

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
 var ECMA_SIZES = {
     NULL: 0,
@@ -17,7 +18,8 @@ export function validateEventProperties(log, maybeProperties, method) {
         return { properties: false, size: BASE_EVENT_SIZE };
     }
     var keys = Object.keys(maybeProperties);
-    var clone = shallowClone(maybeProperties);
+    // Shallow clone
+    var clone = objectAssign({}, maybeProperties);
     // To avoid calculating the size twice we'll return it from here.
     var output = {
         properties: clone,

package/esm/utils/lang/index.js

@@ -183,17 +183,6 @@ export function merge(target, source) {
     }
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.1.0",
+  "version": "1.2.1-rc.1",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,8 +24,8 @@
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs --importHelpers",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
-    "publish:stable": "npm run check && npm run test && npm run build && npm publish"
+    "publish:rc": "npm run check && npm run build && npm run test && npm publish --tag rc",
+    "publish:stable": "npm run check && npm run build && npm run test && npm publish"
   },
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
     "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",

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/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/clientAttributesDecoration.ts

@@ -0,0 +1,122 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+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<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
+
+  const attributeStorage = new AttributesCacheInMemory();
+
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  const clientTrack = client.track;
+
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+  }
+
+  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
+    const 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(attributeName: string, attributeValue: Object) {
+      const attribute: Record<string, Object> = {};
+      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(attributeName: string) {
+      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(attributes: Record<string, Object>) {
+      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(): Record<string, Object> {
+      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(attributeName: string) {
+      log.debug(`removed attribute ${attributeName}`);
+      return attributeStorage.removeAttribute(attributeName + '');
+    },
+
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes() {
+      return attributeStorage.clear();
+    }
+    
+  });
+
+}

package/src/sdkClient/clientCS.ts

@@ -1,5 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
 /**
@@ -9,15 +11,20 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
-  return objectAssign(client, {
+export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
+
+  let 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
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -29,6 +29,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   const validKey = validateKey(log, key, method);
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey
   );
@@ -74,6 +75,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // 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(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -35,6 +35,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   }
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey,
     validTrafficType
@@ -88,6 +89,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // 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(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

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/storages/inMemory/AttributesCacheInMemory.ts

@@ -0,0 +1,73 @@
+import { objectAssign } from '../../utils/lang/objectAssign';
+
+export class AttributesCacheInMemory {
+
+  private attributesCache: Record<string, Object> = {};
+
+
+  /**
+   * 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 
+   */
+  setAttribute(attributeName: string, attributeValue: Object): boolean {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+
+  /**
+   * Retrieves the value of a given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  getAttribute(attributeName: string): Object {
+    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
+   */
+  setAttributes(attributes: Record<string, Object>): boolean {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   * 
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll(): Record<string, Object> {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   * 
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  removeAttribute(attributeName: string): boolean {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clears all attributes stored in the SDK
+   * 
+   */
+  clear() {
+    this.attributesCache = {};
+    return true;
+  }
+
+}

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 = {};