@splitsoftware/splitio-commons 1.16.1-rc.0 → 1.16.1-rc.10

package/src/sync/polling/types.ts

@@ -1,4 +1,4 @@
-import { ISplit } from '../../dtos/types';
+import { IMembershipsResponse, ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { ITask, ISyncTask } from '../types';
@@ -7,27 +7,28 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
-export type MySegmentsData = string[] | {
+export type MySegmentsData = IMembershipsResponse | {
+  /* segment type */
+  isLS?: boolean
   /* segment name */
-  name: string,
+  name: string
   /* action: `true` for add, and `false` for delete */
   add: boolean
-}
+}[]
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
   segmentsSyncTask: ISyncTask
-  largeSegmentsSyncTask?: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
   remove(matchingKey: string): void;
-  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
+  get(matchingKey: string): IMySegmentsSyncTask | undefined
 }

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

@@ -1,6 +1,8 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
+import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
+import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
@@ -16,13 +18,14 @@ type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => P
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  storage: IStorageSync,
+  segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
 ): IMySegmentsUpdater {
 
+  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -37,24 +40,25 @@ export function mySegmentsUpdaterFactory(
 
     let shouldNotifyUpdate;
     if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+      // Add/Delete the segment names
+      segmentsData.forEach(({ isLS, name, add }) => {
+        const cache = isLS ? largeSegments : segments;
+        if (cache!.isInSegment(name) !== add) {
+          shouldNotifyUpdate = true;
+          if (add) cache!.addToSegment(name);
+          else cache!.removeFromSegment(name);
+        }
+      });
     } else {
-      // Add/Delete the segment
-      const { name, add } = segmentsData;
-      if (mySegmentsCache.isInSegment(name) !== add) {
-        shouldNotifyUpdate = true;
-        if (add) mySegmentsCache.addToSegment(name);
-        else mySegmentsCache.removeFromSegment(name);
-      } else {
-        shouldNotifyUpdate = false;
-      }
+      // Reset the list of segment names
+      shouldNotifyUpdate = segments.resetSegments((segmentsData.ms?.k || []).map((segment) => segment.n), segmentsData.ms?.cn);
+      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData.ls?.k || []).map((segment) => segment.n), segmentsData.ls?.cn) || shouldNotifyUpdate;
     }
 
     // Notify update if required
-    if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      notifyUpdate();
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 
@@ -94,14 +98,8 @@ export function mySegmentsUpdaterFactory(
    *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
    * @param {boolean | undefined} noCache true to revalidate data to fetch
    */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, delay?: number) {
-    return delay ?
-      new Promise(res => {
-        setTimeout(() => {
-          _mySegmentsUpdater(0, segmentsData, noCache).then(res);
-        }, delay);
-      }) :
-      _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
+    return _mySegmentsUpdater(0, segmentsData, noCache);
   };
 
 }

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

@@ -76,12 +76,10 @@ export class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    const channelsQueryParam = Object.keys(authToken.channels).map(
-      function (channel) {
-        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-        return encodeURIComponent(params + channel);
-      }
-    ).join(',');
+    const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {
+      const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+      return encodeURIComponent(params + channel);
+    }).join(',');
     const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
 
     this.connection = new this.eventSource!(

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

@@ -1,9 +1,9 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE_V3, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { INotificationError, INotificationMessage } from './types';
+import { IControlData, INotificationError, INotificationMessage, IOccupancyData } from './types';
 import { ILogger } from '../../../logger/types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
@@ -74,29 +74,27 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       const { parsedData, data, channel, timestamp } = messageWithParsedData;
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
-      // we only handle update events if streaming is up.
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
-        return;
+      // we only handle update events if streaming is up
+      // @ts-expect-error
+      const type = parsedData.type || parsedData.t;
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1) return;
 
