@splitsoftware/splitio 10.17.2 → 10.17.3-rc.0

package/src/sync/PushManager/index.js

@@ -1,328 +0,0 @@
-import EventEmitter from 'events';
-import objectAssign from 'object-assign';
-
-import authenticate from '../AuthClient';
-import { checkPushRequirements } from './pushRequirements';
-import SegmentUpdateWorker from '../SegmentUpdateWorker';
-import SplitUpdateWorker from '../SplitUpdateWorker';
-import SSEClient from '../SSEClient';
-import SSEHandlerFactory from '../SSEHandler';
-
-import Backoff from '../../utils/backoff';
-import { hashUserKey } from '../../utils/jwt/hashUserKey';
-import logFactory from '../../utils/logger';
-import { SECONDS_BEFORE_EXPIRATION, PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_RETRYABLE_ERROR, SPLIT_KILL, SPLIT_UPDATE, SEGMENT_UPDATE, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, ControlTypes } from '../constants';
-import { parseBitmap, parseKeyList, isInBitmap } from './mySegmentsV2utils';
-import { forOwn } from '../../utils/lang';
-import { _Set } from '../../utils/lang/Sets';
-import { hash64 } from '../../engine/engine/murmur3/murmur3_64';
-
-const log = logFactory('splitio-sync:push-manager');
-
-// const UnboundedFetchRequest = 0;
-const BoundedFetchRequest = 1;
-const KeyList = 2;
-const SegmentRemoval = 3;
-
-function fallbackWarning(notificationType, e) {
-  return `Fetching MySegments due to an error processing ${notificationType} notification: ${e}`;
-}
-
-/**
- * Factory of the push mode manager.
- *
- * @param {Object} context context of main client.
- * @param {Object | undefined} clientContexts map of user keys to client contexts to handle sync of MySegments. undefined for node.
- */
-export default function PushManagerFactory(context, clientContexts /* undefined for node */) {
-
-  // No return a PushManager if PUSH mode is not supported.
-  if (!checkPushRequirements(log)) return;
-
-  const pushEmitter = new EventEmitter();
-  const { splits: splitsEventEmitter } = context.get(context.constants.READINESS);
-  const settings = context.get(context.constants.SETTINGS);
-  const storage = context.get(context.constants.STORAGE);
-  const sseClient = SSEClient.getInstance(settings, clientContexts ? false : true);
-  const sseHandler = SSEHandlerFactory(pushEmitter);
-  sseClient.setEventHandler(sseHandler);
-
-  // map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
-  const userKeyHashes = {};
-  // map of user keys to their corresponding hash64 and MySegmentsUpdateWorker.
-  // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding worker.
-  const clients = {};
-
-  // variable used on browser to reconnect only when a new client was added, saving some authentication and sse connections.
-  let connectForNewClient = false;
-  // flag that indicates if `disconnectPush` was called, either by the SyncManager (when the client is destroyed) or by a PUSH_NONRETRYABLE_ERROR error
-  let disconnected;
-
-  /** PushManager functions related to initialization */
-
-  const connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
-
-  let timeoutIdTokenRefresh;
-  let timeoutIdSseOpen;
-
-  function scheduleTokenRefreshAndSse(authData) {
-    // clear scheduled tasks if exist
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
-
-    // Set token refresh 10 minutes before expirationTime - issuedAt
-    const decodedToken = authData.decodedToken;
-    const refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION;
-    // Default connDelay of 60 secs
-    const connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
-
-    log.info(`Refreshing streaming token in ${refreshTokenDelay} seconds, and connecting streaming in ${connDelay} seconds`);
-
-    timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
-
-    timeoutIdSseOpen = setTimeout(() => {
-      // halt if disconnected
-      if (disconnected) return;
-      sseClient.open(authData);
-    }, connDelay * 1000);
-  }
-
-  function connectPush() {
-    // Halt connecting in case `stop/disconnectPush` has been called
-    if (disconnected) return;
-    log.info(`${disconnected === undefined ? 'Connecting' : 'Re-connecting'} to push streaming.`);
-    disconnected = false;
-
-    const userKeys = clientContexts ? Object.keys(clientContexts) : undefined;
-    authenticate(settings, userKeys).then(
-      function (authData) {
-        if (disconnected) return;
-
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_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 is not available. Switching to polling mode.');
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // 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(clientContexts).length) return;
-
-        // Schedule SSE connection and refresh token
-        scheduleTokenRefreshAndSse(authData);
-      }
-    ).catch(
-      function (error) {
-        if (disconnected) return;
-
-        log.error(`Failed to authenticate for streaming. Error: ${error.message}.`);
-
-        // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side)
-        if (error.statusCode >= 400 && error.statusCode < 500) {
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // Handle other HTTP and network errors as recoverable errors
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      }
-    );
-  }
-
-  // close SSE connection and cancel scheduled tasks
-  function disconnectPush() {
-    // Halt disconnecting, just to avoid redundant logs if called multiple times
-    if (disconnected) return;
-    disconnected = true;
-
-    sseClient.close();
-    log.info('Disconnecting from push streaming.');
-
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
-    connectPushRetryBackoff.reset();
-
-    stopWorkers();
-  }
-
-  pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
-
-  // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
-  // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
-  pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
-    connectPushRetryBackoff.reset();
-    stopWorkers();
-  });
-
-  /** Fallbacking without retry due to STREAMING_DISABLED control event, 'pushEnabled: false', and non-recoverable SSE and Authentication errors */
-
-  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
-    // Note: `stopWorkers` is been called twice, but it is not harmful
-    disconnectPush();
-    pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
-  });
-
-  /** Fallbacking with retry due to recoverable SSE and Authentication errors */
-
-  pushEmitter.on(PUSH_RETRYABLE_ERROR, function handleRetryableError() { // HTTP or network error in SSE connection
-    // SSE connection is closed to avoid repeated errors due to retries
-    sseClient.close();
-
-    // retry streaming reconnect with backoff algorithm
-    let delayInMillis = connectPushRetryBackoff.scheduleCall();
-
-    log.info(`Attempting to reconnect in ${delayInMillis / 1000} seconds.`);
-
-    pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
-  });
-
-  /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */
-
-  pushEmitter.on(ControlTypes.STREAMING_RESET, function handleStreamingReset() {
-    if (disconnected) return; // should never happen
-
-    // Minimum required clean-up.
-    // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-
-    connectPush();
-  });
-
-  /** Functions related to synchronization (Queues and Workers in the spec) */
-
-  const producer = context.get(context.constants.PRODUCER);
-  const splitUpdateWorker = new SplitUpdateWorker(storage.splits, producer, splitsEventEmitter);
-  let segmentUpdateWorker; // used in Node
-
-  // cancel scheduled fetch retries of Split, Segment, and MySegment Update Workers
-  function stopWorkers() {
-    splitUpdateWorker.backoff.reset();
-    if (segmentUpdateWorker) segmentUpdateWorker.backoff.reset();
-    forOwn(clients, ({ worker }) => worker.backoff.reset());
-  }
-
-  pushEmitter.on(SPLIT_KILL, splitUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitUpdateWorker.put);
-
-  if (clientContexts) { // browser
-    pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-      const userKeyHash = channel.split('_')[2];
-      const userKey = userKeyHashes[userKeyHash];
-      if (userKey && clientContexts[userKey]) { // check context since it can be undefined if client has been destroyed
-        const mySegmentSync = clientContexts[userKey].get(context.constants.MY_SEGMENTS_CHANGE_WORKER, true);
-        mySegmentSync && mySegmentSync.put(
-          parsedData.changeNumber,
-          parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-      }
-    });
-
-    pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-      switch (parsedData.u) {
-        case BoundedFetchRequest: {
-          let bitmap;
-          try {
-            bitmap = parseBitmap(parsedData.d, parsedData.c);
-          } catch (e) {
-            log.warn(fallbackWarning('BoundedFetchRequest', e));
-            break;
-          }
-
-          forOwn(clients, ({ hash64, worker }) => {
-            if (isInBitmap(bitmap, hash64.hex)) {
-              worker.put(parsedData.changeNumber); // fetch mySegments
-            }
-          });
-          return;
-        }
-        case KeyList: {
-          let keyList, added, removed;
-          try {
-            keyList = parseKeyList(parsedData.d, parsedData.c);
-            added = new _Set(keyList.a);
-            removed = new _Set(keyList.r);
-          } catch (e) {
-            log.warn(fallbackWarning('KeyList', e));
-            break;
-          }
-
-          forOwn(clients, ({ hash64, worker }) => {
-            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
-            if (add !== undefined) {
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add
-              });
-            }
-          });
-          return;
-        }
-        case SegmentRemoval:
-          if (!parsedData.segmentName) {
-            log.warn(fallbackWarning('SegmentRemoval', 'No segment name was provided'));
-            break;
-          }
-
-          forOwn(clients, ({ worker }) => {
-            worker.put(parsedData.changeNumber, {
-              name: parsedData.segmentName,
-              add: false
-            });
-          });
-          return;
-      }
-
-      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-      forOwn(clients, ({ worker }) => {
-        worker.put(parsedData.changeNumber);
-      });
-    });
-
-  } else { // node
-    segmentUpdateWorker = new SegmentUpdateWorker(storage.segments, producer);
-    pushEmitter.on(SEGMENT_UPDATE, segmentUpdateWorker.put);
-  }
-
-  return objectAssign(
-    // Expose Event Emitter functionality and Event constants
-    Object.create(pushEmitter),
-    {
-      // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which start polling.
-
-      // used in node
-      start: connectPush,
-
-      // used in browser
-      startNewClient(userKey, context) {
-        const hash = hashUserKey(userKey);
-        const storage = context.get(context.constants.STORAGE);
-        const producer = context.get(context.constants.PRODUCER);
-
-        if (!userKeyHashes[hash]) {
-          userKeyHashes[hash] = userKey;
-          connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
-        }
-        const mySegmentSync = new SegmentUpdateWorker(storage.segments, producer);
-        clients[userKey] = { worker: mySegmentSync, hash64: hash64(userKey) };
-        context.put(context.constants.MY_SEGMENTS_CHANGE_WORKER, mySegmentSync);
-
-        // Reconnects in case of a new client.
-        // Run in next event-loop cycle to save authentication calls
-        // in case the user is creating several clients in the current cycle.
-        setTimeout(function checkForReconnect() {
-          if (connectForNewClient) {
-            connectForNewClient = false;
-            connectPush();
-          }
-        }, 0);
-
-      },
-      removeClient(userKey) {
-        const hash = hashUserKey(userKey);
-        delete userKeyHashes[hash];
-        delete clients[userKey];
-      }
-    }
-  );
-}

