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

package/src/sync/polling/pollingManagerSS.ts

@@ -3,57 +3,61 @@ import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { IPollingManager, ISegmentsSyncTask, IDefinitionsSyncTask } from './types';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IDefinitionChangesFetcher, ISegmentChangesFetcher } from './fetchers/types';
+import { segmentChangesFetcherFactory } from './fetchers/segmentChangesFetcher';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
 export function pollingManagerSSFactory(
-  params: ISdkFactoryContextSync,
-  definitionChangesFetcher: IDefinitionChangesFetcher,
-  segmentChangesFetcher: ISegmentChangesFetcher
-): IPollingManager {
-
-  const { storage, readiness, settings } = params;
-  const log = settings.log;
-
-  const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
-  const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-
-  return {
-    definitionsSyncTask,
-    segmentsSyncTask,
-
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `${definitionChangesFetcher.type} will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
-
-      const startingUp = definitionsSyncTask.start();
-      if (startingUp) {
-        startingUp.then(() => {
-          if (definitionsSyncTask.isRunning()) segmentsSyncTask.start();
+  definitionFetcherFactory = splitChangesFetcherFactory,
+  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges)
+): (params: ISdkFactoryContextSync) => IPollingManager {
+
+  return function (params: ISdkFactoryContextSync): IPollingManager {
+    const { storage, readiness, settings } = params;
+    const log = settings.log;
+
+    const definitionChangesFetcher = definitionFetcherFactory(params);
+    const segmentChangesFetcher = segmentFetcherFactory(params);
+    const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+    const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+
+    return {
+      definitionsSyncTask,
+      segmentsSyncTask,
+
+      // Start periodic fetching (polling)
+      start() {
+        log.info(POLLING_START);
+        log.debug(LOG_PREFIX_SYNC_POLLING + `${definitionChangesFetcher.type} will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
+        log.debug(LOG_PREFIX_SYNC_POLLING + `segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
+
+        const startingUp = definitionsSyncTask.start();
+        if (startingUp) {
+          startingUp.then(() => {
+            if (definitionsSyncTask.isRunning()) segmentsSyncTask.start();
+          });
+        }
+      },
+
+      // Stop periodic fetching (polling)
+      stop() {
+        log.info(POLLING_STOP);
+
+        if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
+        if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
+      },
+
+      // Used by SyncManager to know if running in polling mode.
+      isRunning: definitionsSyncTask.isRunning,
+
+      syncAll() {
+        // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+        return definitionsSyncTask.execute().then(() => {
+          return segmentsSyncTask.execute();
         });
       }
-    },
-
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
-
-      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
-      if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
-    },
-
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: definitionsSyncTask.isRunning,
-
-    syncAll() {
-      // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-      return definitionsSyncTask.execute().then(() => {
-        return segmentsSyncTask.execute();
-      });
-    }
+    };
   };
 }

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

@@ -9,7 +9,7 @@ import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_FETCH_RETRY } from '../
 import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
+import { RB_SEGMENT_UPDATE } from '../../streaming/constants';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
 import { ISplit } from '../fetchers/splitChangesFetcher';
 import { ISegmentsSyncTask } from '../types';
@@ -154,14 +154,14 @@ export function definitionChangesUpdaterFactory(
 
       return Promise.resolve(
         instantUpdate ?
-          instantUpdate.type === SPLIT_UPDATE ?
+          instantUpdate.type === RB_SEGMENT_UPDATE ?
+            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
             // IFFU edge case: a change to definition that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
             Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then((contains) => {
               return contains ?
                 { d: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['d'] } :
                 definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
             }) :
-            { rbs: convertInstantUpdateToDefinitionChanges(instantUpdate) as IDefinitionChangesResponse['rbs'] } :
           definitionChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
         .then((definitionChanges: IDefinitionChangesResponse) => {

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

@@ -47,7 +47,7 @@ export function segmentChangesUpdaterFactory(
         false :
         segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
           return Promise.all(changes.map(x => {
-            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with since = ${x.since} and till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);

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

@@ -1,22 +1,20 @@
-import { IFetchAuth } from '../../../services/types';
-import { IAuthenticate, IJwtCredentialV2 } from './types';
+import { IJwtCredential, IFetchAuth } from './types';
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { encodeToBase64 } from '../../../utils/base64';
 import { decodeJWTtoken } from '../../../utils/jwt';
-import { hash } from '../../../utils/murmur3/murmur3';
+import { IResponse } from '../../../services/types';
 
 /**
  * Factory of authentication function.
  *
- * @param fetchAuth - `ServiceApi.fetchAuth` endpoint
+ * @param fetchAuth - /auth endpoint
  */
-export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
+export function fetchAuthFactory(fetchAuth: (userKeys?: string[]) => Promise<IResponse>): IFetchAuth {
 
   /**
    * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
    * @param userKeys - set of user Keys to track membership updates. It is undefined for server-side API.
    */
-  return function authenticate(userKeys?: string[]): Promise<IJwtCredentialV2> {
+  return function authenticate(userKeys?: string[]): Promise<IJwtCredential> {
     return fetchAuth(userKeys)
       .then(resp => resp.json())
       .then(json => {
@@ -24,19 +22,20 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
           const decodedToken = decodeJWTtoken(json.token);
           if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
           const channels = JSON.parse(decodedToken['x-ably-capability']);
-          return objectAssign({
+          const credential = objectAssign({
             decodedToken,
             channels
           }, json);
+          // The `/api/v3/auth` endpoint nests the streaming settings under `config.streaming`. Normalize
+          // them into the flat `pushEnabled`/`connDelay` properties used by the PushManager.
+          const streaming = credential.config && credential.config.streaming;
+          if (streaming) {
+            credential.pushEnabled = streaming.enabled;
+            credential.connDelay = streaming.delay;
+          }
+          return credential;
         }
         return json;
       });
   };
 }
-
-/**
- * Returns the hash of a given user key
- */
-export function hashUserKey(userKey: string): string {
-  return encodeToBase64(hash(userKey, 0).toString());
-}

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

@@ -1,23 +1,19 @@
 import { IDecodedJWTToken } from '../../../utils/jwt/types';
 
-export type IJwtCredentialV2 = {
-  pushEnabled: boolean
-  token: string // empty string ("") when `"pushEnabled": false`
-  decodedToken: IDecodedJWTToken
-  channels: { [channel: string]: string[] }
-  connDelay?: number
-}
-
-export type IJwtCredentialV3 = {
-  token: string
+export type IJwtCredential = {
+  token: string; // empty string ("") when `"pushEnabled": false`
   decodedToken: IDecodedJWTToken
   channels: { [channel: string]: string[] }
+  // /api/v2/auth fields
+  pushEnabled?: boolean | null;
+  connDelay?: number | null;
+  // /api/v3/auth fields
   config?: {
     streaming?: {
-      delay?: number
-      enabled?: boolean
+      delay?: number | null;
+      enabled?: boolean | null;
     } | null;
   } | null;
 }
 
-export type IAuthenticate = (userKeys?: string[]) => Promise<IJwtCredentialV2>
+export type IFetchAuth = (userKeys?: string[]) => Promise<IJwtCredential>

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

@@ -5,7 +5,7 @@ import { ISettings } from '../../../types';
 import { checkIfServerSide } from '../../../utils/key';
 import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { IJwtCredentialV2 } from '../AuthClient/types';
+import { IJwtCredential } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
 const ABLY_API_VERSION = '1.1';
@@ -66,7 +66,7 @@ export class SSEClient implements ISSEClient {
   /**
    * Open the connection with a given authToken
    */
-  open(authToken: IJwtCredentialV2) {
+  open(authToken: IJwtCredential) {
     this.close(); // it closes connection if previously opened
 
     const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {

package/src/sync/streaming/SSEClient/types.ts

@@ -1,4 +1,4 @@
-import { IJwtCredentialV2 } from '../AuthClient/types';
+import { IJwtCredential } from '../AuthClient/types';
 
 export interface ISseEventHandler {
   handleError: (ev: Event) => any;
@@ -7,7 +7,7 @@ export interface ISseEventHandler {
 }
 
 export interface ISSEClient {
-  open(authToken: IJwtCredentialV2): void,
+  open(authToken: IJwtCredential): void,
   close(): void,
   setEventHandler(handler: ISseEventHandler): void
 }

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -80,6 +80,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
+        case CONFIG_UPDATE:
         case SEGMENT_UPDATE:
         case MEMBERSHIPS_MS_UPDATE:
         case MEMBERSHIPS_LS_UPDATE:

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, CONFIG_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -42,7 +42,7 @@ export interface ISegmentUpdateData {
 }
 
 export interface ISplitUpdateData {
-  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
+  type: SPLIT_UPDATE | CONFIG_UPDATE | RB_SEGMENT_UPDATE,
   changeNumber: number,
   pcn?: number,
   d?: string,

package/src/sync/streaming/constants.ts

@@ -30,6 +30,7 @@ export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
+export const CONFIG_UPDATE = 'CONFIG_UPDATE';
 export const RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper

package/src/sync/streaming/pushManager.ts

@@ -7,16 +7,15 @@ 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 { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IJwtCredentialV2 } from './AuthClient/types';
+import { IJwtCredential } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -45,7 +44,6 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(serviceApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
@@ -58,8 +56,6 @@ export function pushManagerFactory(
   // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
   const 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
-  const userKeyHashes: Record<string, string> = {};
   // [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.
   const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
@@ -81,7 +77,7 @@ export function pushManagerFactory(
   let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
   let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
 
-  function scheduleTokenRefreshAndSse(authData: IJwtCredentialV2) {
+  function scheduleTokenRefreshAndSse(authData: IJwtCredential) {
     // clear scheduled tasks if exist
     if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
@@ -113,41 +109,37 @@ export function pushManagerFactory(
     disconnected = false;
 
     const userKeys = userKey ? Object.keys(clients) : undefined;
-    authenticate(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
-        // close the sseClient in case the org has been bloqued while the instance was connected to streaming
-        if (!authData.pushEnabled) {
-          log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
-          return;
-        }
-
-        // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
-        if (userKeys && userKeys.length < Object.keys(clients).length) return;
+    serviceApi.fetchAuth(userKeys).then((authData) => {
+      if (disconnected) return;
 
-        // Schedule SSE connection and refresh token
-        scheduleTokenRefreshAndSse(authData);
+      // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+      // close the sseClient in case the org has been bloqued while the instance was connected to streaming
+      if (!authData.pushEnabled) {
+        log.info(STREAMING_DISABLED);
+        pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
+        return;
       }
-    ).catch(
-      function (error) {
-        if (disconnected) return;
 
-        log.error(ERROR_STREAMING_AUTH, [error.message]);
+      // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
+      if (userKeys && userKeys.length < Object.keys(clients).length) return;
 
-        // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
-        if (error.statusCode >= 400 && error.statusCode < 500) {
-          telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
-          return;
-        }
+      // Schedule SSE connection and refresh token
+      scheduleTokenRefreshAndSse(authData);
+    }).catch((error) => {
+      if (disconnected) return;
 
-        // Handle other HTTP and network errors as recoverable errors
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
+      log.error(ERROR_STREAMING_AUTH, [error.message]);
+
+      // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
+      if (error.statusCode >= 400 && error.statusCode < 500) {
+        telemetryTracker.streamingEvent(AUTH_REJECTION);
+        pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
+        return;
       }
-    );
+
+      // Handle other HTTP and network errors as recoverable errors
+      pushEmitter.emit(PUSH_RETRYABLE_ERROR);
+    });
   }
 
   // close SSE connection and cancel scheduled tasks
@@ -218,8 +210,11 @@ export function pushManagerFactory(
 
   /** 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: IMembershipMSUpdateData | IMembershipLSUpdateData) {
@@ -324,10 +319,7 @@ export function pushManagerFactory(
 
       // [Only for client-side]
       add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
-        const hash = hashUserKey(userKey);
-
-        if (!userKeyHashes[hash]) {
-          userKeyHashes[hash] = userKey;
+        if (!clients[userKey]) {
           clients[userKey] = {
             hash64: hash64(userKey),
             worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -349,8 +341,6 @@ export function pushManagerFactory(
       },
       // [Only for client-side]
       remove(userKey: string) {
-        const hash = hashUserKey(userKey);
-        delete userKeyHashes[hash];
         delete clients[userKey];
       }
     }

package/src/sync/streaming/types.ts

@@ -16,19 +16,20 @@ export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
+export type CONFIG_UPDATE = 'CONFIG_UPDATE';
 export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | CONFIG_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
   T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
-  T extends SPLIT_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_UPDATE | CONFIG_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**

package/src/sync/submitters/impressionsSubmitter.ts

@@ -1,14 +1,14 @@
 import { groupBy, forOwn } from '../../utils/lang';
 import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
-import { ImpressionsPayload } from './types';
+import { EntityType, ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, data: (SplitIO.ImpressionDTO & { entityType?: EntityType })[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 
@@ -25,7 +25,7 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           b: entry.bucketingKey, // Bucketing Key
           pt: entry.pt, // Previous time
           properties: entry.properties, // 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/src/sync/submitters/types.ts

@@ -3,7 +3,7 @@ import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
-type EntityType = 'config' | 'flag' | 'ai-config';
+export type EntityType = 'config' | 'flag' | 'ai-config';
 
 type ImpressionPayload = {
   /** Matching Key */

package/src/sync/syncManagerOnline.ts

@@ -11,9 +11,6 @@ import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
-import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { IDefinitionChangesFetcher, ISegmentChangesFetcher } from './polling/fetchers/types';
-import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 
 /**
  * Online SyncManager factory.
@@ -22,13 +19,10 @@ 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?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher, segmentChangesFetcher: ISegmentChangesFetcher) => IPollingManager,
+  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
-  definitionFetcherFactory = splitChangesFetcherFactory,
-  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges)
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -39,7 +33,7 @@ export function syncManagerOnlineFactory(
     const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?