@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.11

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,12 +1,12 @@
 // Dynamically require ioredis to prevent strict TypeScript binding
-// and handle module export differences between v4 and v5.
+// and handle module export differences between v4 and later major versions.
 let RedisConstructor: any;
 try {
   const ioredisLib = require('ioredis');
   RedisConstructor = ioredisLib.default || ioredisLib;
 } catch (e) {
   // If we reach here, the peer dependency is missing
-  throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+  throw new Error('ioredis is missing. Please install ioredis v4, v5 or v6.');
 }
 
 import { ILogger } from '../../logger/types';
@@ -31,9 +31,12 @@ const DEFAULT_LIBRARY_OPTIONS = {
   enableOfflineQueue: false,
   connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
   lazyConnect: false,
-  // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
-  // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+  // CRITICAL: v5 and v6 default this to 0 (disabled), which breaks dynamic clusters.
+  // v4 defaulted to 5000. We explicitly set it here to ensure v5 and v6 work like v4.
   slotsRefreshInterval: 5000,
+  // v6 defaults to RESP3 (`protocol: 3`). The SDK doesn't use any RESP3 feature,
+  // so we stick to RESP2 to keep the v4 and v5 behavior. Ignored by v4 and v5.
+  protocol: 2,
 };
 
 interface IRedisCommand {
@@ -45,7 +48,7 @@ interface IRedisCommand {
 
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- * Refactored to use Composition instead of Inheritance to support both v4 and v5.
+ * Refactored to use Composition instead of Inheritance to support v4, v5 and v6.
  */
 export class RedisAdapter {
   // eslint-disable-next-line no-undef -- Index signature to allow proxying dynamic ioredis methods without TS errors

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];
-    }
   };
-
 }

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