package/src/sync/PushManager/mySegmentsV2utils.js

@@ -1,76 +0,0 @@
-import { algorithms } from '../../utils/decompress';
-import { decodeFromBase64 } from '../../utils/base64';
-
-const GZIP = 1;
-const ZLIB = 2;
-
-function Uint8ArrayToString(myUint8Arr) {
-  return String.fromCharCode.apply(null, myUint8Arr);
-}
-
-function StringToUint8Array(myString) {
-  const charCodes = myString.split('').map((e) => e.charCodeAt());
-  return new Uint8Array(charCodes);
-}
-
-/**
- * Decode and decompress 'data' with 'compression' algorithm
- *
- * @param {string} data
- * @param {number} compression 1 GZIP, 2 ZLIB
- * @returns {Uint8Array}
- * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
- */
-function decompress(data, compression) {
-  let compressData = decodeFromBase64(data);
-  const binData = StringToUint8Array(compressData);
-
-  if (typeof algorithms === 'string') throw new Error(algorithms);
-  if (compression === GZIP) return algorithms.gunzipSync(binData);
-  if (compression === ZLIB) return algorithms.unzlibSync(binData);
-  throw new Error(`Invalid compression algorithm #${compression}`);
-}
-
-/**
- * Decode, decompress and parse the provided 'data' into a KeyList object
- *
- * @param {string} data
- * @param {number} compression
- * @returns {{a?: string[], r?: string[] }}
- * @throws if data string cannot be decoded, decompressed or parsed
- */
-export function parseKeyList(data, compression) {
-  const binKeyList = decompress(data, compression);
-  const strKeyList = Uint8ArrayToString(binKeyList);
-
-  // replace numbers to strings, to avoid losing precision
-  return JSON.parse(strKeyList.replace(/\d+/g, '"$&"'));
-}
-
-/**
- * Decode, decompress and parse the provided 'data' into a Bitmap object
- *
- * @param {string} data
- * @param {number} compression
- * @returns {Uint8Array}
- * @throws if data string cannot be decoded or decompressed
- */
-export function parseBitmap(data, compression) {
-  return decompress(data, compression);
-}
-
-/**
- * Check if the 'bitmap' bit at 'hash64hex' position is 1
- *
- * @param {Uint8Array} bitmap
- * @param {string} hash64hex 16-chars string, representing a number in hexa
- * @returns {boolean}
- */
-export function isInBitmap(bitmap, hash64hex) {
-  // using the lowest 32 bits as index, to avoid losing precision when converting to number
-  const index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
-
-  const internal = Math.floor(index / 8);
-  const offset = index % 8;
-  return (bitmap[internal] & 1 << offset) > 0;
-}