-      switch (parsedData.type) {
+      switch (type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MY_SEGMENTS_UPDATE_V2:
+        case MY_SEGMENTS_UPDATE_V3:
         case MY_LARGE_SEGMENTS_UPDATE:
         case SPLIT_KILL:
-          pushEmitter.emit(parsedData.type, parsedData);
-          break;
-        case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(parsedData.type, parsedData, channel);
+          pushEmitter.emit(type, parsedData);
           break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
+          notificationKeeper.handleOccupancyEvent((parsedData as IOccupancyData).metrics.publishers, channel, timestamp);
           break;
         case CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
+          notificationKeeper.handleControlEvent((parsedData as IControlData).controlType, channel, timestamp);
           break;
 
         default:

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

@@ -1,12 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE } from '../types';
-
-export interface IMySegmentsUpdateData {
-  type: MY_SEGMENTS_UPDATE,
-  changeNumber: number,
-  includesPayload: boolean,
-  segmentList?: string[]
-}
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V3 } from '../types';
 
 export enum Compression {
   None = 0,
@@ -26,27 +19,22 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-export interface IMySegmentsUpdateV2Data {
-  type: MY_SEGMENTS_UPDATE_V2,
-  changeNumber: number,
-  segmentName: string,
-  c: Compression,
-  d: string,
-  u: UpdateStrategy,
-}
-
-export interface IMyLargeSegmentsUpdateData {
-  type: MY_LARGE_SEGMENTS_UPDATE,
-  changeNumber: number,
-  largeSegments: string[],
-  c: Compression,
-  d: string,
+interface IMySegmentsUpdateData<T extends string> {
+  t: T,
+  cn: number,
+  n?: string[],
+  c?: Compression,
+  d?: string,
   u: UpdateStrategy,
   i?: number, // time interval in millis
-  h?: number, // hash function. 0 for murmur3_32, 1 for murmur3_64
+  h?: number, // hash function
   s?: number, // seed for hash function
 }
 
+export interface IMySegmentsUpdateV3Data extends IMySegmentsUpdateData<MY_SEGMENTS_UPDATE_V3> { }
+
+export interface IMyLargeSegmentsUpdateData extends IMySegmentsUpdateData<MY_LARGE_SEGMENTS_UPDATE> { }
+
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -80,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }

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

@@ -7,7 +7,7 @@ import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -15,6 +15,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
   let isHandlingEvent: boolean;
   let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
   let _delay: undefined | number;
+  let _delayTimeoutID: any;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {
@@ -24,9 +25,18 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       const currentMaxChangeNumber = maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      mySegmentsSyncTask.execute(_segmentsData, true, _delay).then((result) => {
+      const syncTask = _delay ?
+        new Promise(res => {
+          _delayTimeoutID = setTimeout(() => {
+            _delay = undefined;
+            mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+          }, _delay);
+        }) :
+        mySegmentsSyncTask.execute(_segmentsData, true);
+
+      syncTask.then((result) => {
         if (!isHandlingEvent) return; // halt if `stop` has been called
-        if (result !== false) {// Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+        if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
           if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(updateType);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
         }
@@ -43,13 +53,15 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
   return {
     /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+     * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
      *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
+     * @param changeNumber change number of the notification
+     * @param segmentsData data for KeyList or SegmentRemoval instant updates
+     * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
      */
     put(changeNumber: number, segmentsData?: MySegmentsData, delay?: number) {
-      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+      // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay) return;
 
       maxChangeNumber = changeNumber;
       handleNewEvent = true;
@@ -61,6 +73,8 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
     },
 
     stop() {
+      clearTimeout(_delayTimeoutID);
+      _delay = undefined;
       isHandlingEvent = false;
       backoff.reset();
     }

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

@@ -9,7 +9,7 @@ import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {

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

@@ -14,7 +14,7 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: any[]): void // handle new update event
+  put(...args: T): void // handle new update event
 }

package/src/sync/streaming/constants.ts

@@ -25,8 +25,7 @@ export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 
 // Update-type push notifications, handled by NotificationProcessor
-export const MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export const MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export const MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';

package/src/sync/streaming/parseUtils.ts

@@ -1,6 +1,8 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
-import { Compression, KeyList } from './SSEHandler/types';
+import { hash } from '../../utils/murmur3/murmur3';
+import { Compression, IMyLargeSegmentsUpdateData, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -42,7 +44,7 @@ function decompress(data: string, compression: Compression) {
  * @returns {{a?: string[], r?: string[] }}
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss: boolean = true): KeyList {
+export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
   const binKeyList = decompress(data, compression);
   let strKeyList = Uint8ArrayToString(binKeyList);
   // replace numbers to strings, to avoid losing precision
@@ -80,14 +82,20 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined {
-  const avoidPrecisionLoss = false;
-  if (compression > 0)
-    return parseKeyList(data, compression, avoidPrecisionLoss);
-  else
-    return JSON.parse(decodeFromBase64(data));
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
+  return compression > 0 ?
+    parseKeyList(data, compression, false) :
+    JSON.parse(decodeFromBase64(data));
+}
+
+const DEFAULT_MAX_INTERVAL = 60000;
+
+export function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
+  if (parsedData.h === 0) return 0;
+
+  const interval = parsedData.i || DEFAULT_MAX_INTERVAL;
+  const seed = parsedData.s || 0;
+
+  return hash(matchingKey, seed) % interval;
 }

package/src/sync/streaming/pushManager.ts

@@ -11,25 +11,15 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
-import { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV2Data, KeyList, UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
+import { MY_SEGMENTS_UPDATE_V3, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV3Data, KeyList, UpdateStrategy } from './SSEHandler/types';
+import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
-import { hash } from '../../utils/murmur3/murmur3';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IUpdateWorker } from './UpdateWorkers/types';
-
-export function getDelay(parsedData: IMyLargeSegmentsUpdateData, matchingKey: string) {
-  const interval = parsedData.i || 60000;
-  // const hashType = parsedData.h || 0;
-  const seed = parsedData.s || 0;
-
-  return hash(matchingKey, seed) % interval;
-}
 
 /**
  * PushManager factory:
@@ -72,8 +62,8 @@ export function pushManagerFactory(
   // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_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 MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker, workerLarge?: IUpdateWorker }> = {};
+  // Hash64 is used to process MY_SEGMENTS_UPDATE events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker>, workerLarge: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -182,7 +172,7 @@ export function pushManagerFactory(
     splitsUpdateWorker.stop();
     if (userKey) forOwn(clients, ({ worker, workerLarge }) => {
       worker.stop();
-      workerLarge && workerLarge.stop();
+      workerLarge.stop();
     });
     else segmentsUpdateWorker!.stop();
   }
@@ -248,24 +238,22 @@ export function pushManagerFactory(
     splitsUpdateWorker.put(parsedData);
   });
 
-  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData) {
-    const isLS = parsedData.type === MY_LARGE_SEGMENTS_UPDATE;
+  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData) {
+    const isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
 
     switch (parsedData.u) {
       case UpdateStrategy.BoundedFetchRequest: {
         let bitmap: Uint8Array;
         try {
-          bitmap = parseBitmap(parsedData.d, parsedData.c);
+          bitmap = parseBitmap(parsedData.d!, parsedData.c!);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['BoundedFetchRequest', e]);
           break;
         }
 
         forOwn(clients, ({ hash64, worker, workerLarge }, matchingKey) => {
           if (isInBitmap(bitmap, hash64.hex)) {
-            isLS ?
-              workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-              worker.put(parsedData.changeNumber);
+            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
           }
         });
         return;
@@ -273,72 +261,56 @@ export function pushManagerFactory(
       case UpdateStrategy.KeyList: {
         let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
         try {
-          keyList = parseKeyList(parsedData.d, parsedData.c);
+          keyList = parseKeyList(parsedData.d!, parsedData.c!);
           added = new _Set(keyList.a);
           removed = new _Set(keyList.r);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+          break;
+        }
+
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', 'No segment name was provided']);
           break;
         }
 
         forOwn(clients, ({ hash64, worker, workerLarge }) => {
           const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
           if (add !== undefined) {
-            isLS ?
-              workerLarge && workerLarge.put(parsedData.changeNumber, {
-                name: parsedData.largeSegments[0],
-                add
-              }) :
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add
-              });
+            (isLS ? workerLarge : worker).put(parsedData.cn, [{
+              isLS,
+              name: parsedData.n![0],
+              add,
+            }]);
           }
         });
         return;
       }
       case UpdateStrategy.SegmentRemoval:
-        if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+        if (!parsedData.n || !parsedData.n.length) {
+          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
           break;
         }
 
         forOwn(clients, ({ worker, workerLarge }) => {
-          isLS ?
-            workerLarge && parsedData.largeSegments.forEach(largeSegment => {
-              workerLarge.put(parsedData.changeNumber, {
-                name: largeSegment,
-                add: false
-              });
-            }) :
-            worker.put(parsedData.changeNumber, {
-              name: parsedData.segmentName,
-              add: false
-            });
+          (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n!.map(largeSegment => ({
+            isLS,
+            name: largeSegment,
+            add: false,
+            cn: parsedData.cn
+          })));
         });
         return;
     }
 
     // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
     forOwn(clients, ({ worker, workerLarge }, matchingKey) => {
-      isLS ?
-        workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-        worker.put(parsedData.changeNumber);
+      (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
     });
   }
 
   if (userKey) {
-    pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-      const userKeyHash = channel.split('_')[2];
-      const userKey = userKeyHashes[userKeyHash];
-      if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-        clients[userKey].worker.put(
-          parsedData.changeNumber,
-          parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-      }
-    });
-
-    pushEmitter.on(MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+    pushEmitter.on(MY_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
     pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
@@ -362,7 +334,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask!); // client-side
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
@@ -372,7 +344,7 @@ export function pushManagerFactory(
       },
 
       // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask, myLargeSegmentsSyncTask?: IMySegmentsSyncTask) {
+      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
         const hash = hashUserKey(userKey);
 
         if (!userKeyHashes[hash]) {
@@ -380,7 +352,7 @@ export function pushManagerFactory(
           clients[userKey] = {
             hash64: hash64(userKey),
             worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
-            workerLarge: myLargeSegmentsSyncTask ? MySegmentsUpdateWorker(myLargeSegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT) : undefined
+            workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT)
           };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key