@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/src/storages/types.ts

@@ -57,15 +57,6 @@ export interface ICustomStorageWrapper {
    * The promise rejects if the operation fails.
    */
   getKeysByPrefix: (prefix: string) => Promise<string[]>
-  /**
-   * Returns all values which keys match the given prefix.
-   *
-   * @function getByPrefix
-   * @param {string} prefix String prefix to match
-   * @returns {Promise<string[]>} A promise that resolves with the list of values which keys match the given `prefix`.
-   * The promise rejects if the operation fails.
-   */
-  getByPrefix: (prefix: string) => Promise<string[]>
   /**
    * Returns the values of all given `keys`.
    *
@@ -83,19 +74,19 @@ export interface ICustomStorageWrapper {
    *
    * @function incr
    * @param {string} key Key to increment
-   * @returns {Promise<void>} A promise that resolves if the operation success. The promise rejects if the operation fails,
+   * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
-  incr: (key: string) => Promise<void | boolean>
+  incr: (key: string) => Promise<number>
   /**
    * Decrements in 1 the given `key` value or set it in -1 if the value doesn't exist.
    *
    * @function decr
    * @param {string} key Key to decrement
-   * @returns {Promise<void>} A promise that resolves if the operation success. The promise rejects if the operation fails,
+   * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
-  decr: (key: string) => Promise<void | boolean>
+  decr: (key: string) => Promise<number>
 
   /** Queue operations */
 
@@ -266,8 +257,8 @@ export interface ISegmentsCacheBase {
 
 // Same API for both variants: SegmentsCache and MySegmentsCache (client-side API)
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys: string[]): boolean
-  removeFromSegment(name: string, segmentKeys: string[]): boolean
+  addToSegment(name: string, segmentKeys?: string[]): boolean
+  removeFromSegment(name: string, segmentKeys?: string[]): boolean
   isInSegment(name: string, key?: string): boolean
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
@@ -448,3 +439,15 @@ export interface IStorageFactoryParams {
   onReadyCb?: (error?: any) => void,
   metadata: IMetadata,
 }
+
+export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+
+export type IStorageSyncFactory = {
+  type: StorageType,
+  (params: IStorageFactoryParams): IStorageSync
+}
+
+export type IStorageAsyncFactory = {
+  type: StorageType,
+  (params: IStorageFactoryParams): IStorageAsync
+}

package/src/sync/offline/splitsParser/splitsParserFromFile.ts

@@ -7,8 +7,9 @@ import yaml from 'js-yaml';
 import { isString, endsWith, find, forOwn, uniq, } from '../../../utils/lang';
 import parseCondition, { IMockSplitEntry } from './parseCondition';
 import { ISplitPartial } from '../../../dtos/types';
-import { SplitIO } from '../../../types';
+import { ISettings, SplitIO } from '../../../types';
 import { ILogger } from '../../../logger/types';
+import { ISplitsParser } from './types';
 
 const logPrefix = 'sync:offline:splits-fetcher: ';
 
@@ -16,8 +17,6 @@ type IYamlSplitEntry = Record<string, IMockSplitEntry>
 
 const DEFAULT_FILENAME = '.split';
 
-let previousMock = 'NO_MOCK_LOADED';
-
 function configFilesPath(configFilePath?: SplitIO.MockedFeaturesFilePath): SplitIO.MockedFeaturesFilePath {
   if (configFilePath === DEFAULT_FILENAME || !isString(configFilePath)) {
     let root = process.env.HOME;
@@ -39,96 +38,6 @@ function configFilesPath(configFilePath?: SplitIO.MockedFeaturesFilePath): Split
   return configFilePath as SplitIO.MockedFeaturesFilePath;
 }
 
-// Parse `.split` configuration file and return a map of "Split Objects"
-function readSplitConfigFile(log: ILogger, filePath: SplitIO.MockedFeaturesFilePath): false | Record<string, ISplitPartial> {
-  const SPLIT_POSITION = 0;
-  const TREATMENT_POSITION = 1;
-  let data;
-
-  try {
-    data = fs.readFileSync(filePath, 'utf-8');
-  } catch (e) {
-    log.error(e.message);
-
-    return {};
-  }
-
-  if (data === previousMock) return false;
-  previousMock = data;
-
-  const splitObjects = data.split(/\r?\n/).reduce((accum, line, index) => {
-    let tuple: string | string[] = line.trim();
-
-    if (tuple === '' || tuple.charAt(0) === '#') {
-      log.debug(logPrefix + `Ignoring empty line or comment at #${index}`);
-    } else {
-      tuple = tuple.split(/\s+/);
-
-      if (tuple.length !== 2) {
-        log.debug(logPrefix + `Ignoring line since it does not have exactly two columns #${index}`);
-      } else {
-        const splitName = tuple[SPLIT_POSITION];
-        const condition = parseCondition({ treatment: tuple[TREATMENT_POSITION] });
-        accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
-      }
-    }
-
-    return accum;
-  }, {} as Record<string, ISplitPartial>);
-
-  return splitObjects;
-}
-
-// Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
-function readYAMLConfigFile(log: ILogger, filePath: SplitIO.MockedFeaturesFilePath): false | Record<string, ISplitPartial> {
-  let data = '';
-  let yamldoc = null;
-
-  try {
-    data = fs.readFileSync(filePath, 'utf8');
-
-    if (data === previousMock) return false;
-    previousMock = data;
-
-    yamldoc = yaml.safeLoad(data);
-  } catch (e) {
-    log.error(e);
-
-    return {};
-  }
-
-  // Each entry will be mapped to a condition, but we'll also keep the configurations map.
-  const mocksData = (yamldoc as IYamlSplitEntry[]).reduce((accum, splitEntry) => {
-    const splitName = Object.keys(splitEntry)[0];
-
-    if (!splitName || !isString(splitEntry[splitName].treatment))
-      log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
-
-    const mockData = splitEntry[splitName];
-
-    // "Template" for each split accumulated data
-    if (!accum[splitName]) {
-      accum[splitName] = {
-        configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
-      };
-    }
-
-    // Assign the config if there is one on the mock
-    if (mockData.config) accum[splitName].configurations[mockData.treatment] = mockData.config;
-    // Parse the condition from the entry.
-    const condition = parseCondition(mockData);
-    accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
-    // Also keep track of the treatments, will be useful for manager functionality.
-    accum[splitName].treatments.push(mockData.treatment);
-
-    return accum;
-  }, {} as Record<string, Required<ISplitPartial> & { treatments: string[] }>);
-
-  arrangeConditions(mocksData);
-
-  return mocksData;
-}
-
 // This function is not pure nor meant to be. Here we apply modifications to cover
 // for behaviour that's ensured by the BE.
 function arrangeConditions(mocksData: Record<string, Required<ISplitPartial> & { treatments: string[] }>) {
@@ -160,18 +69,114 @@ function arrangeConditions(mocksData: Record<string, Required<ISplitPartial> & {
   });
 }
 
-// Load the content of a configuration file into an Object
-export default function splitsParserFromFile({ features, log }: { features?: SplitIO.MockedFeaturesFilePath, log: ILogger }): false | Record<string, ISplitPartial> {
-  const filePath = configFilesPath(features);
-  let mockData: false | Record<string, ISplitPartial>;
-
-  // If we have a filePath, it means the extension is correct, choose the parser.
-  if (endsWith(filePath, '.split')) {
-    log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
-    mockData = readSplitConfigFile(log, filePath);
-  } else {
-    mockData = readYAMLConfigFile(log, filePath);
+export function splitsParserFromFileFactory(): ISplitsParser {
+
+  let previousMock = 'NO_MOCK_LOADED';
+
+  // Parse `.split` configuration file and return a map of "Split Objects"
+  function readSplitConfigFile(log: ILogger, filePath: SplitIO.MockedFeaturesFilePath): false | Record<string, ISplitPartial> {
+    const SPLIT_POSITION = 0;
+    const TREATMENT_POSITION = 1;
+    let data;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+      log.error(e.message);
+
+      return {};
+    }
+
+    if (data === previousMock) return false;
+    previousMock = data;
+
+    const splitObjects = data.split(/\r?\n/).reduce((accum, line, index) => {
+      let tuple: string | string[] = line.trim();
+
+      if (tuple === '' || tuple.charAt(0) === '#') {
+        log.debug(logPrefix + `Ignoring empty line or comment at #${index}`);
+      } else {
+        tuple = tuple.split(/\s+/);
+
+        if (tuple.length !== 2) {
+          log.debug(logPrefix + `Ignoring line since it does not have exactly two columns #${index}`);
+        } else {
+          const splitName = tuple[SPLIT_POSITION];
+          const condition = parseCondition({ treatment: tuple[TREATMENT_POSITION] });
+          accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
+        }
+      }
+
+      return accum;
+    }, {} as Record<string, ISplitPartial>);
+
+    return splitObjects;
+  }
+
+  // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
+  function readYAMLConfigFile(log: ILogger, filePath: SplitIO.MockedFeaturesFilePath): false | Record<string, ISplitPartial> {
+    let data = '';
+    let yamldoc = null;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf8');
+
+      if (data === previousMock) return false;
+      previousMock = data;
+
+      yamldoc = yaml.safeLoad(data);
+    } catch (e) {
+      log.error(e);
+
+      return {};
+    }
+
+    // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+    const mocksData = (yamldoc as IYamlSplitEntry[]).reduce((accum, splitEntry) => {
+      const splitName = Object.keys(splitEntry)[0];
+
+      if (!splitName || !isString(splitEntry[splitName].treatment))
+        log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
+
+      const mockData = splitEntry[splitName];
+
+      // "Template" for each split accumulated data
+      if (!accum[splitName]) {
+        accum[splitName] = {
+          configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
+        };
+      }
+
+      // Assign the config if there is one on the mock
+      if (mockData.config) accum[splitName].configurations[mockData.treatment] = mockData.config;
+      // Parse the condition from the entry.
+      const condition = parseCondition(mockData);
+      accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
+      // Also keep track of the treatments, will be useful for manager functionality.
+      accum[splitName].treatments.push(mockData.treatment);
+
+      return accum;
+    }, {} as Record<string, Required<ISplitPartial> & { treatments: string[] }>);
+
+    arrangeConditions(mocksData);
+
+    return mocksData;
   }
 
-  return mockData;
+  // Load the content of a configuration file into an Object
+  return function splitsParserFromFile({ features, log }: ISettings): false | Record<string, ISplitPartial> {
+    const filePath = configFilesPath(features as string);
+    let mockData: false | Record<string, ISplitPartial>;
+
+    // If we have a filePath, it means the extension is correct, choose the parser.
+    if (endsWith(filePath, '.split')) {
+      log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+      mockData = readSplitConfigFile(log, filePath);
+    } else {
+      mockData = readYAMLConfigFile(log, filePath);
+    }
+
+    return mockData;
+  };
+
 }

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -3,8 +3,6 @@ import { ISettings, SplitIO } from '../../../types';
 import { isObject, forOwn } from '../../../utils/lang';
 import parseCondition from './parseCondition';
 