package/src/sync/PushManager/pushRequirements/browser.js

@@ -1,20 +0,0 @@
-import getEventSource from '../../../services/getEventSource/browser';
-
-/**
- * Check if the JS environment has the necessary features to run in PUSH mode,
- * i.e., EventSource, base64 encoder and decoder.
- *
- * @return {boolean} if push is supported
- */
-export function checkPushRequirements(logger) {
-  const esReference = getEventSource();
-  if (!esReference) {
-    logger.warn('EventSource API is not available. Falling back to polling mode.');
-    return false;
-  }
-  if (typeof atob !== 'function' || typeof btoa !== 'function') {
-    logger.warn('"atob" and "btoa" functions for Base64 encoding are not available. Falling back to polling mode.');
-    return false;
-  }
-  return true;
-}

package/src/sync/PushManager/pushRequirements/node.js

@@ -1,16 +0,0 @@
-import getEventSource from '../../../services/getEventSource/node';
-
-/**
- * Check if the Node environment has the necessary features to run in PUSH mode,
- * i.e., EventSource, base64 encoder and decoder.
- *
- * @return {boolean} if push is supported
- */
-export function checkPushRequirements(logger) {
-  const esReference = getEventSource();
-  if (!esReference) {
-    logger.warn('EventSource API is not available. Falling back to polling mode.');
-    return false;
-  }
-  return true;
-}

