@splitsoftware/splitio-commons 3.1.1-rc.3 → 3.1.1-rc.5

package/esm/sync/streaming/pushManager.js

@@ -4,11 +4,10 @@ import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
 import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
-import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
@@ -34,7 +33,6 @@ export function pushManagerFactory(params, pollingManager) {
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(serviceApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
@@ -44,8 +42,6 @@ export function pushManagerFactory(params, pollingManager) {
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
     var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
-    // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
-    var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
@@ -90,7 +86,7 @@ export function pushManagerFactory(params, pollingManager) {
         log.info(STREAMING_CONNECTING);
         disconnected = false;
         var userKeys = userKey ? Object.keys(clients) : undefined;
-        authenticate(userKeys).then(function (authData) {
+        serviceApi.fetchAuth(userKeys).then(function (authData) {
             if (disconnected)
                 return;
             // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
@@ -178,8 +174,11 @@ export function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
+    // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+    // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
     pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
     pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(CONFIG_UPDATE, definitionsUpdateWorker.put);
     pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
@@ -282,9 +281,7 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var hash = hashUserKey(userKey);
-            if (!userKeyHashes[hash]) {
-                userKeyHashes[hash] = userKey;
+            if (!clients[userKey]) {
                 clients[userKey] = {
                     hash64: hash64(userKey),
                     worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -305,8 +302,6 @@ export function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = hashUserKey(userKey);
-            delete userKeyHashes[hash];
             delete clients[userKey];
         }
     });

package/esm/sync/submitters/impressionsSubmitter.js

@@ -20,7 +20,7 @@ export function fromImpressionsCollector(sendLabels, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
                     et: entry.entityType, // Definition type
                 };
             })

package/esm/sync/syncManagerOnline.js

@@ -5,8 +5,6 @@ import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
-import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -14,18 +12,15 @@ import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesF
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
     return function (params) {
         var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.3",
+  "version": "3.1.1-rc.5",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -236,7 +236,7 @@ export interface IDefinition extends TargetingEntity {
   } | null;
   /** Definition classification. Absent means a feature flag. */
   type?: ConfigType;
-  /** Only meaningful when `type === 'AI'`. */
+  /** Only meaningful when `type === 'ai'`. */
   subtype?: ConfigSubtype;
 }
 

package/src/presets/serverSide.ts

@@ -1,4 +1,4 @@
-import { serviceApiFactory } from '../services/serviceApi';
+import { splitApiFactory } from '../services/splitApi';
 import { syncManagerOnlineFactory } from '../sync/syncManagerOnline';
 import { pushManagerFactory } from '../sync/streaming/pushManager';
 import { pollingManagerSSFactory } from '../sync/polling/pollingManagerSS';
@@ -7,11 +7,11 @@ import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
 
-const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 
 export const serverSideModules = {
   storageFactory: InMemoryStorageFactory,
-  serviceApiFactory,
+  serviceApiFactory: splitApiFactory,
   syncManagerFactory: syncManagerOnlineSSFactory,
   sdkManagerFactory,
   sdkClientMethodFactory,

package/src/services/authProvider.ts

@@ -1,6 +1,6 @@
 import { ISplitHttpClient, NetworkError } from './types';
-import { IJwtCredentialV3 } from '../sync/streaming/AuthClient/types';
-import { authenticateFactory } from '../sync/streaming/AuthClient';
+import { IJwtCredential } from '../sync/streaming/AuthClient/types';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 import { Backoff } from '../utils/Backoff';
 import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
 import { ISettings } from '../types';
@@ -9,12 +9,20 @@ import { ITelemetryTracker } from '../trackers/types';
 
 const SKEW_SECONDS = 30;
 
-function isExpired(credential: IJwtCredentialV3): boolean {
+function isExpired(credential: IJwtCredential): boolean {
   return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
 }
 
 export interface IAuthProvider {
-  credential(): Promise<IJwtCredentialV3>;
+  /**
+   * Returns the cached credential, or fetches a new one if there isn't one cached or it's expired,
+   * retrying with backoff on recoverable errors. Used by `secureSplitHttpClient` and `serviceApi.fetchAuth`.
+   */
+  credential(): Promise<IJwtCredential>;
+  /**
+   * Invalidates/clears the cached credential. Used by `secureSplitHttpClient` in the special case of 401 error,
+   * and by `serviceApi.fetchAuth` to force a credential/token refresh.
+   */
   invalidate(): void;
   stop(): void;
 }
@@ -27,20 +35,18 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
 
   const { urls, log } = settings;
 
-  function fetchAuth() {
+  const fetchAuth = fetchAuthFactory(() => {
     let url = `${urls.auth}/api/v3/auth?capabilities=config,aiconfig`;
     return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
-  }
-
-  const authenticate = authenticateFactory(fetchAuth);
+  });
   const backoff = new Backoff(fetchCredential);
 
-  let cachedCredential: IJwtCredentialV3 | undefined;
-  let inFlightPromise: Promise<IJwtCredentialV3> | undefined;
+  let cachedCredential: IJwtCredential | undefined;
+  let inFlightPromise: Promise<IJwtCredential> | undefined;
   let stopped = false;
 
-  function fetchCredential(): Promise<IJwtCredentialV3> {
-    return authenticate().then((credential: IJwtCredentialV3) => {
+  function fetchCredential(): Promise<IJwtCredential> {
+    return fetchAuth().then((credential: IJwtCredential) => {
       log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
       cachedCredential = credential;
       inFlightPromise = undefined;
@@ -62,7 +68,7 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
   }
 
   return {
-    credential(): Promise<IJwtCredentialV3> {
+    credential(): Promise<IJwtCredential> {
       if (cachedCredential && !isExpired(cachedCredential)) {
         return Promise.resolve(cachedCredential);
       }

package/src/services/secureSplitHttpClient.ts

@@ -1,22 +1,14 @@
-import { IRequestOptions, IResponse, ISecureSplitHttpClient, NetworkError } from './types';
-import { ISettings } from '../types';
-import { IPlatform } from '../sdkFactory/types';
-import { splitHttpClientFactory } from './splitHttpClient';
-import { authProviderFactory } from './authProvider';
-import { ITelemetryTracker } from '../trackers/types';
+import { IRequestOptions, IResponse, ISecureSplitHttpClient, ISplitHttpClient, NetworkError } from './types';
+import { IAuthProvider } from './authProvider';
 
 /**
  * Factory of Secure HTTP client, which authenticates requests using a JWT token.
  * On 401 responses, invalidates the cached credential and retries once with a fresh token.
  *
- * @param settings - SDK settings
- * @param platform - object containing environment-specific dependencies
- * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
+ * @param splitHttpClient - `splitHttpClientFactory` to use for making requests
+ * @param authProvider - `authProviderFactory` to use for authentication
  */
-export function secureSplitHttpClientFactory(settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISecureSplitHttpClient {
-
-  const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+export function secureSplitHttpClientFactory(splitHttpClient: ISplitHttpClient, authProvider: IAuthProvider): ISecureSplitHttpClient {
 
   function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker: ((error?: NetworkError) => void) | undefined, logErrorsAsInfo: boolean | undefined, token: string): Promise<IResponse> {
     return splitHttpClient(url, { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } }, latencyTracker, logErrorsAsInfo, true);

package/src/services/serviceApi.ts

@@ -1,40 +1,52 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
-import { ISecureSplitHttpClient, IServiceApi } from './types';
+import { IServiceApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { authProviderFactory } from './authProvider';
+import { secureSplitHttpClientFactory } from './secureSplitHttpClient';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
-function userKeyToQueryParam(userKey: string) {
-  return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
-
 /**
  * Factory of ServiceApi objects, which group the collection of HTTP endpoints used by the SDKs
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
  * @param telemetryTracker - telemetry tracker
- * @param secureSplitHttpClientFactory - factory of SecureSplitHttpClient objects
  */
 export function serviceApiFactory(
   settings: ISettings,
   platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
   telemetryTracker: ITelemetryTracker,
-  secureSplitHttpClientFactory?: (settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker) => ISecureSplitHttpClient,
 ): IServiceApi {
 
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
+
   const splitHttpClient = splitHttpClientFactory(settings, platform);
-  const secureSplitHttpClient = secureSplitHttpClientFactory!(settings, platform, telemetryTracker);
+
+  // Shared authProvider so that the SSE authentication (via `fetchAuth`,
+  // used by `pushManager`) and every authenticated HTTP request to the Configs
+  // API reuse the same cached credential instead of each fetching their own.
+  const authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
+  const secureSplitHttpClient = secureSplitHttpClientFactory(splitHttpClient, authProvider);
+
+  let initialAuth = true;
 
   return {
+    fetchAuth() {
+      // Guard condition to avoid invalidating the cached credential on the first pushManager authentication
+      if (initialAuth) initialAuth = false;
+      else authProvider.invalidate();
+
+      return authProvider.credential();
+    },
+
     // @TODO throw errors if health check requests fail, to log them in the Synchronizer
     getSdkAPIHealthCheck() {
       const url = `${urls.sdk}/api/version`;
@@ -46,15 +58,6 @@ export function serviceApiFactory(
       return splitHttpClient(url).then(() => true).catch(() => false);
     },
 
-    fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/api/v2/auth?s=${settings.sync.flagSpecVersion}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
-      }
-      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-    },
-
     fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
       const url = `${urls.sdk}/api/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))

package/src/services/splitApi.ts

@@ -6,6 +6,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
+import { fetchAuthFactory } from '../sync/streaming/AuthClient';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -33,6 +34,15 @@ export function splitApiFactory(
   const splitHttpClient = splitHttpClientFactory(settings, platform);
 
   return {
+    fetchAuth: fetchAuthFactory((userMatchingKeys?: string[]) => {
+      let url = `${urls.auth}/v2/auth?s=${settings.sync.flagSpecVersion}`;
+      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
+        if (queryParams) url += '&' + queryParams;
+      }
+      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
+    }),
+
     // @TODO throw errors if health check requests fail, to log them in the Synchronizer
     getSdkAPIHealthCheck() {
       const url = `${urls.sdk}/version`;
@@ -44,15 +54,6 @@ export function splitApiFactory(
       return splitHttpClient(url).then(() => true).catch(() => false);
     },
 
-    fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/v2/auth?s=${settings.sync.flagSpecVersion}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-        const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
-      }
-      return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-    },
-
     fetchSplitChanges(since: number, noCache?: boolean, till?: number, rbSince?: number) {
       const url = `${urls.sdk}/splitChanges?s=${settings.sync.flagSpecVersion}&since=${since}${rbSince ? '&rbSince=' + rbSince : ''}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))

package/src/services/types.ts

@@ -1,3 +1,5 @@
+import { IFetchAuth } from '../sync/streaming/AuthClient/types';
+
 export type IRequestOptions = {
 	method?: string,
 	headers?: Record<string, string>,
@@ -35,8 +37,6 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
 
-export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
-
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>

package/src/sync/polling/pollingManagerCS.ts

@@ -10,110 +10,112 @@ import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 import { SdkUpdateMetadata } from '../../../types/splitio';
-import { IDefinitionChangesFetcher } from './fetchers/types';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(
-  params: ISdkFactoryContextSync,
-  definitionChangesFetcher: IDefinitionChangesFetcher
-): IPollingManagerCS {
+  definitionFetcherFactory = splitChangesFetcherFactory,
+): (params: ISdkFactoryContextSync) => IPollingManagerCS {
 
-  const { serviceApi, storage, readiness, settings } = params;
-  const log = settings.log;
+  return function (params: ISdkFactoryContextSync): IPollingManagerCS {
+    const { serviceApi, storage, readiness, settings } = params;
+    const log = settings.log;
 
-  const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
+    const definitionChangesFetcher = definitionFetcherFactory(params);
+    const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
+    // Map of matching keys to their corresponding MySegmentsSyncTask.
+    const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
 
-  const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
+    const matchingKey = getMatching(settings.core.key);
+    const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
-  function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      mySegmentsSyncTask.start();
-    });
-  }
+    function startMySegmentsSyncTasks() {
+      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+        mySegmentsSyncTask.start();
+      });
+    }
 
-  function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
-    });
-  }
-
-  // smart pausing
-  readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
-    if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
-    const usingSegments = usesSegmentsSync(storage);
-    if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-      log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-      if (usingSegments) {
-        startMySegmentsSyncTasks();
-      } else {
-        stopMySegmentsSyncTasks();
-      }
+    function stopMySegmentsSyncTasks() {
+      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+        if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
+      });
     }
-  });
 
-  function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+    // smart pausing
+    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
+      if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
+      const usingSegments = usesSegmentsSync(storage);
+      if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+        log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+        if (usingSegments) {
+          startMySegmentsSyncTasks();
+        } else {
+          stopMySegmentsSyncTasks();
+        }
+      }
+    });
+
+    function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
+      const mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
-    // smart ready
-    function smartReady(metadata: SdkUpdateMetadata) {
-      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+      // smart ready
+      function smartReady(metadata: SdkUpdateMetadata) {
+        if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+      }
+      if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
+      else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
+
+      mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+      return mySegmentsSyncTask;
     }
-    if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
-    else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
 
-    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-    return mySegmentsSyncTask;
-  }
+    return {
+      definitionsSyncTask,
+      segmentsSyncTask: mySegmentsSyncTask,
 
-  return {
-    definitionsSyncTask,
-    segmentsSyncTask: mySegmentsSyncTask,
+      // Start periodic fetching (polling)
+      start() {
+        log.info(POLLING_START);
 
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
+        definitionsSyncTask.start();
+        if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
+      },
 
-      definitionsSyncTask.start();
-      if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
-    },
+      // Stop periodic fetching (polling)
+      stop() {
+        log.info(POLLING_STOP);
 
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
+        if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
+        stopMySegmentsSyncTasks();
+      },
 
-      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
-      stopMySegmentsSyncTasks();
-    },
+      // Used by SyncManager to know if running in polling mode.
+      isRunning: definitionsSyncTask.isRunning,
 
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: definitionsSyncTask.isRunning,
+      // fetch definitions and segments
+      syncAll() {
+        const promises = [definitionsSyncTask.execute()];
+        forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+          promises.push(mySegmentsSyncTask.execute());
+        });
+        return Promise.all(promises);
+      },
 
-    // fetch definitions and segments
-    syncAll() {
-      const promises = [definitionsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-        promises.push(mySegmentsSyncTask.execute());
-      });
-      return Promise.all(promises);
-    },
+      // Support for handling mySegments sync of multiple clients
+      add,
 
-    // Support for handling mySegments sync of multiple clients
-    add,
+      remove(matchingKey: string) {
+        delete mySegmentsSyncTasks[matchingKey];
+      },
 
-    remove(matchingKey: string) {
-      delete mySegmentsSyncTasks[matchingKey];
-    },
+      get(matchingKey: string) {
+        return mySegmentsSyncTasks[matchingKey];
+      }
+    };
 
-    get(matchingKey: string) {
-      return mySegmentsSyncTasks[matchingKey];
-    }
   };
-
 }