-let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
-
 function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
   if (typeof prev !== typeof curr) return true;
 
@@ -15,54 +13,60 @@ function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: s
   }
 }
 
-function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
-  const names = Object.keys(currentData);
+export function splitsParserFromSettingsFactory() {
 
-  // Different amount of items
-  if (names.length !== Object.keys(previousMock).length) {
-    previousMock = currentData;
-    return true;
-  }
+  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
 
-  return names.some(name => {
-    const newSplit = !previousMock[name];
-    const newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-    const changed = newSplit || newTreatment;
+  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
+    const names = Object.keys(currentData);
 
-    if (changed) previousMock = currentData;
+    // Different amount of items
+    if (names.length !== Object.keys(previousMock).length) {
+      previousMock = currentData;
+      return true;
+    }
 
-    return changed;
-  });
-}
+    return names.some(name => {
+      const newSplit = !previousMock[name];
+      const newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
+      const changed = newSplit || newTreatment;
 
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-export default function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
-  const features = settings.features as SplitIO.MockedFeaturesMap || {};
+      if (changed) previousMock = currentData;
 
-  if (!mockUpdated(features)) return false;
+      return changed;
+    });
+  }
 
-  const splitObjects: Record<string, ISplitPartial> = {};
+  /**
+   *
+   * @param settings validated object with mocked features mapping.
+   */
+  return function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
+    const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
-  forOwn(features, (data, splitName) => {
-    let treatment = data;
-    let config = null;
+    if (!mockUpdated(features)) return false;
 
-    if (isObject(data)) {
-      treatment = (data as SplitIO.TreatmentWithConfig).treatment;
-      config = (data as SplitIO.TreatmentWithConfig).config || config;
-    }
-    const configurations: Record<string, string> = {};
-    if (config !== null) configurations[treatment as string] = config;
+    const splitObjects: Record<string, ISplitPartial> = {};
+
+    forOwn(features, (data, splitName) => {
+      let treatment = data;
+      let config = null;
+
+      if (isObject(data)) {
+        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
+        config = (data as SplitIO.TreatmentWithConfig).config || config;
+      }
+      const configurations: Record<string, string> = {};
+      if (config !== null) configurations[treatment as string] = config;
+
+      splitObjects[splitName] = {
+        trafficTypeName: 'localhost',
+        conditions: [parseCondition({ treatment: treatment as string })],
+        configurations
+      };
+    });
 
-    splitObjects[splitName] = {
-      trafficTypeName: 'localhost',
-      conditions: [parseCondition({ treatment: treatment as string })],
-      configurations
-    };
-  });
+    return splitObjects;
+  };
 