package/src/sync/PushManager/pushRequirements/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "./node.js",
-  "browser": "./browser.js"
-}

package/src/sync/SSEClient/index.js

@@ -1,92 +0,0 @@
-import getEventSource from '../../services/getEventSource';
-
-const VERSION = '1.1';
-
-const CONTROL_CHANNEL_REGEX = /^control_/;
-
-/**
- * Build metadata headers for SSE connection.
- *
- * @param {Object} settings Validated settings.
- */
-function buildSSEHeaders(settings) {
-  const headers = {
-    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
-    SplitSDKVersion: settings.version,
-  };
-
-  // ip and hostname are false if IPAddressesEnabled is false
-  const { ip, hostname } = settings.runtime;
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
-
-  return headers;
-}
-
-export default class SSEClient {
-
-  /**
-   * Returns a SSEClient instance, or undefined if EventSource is not available.
-   * @param {Object} settings Validated SDK settings.
-   * @param {boolean} useHeaders True for Node and false for Browser, used to send metadata as headers or query params respectively.
-   */
-  static getInstance(settings, useHeaders) {
-    const EventSource = getEventSource();
-    if (EventSource)
-      return new SSEClient(EventSource, settings, useHeaders);
-  }
-
-  // Instance properties:
-  //  streamingUrl: string
-  //  EventSource: EventSource constructor
-  //  connection: EventSource | undefined
-  //  handler: EventHandler for open, close, error and messages events
-
-  constructor(EventSource, settings, useHeaders) {
-    this.EventSource = EventSource;
-    this.streamingUrl = settings.url('/sse');
-    this.useHeaders = useHeaders;
-    this.headers = buildSSEHeaders(settings);
-  }
-
-  setEventHandler(handler) {
-    this.handler = handler;
-  }
-
-  /**
-   * Open the connection with a given authToken
-   *
-   * @param {Object} authToken
-   * @throws {TypeError} Will throw an error if `authToken` is undefined
-   */
-  open(authToken) {
-    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 url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
-
-    this.connection = new this.EventSource(
-      // For Browser, SplitSDKClientKey and SplitSDKClientKey headers are passed as query params,
-      // because native EventSource implementations for browser doesn't support headers.
-      this.useHeaders ? url : url + `&SplitSDKVersion=${this.headers.SplitSDKVersion}&SplitSDKClientKey=${this.headers.SplitSDKClientKey}`,
-      // For Node, metadata headers are passed because 'eventsource' package supports them.
-      this.useHeaders ? { headers: this.headers } : undefined
-    );
-
-    if (this.handler) { // no need to check if SSEClient is used only by PushManager
-      this.connection.onopen = this.handler.handleOpen;
-      this.connection.onmessage = this.handler.handleMessage;
-      this.connection.onerror = this.handler.handleError;
-    }
-  }
-
-  /** Close connection  */
-  close() {
-    if (this.connection) this.connection.close();
-  }
-}

package/src/sync/SSEHandler/NotificationKeeper.js

@@ -1,90 +0,0 @@
-import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN, PUSH_NONRETRYABLE_ERROR, ControlTypes } from '../constants';
-
-const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-
-export default function notificationKeeperFactory(feedbackLoopEmitter) {
-
-  let channels = CONTROL_CHANNEL_REGEXS.map(regex => ({
-    regex,
-    hasPublishers: true, // keep track of publishers presence per channel, in order to compute `hasPublishers`. Init with true, to emit PUSH_SUBSYSTEM_UP if initial OCCUPANCY notifications have 0 publishers
-    oTime: -1, // keep track of most recent occupancy notification timestamp per channel
-    cTime: -1 // keep track of most recent control notification timestamp per channel
-  }));
-
-  // false if the number of publishers is equal to 0 in all regions
-  let hasPublishers = true;
-
-  // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
-  let hasResumed = true;
-
-  function getHasPublishers() { // computes the value of `hasPublishers`
-    return channels.some(c => c.hasPublishers);
-  }
-
-  return {
-    handleOpen() {
-      feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_UP);
-    },
-
-    isStreamingUp() {
-      return hasResumed && hasPublishers;
-    },
-
-    handleOccupancyEvent(publishers, channel, timestamp) {
-      for (let i = 0; i < channels.length; i++) {
-        const c = channels[i];
-        if (c.regex.test(channel)) {
-          if (timestamp > c.oTime) {
-            c.oTime = timestamp;
-            c.hasPublishers = publishers !== 0;
-            const hasPublishersNow = getHasPublishers();
-            if (hasResumed) {
-              if (!hasPublishersNow && hasPublishers) {
-                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-              } else if (hasPublishersNow && !hasPublishers) {
-                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_UP);
-              }
-              // nothing to do when hasResumed === false:
-              // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`
-            }
-            hasPublishers = hasPublishersNow;
-          }
-          return;
-        }
-      }
-    },
-
-    handleControlEvent(controlType, channel, timestamp) {
-      /* STREAMING_RESET event is handled by PushManager directly since it doesn't require
-       * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
-       * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
-      if (controlType === ControlTypes.STREAMING_RESET) {
-        feedbackLoopEmitter.emit(controlType);
-        return;
-      }
-
-      for (let i = 0; i < channels.length; i++) {
-        const c = channels[i];
-        if (c.regex.test(channel)) {
-          if (timestamp > c.cTime) {
-            c.cTime = timestamp;
-            if (controlType === ControlTypes.STREAMING_DISABLED) {
-              feedbackLoopEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-            } else if (hasPublishers) {
-              if (controlType === ControlTypes.STREAMING_PAUSED && hasResumed) {
-                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-              } else if (controlType === ControlTypes.STREAMING_RESUMED && !hasResumed) {
-                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_UP);
-              }
-              // nothing to do when hasPublishers === false:
-              // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`
-            }
-            hasResumed = controlType === ControlTypes.STREAMING_RESUMED;
-          }
-          return;
-        }
-      }
-    },
-
-  };
-}

package/src/sync/SSEHandler/NotificationParser.js

@@ -1,35 +0,0 @@
-import { OCCUPANCY } from '../constants';
-import { isString } from '../../utils/lang';
-
-/**
- * Parses the `data` JSON string, if exists, of a given SSE error notifications.
- * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.
- * Other network and HTTP errors do not have this property.
- *
- * @param {Object} error
- * @throws {SyntaxError} if `error.data` is an invalid JSON string
- */
-export function errorParser(error) {
-  if (isString(error.data))
-    error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
-
-  return error;
-}
-
-/**
- * Parses the `data` JSON string of a given SSE message notifications.
- * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
- *
- * @param {Object} message
- * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
- */
-export function messageParser(message) {
-  const messageData = JSON.parse(message.data);
-  messageData.parsedData = JSON.parse(messageData.data);
-
-  // set the event type to OCCUPANCY, to handle all events uniformely
-  if (messageData.name && messageData.name === '[meta]occupancy')
-    messageData.parsedData.type = OCCUPANCY;
-
-  return messageData;
-}