-  return splitObjects;
 }

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -7,7 +7,7 @@ import syncTaskFactory from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 
 /**
@@ -20,7 +20,8 @@ export function fromObjectUpdaterFactory(
   settings: ISettings,
 ): () => Promise<boolean> {
 
-  const log = settings.log;
+  const log = settings.log, splitsCache = storage.splits;
+  let startingUp = true;
 
   return function objectUpdater() {
     const splits: [string, string][] = [];
@@ -53,11 +54,20 @@ export function fromObjectUpdaterFactory(
       });
 
       return Promise.all([
-        storage.splits.clear(),
-        storage.splits.addSplits(splits)
+        splitsCache.clear(), // required to sync removed splits from mock
+        splitsCache.addSplits(splits)
       ]).then(() => {
         readiness.splits.emit(SDK_SPLITS_ARRIVED);
-        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+        if (startingUp) {
+          startingUp = false;
+          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
+            // Emits SDK_READY_FROM_CACHE
+            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            // Emits SDK_READY
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          });
+        }
         return true;
       });
     } else {

package/src/sync/polling/types.ts

@@ -2,11 +2,12 @@ import { IReadinessManager } from '../../readiness/types';
 import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
 import { ISettings } from '../../types';
+import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean], boolean> { }
 
-export interface ISegmentsSyncTask extends ISyncTask<[segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean], boolean> { }
+export interface ISegmentsSyncTask extends ISyncTask<[segmentNames?: SegmentsData, noCache?: boolean, fetchOnlyNew?: boolean], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

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

@@ -5,6 +5,7 @@ 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 { SegmentsData } from '../../streaming/SSEHandler/types';
 
 type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
 
@@ -38,9 +39,23 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing custom storages, handle async execution
-  function updateSegments(segments: string[]) {
-    // Update the list of segment names available
-    const shouldNotifyUpdate = mySegmentsCache.resetSegments(segments);
+  function updateSegments(segmentsData: SegmentsData) {
+
+    let shouldNotifyUpdate;
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    } 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;
+      }
+    }
 
     // Notify update if required
     if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
@@ -49,10 +64,10 @@ export function mySegmentsUpdaterFactory(
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentList?: string[], noCache?: boolean): Promise<boolean> {
-    const updaterPromise: Promise<boolean> = segmentList ?
-      // If segmentList is provided, there is no need to fetch mySegments
-      new Promise((res) => { updateSegments(segmentList); res(true); }) :
+  function _mySegmentsUpdater(retry: number, segmentsData?: SegmentsData, noCache?: boolean): Promise<boolean> {
+    const updaterPromise: Promise<boolean> = segmentsData ?
+      // If segmentsData is provided, there is no need to fetch mySegments
+      new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
       mySegmentsFetcher(noCache, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
@@ -79,11 +94,14 @@ export function mySegmentsUpdaterFactory(
    * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
    * Returned promise will not be rejected.
    *
-   * @param {string[] | undefined} segmentList list of mySegments names to sync in the storage. If the list is `undefined`, it fetches them before syncing in the storage.
+   * @param {SegmentsData | undefined} segmentsData it can be:
+   *  (1) the list of mySegments names to sync in the storage,
+   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+   *  (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(segmentList?: string[], noCache?: boolean) {
-    return _mySegmentsUpdater(0, segmentList, noCache);
+  return function mySegmentsUpdater(segmentsData?: SegmentsData, noCache?: boolean) {
+    return _mySegmentsUpdater(0, segmentsData, noCache);
   };
 
 }

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

@@ -5,6 +5,7 @@ export interface IAuthTokenPushEnabled {
   token: string
   decodedToken: IDecodedJWTToken
   channels: { [channel: string]: string[] }
+  connDelay?: number
 }
 
 export interface IAuthTokenPushDisabled {
@@ -15,3 +16,5 @@ export interface IAuthTokenPushDisabled {
 export type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled
 
 export type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>
+
+export type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>

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

@@ -35,7 +35,6 @@ export default class SSEClient implements ISSEClient {
   streamingUrl: string;
   connection?: InstanceType<typeof EventSource>;
   handler?: ISseEventHandler;
-  authToken?: IAuthTokenPushEnabled;
   useHeaders?: boolean;
   headers: Record<string, string>;
 
@@ -47,14 +46,13 @@ export default class SSEClient implements ISSEClient {
    * @param getEventSource Function to get the EventSource constructor.
    * @throws 'EventSource API is not available. ' if EventSource is not available.
    */
-  constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => typeof EventSource | undefined) {
+  constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (typeof EventSource | undefined)) {
     // @ts-expect-error
     this.eventSource = getEventSource && getEventSource();
     // if eventSource is not available, throw an exception
     if (!this.eventSource) throw new Error('EventSource API is not available. ');
 
     this.streamingUrl = settings.urls.streaming + '/sse';
-    this.reopen = this.reopen.bind(this);
     // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
     this.useHeaders = useHeaders;
     this.headers = buildSSEHeaders(settings);
@@ -73,8 +71,6 @@ export default class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    this.authToken = authToken;
-
     const channelsQueryParam = Object.keys(authToken.channels).map(
       function (channel) {
         const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
@@ -102,14 +98,4 @@ export default class SSEClient implements ISSEClient {
   close() {
     if (this.connection) this.connection.close();
   }
-
-  /**
-   * Re-open the connection with the last given authToken.
-   *
-   * @throws {TypeError} if `open` has not been previously called with an authToken
-   * @TODO this method is not used currently and could be removed.
-   */
-  reopen() {
-    this.open(this.authToken as IAuthTokenPushEnabled);
-  }
 }

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

@@ -8,7 +8,6 @@ export interface ISseEventHandler {
 
 export interface ISSEClient {
   open(authToken: IAuthTokenPushEnabled): void,
-  reopen(): void,
   close(): void,
   setEventHandler(handler: ISseEventHandler): void
 }

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

@@ -62,6 +62,14 @@ export default function notificationKeeperFactory(pushEmitter: IPushEventEmitter
     },
 
     handleControlEvent(controlType: ControlType, channel: string, timestamp: number) {
+      /* STREAMING_RESET control 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 === ControlType.STREAMING_RESET) {
+        pushEmitter.emit(controlType);
+        return;
+      }
+
       for (let i = 0; i < channels.length; i++) {
         const c = channels[i];
         if (c.regex.test(channel)) {

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

@@ -22,10 +22,12 @@ export function errorParser(error: Event): INotificationError {
  * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
  *
  * @param message
- * @returns parsed notification message
+ * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
+ * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
  * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
  */
-export function messageParser(message: MessageEvent): INotificationMessage {
+export function messageParser(message: MessageEvent): INotificationMessage | undefined {
+  if (!message.data) return;
   const messageData = JSON.parse(message.data);
   messageData.parsedData = JSON.parse(messageData.data);