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

package/src/utils/settingsValidation/index.ts

@@ -3,7 +3,8 @@ import mode from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import validImpressionsMode from './impressionsMode';
-import { ISettingsInternal, ISettingsValidationParams } from './types';
+import { ISettingsValidationParams } from './types';
+import { ISettings } from '../../types';
 
 const base = {
   // Define which kind of object you want to retrieve from SplitFactory
@@ -73,7 +74,8 @@ const base = {
   sync: {
     splitFilters: undefined,
     // impressions collection mode
-    impressionsMode: OPTIMIZED
+    impressionsMode: OPTIMIZED,
+    localhostMode: undefined
   },
 
   runtime: {
@@ -98,10 +100,10 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, localhost } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
-  const withDefaults = merge({}, base, defaults, config) as ISettingsInternal;
+  const withDefaults = merge({}, base, defaults, config) as ISettings;
 
   // ensure a valid logger.
   // First thing to validate, since other validators might use the logger.
@@ -143,6 +145,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (integrations) withDefaults.integrations = integrations(withDefaults);
 
+  if (localhost) withDefaults.sync.localhostMode = localhost(withDefaults);
+
   // validate push options
   if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
     withDefaults.streamingEnabled = true;

package/src/utils/settingsValidation/localhost/index.ts

@@ -0,0 +1,19 @@
+import { ERROR_LOCALHOST_MODULE_REQUIRED } from '../../../logger/constants';
+import { ISettings, } from '../../../types';
+import { LOCALHOST_MODE } from '../../constants';
+
+/**
+ * This function validates `settings.storage` object
+ *
+ * @param {any} settings config object provided by the user to initialize the sdk
+ *
+ * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ */
+export function validateLocalhost(settings: ISettings) {
+  const localhostMode = settings.sync.localhostMode;
+
+  if (settings.mode === LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== LOCALHOST_MODE)) {
+    settings.log.error(ERROR_LOCALHOST_MODULE_REQUIRED);
+  }
+  return localhostMode;
+}

package/src/utils/settingsValidation/splitFilters.ts

@@ -107,7 +107,6 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   }
 
   // Validate filters and group their values by filter type inside `groupedFilters` object
-  // Assign the valid filters to the output of the validator by using filter function
   res.validFilters = maybeSplitFilters.filter((filter, index) => {
     if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
       res.groupedFilters[filter.type as SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,7 +1,16 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { ISettings } from '../../../types';
+import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
 import { WARN_STORAGE_INVALID } from '../../../logger/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+import { IStorageFactoryParams, IStorageSyncCS } from '../../../storages/types';
+
+export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSyncCS {
+  const result = InMemoryStorageCSFactory(params);
+  result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
+  return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 
 /**
  * This function validates `settings.storage` object
@@ -10,16 +19,20 @@ import { WARN_STORAGE_INVALID } from '../../../logger/constants';
  *
  * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
  */
-export function validateStorageCS(settings: { log: ILogger, storage?: any }): ISettings['storage'] {
-  const { storage, log } = settings;
+export function validateStorageCS(settings: { log: ILogger, storage?: any, mode?: SDKMode }): ISettings['storage'] {
+  let { storage = InMemoryStorageCSFactory, log, mode } = settings;
 
-  // validate storage
-  // @TODO validate its API (Splits cache, MySegments cache, etc) when supporting custom storages
-  if (storage) {
-    if (typeof storage === 'function') return storage;
+  // If an invalid storage is provided, fallback into MEMORY
+  if (typeof storage !== 'function' || storage.type !== STORAGE_MEMORY && storage.type !== STORAGE_LOCALSTORAGE) {
+    storage = InMemoryStorageCSFactory;
     log.warn(WARN_STORAGE_INVALID);
   }
 
+  // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+  if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
+    return __InLocalStorageMockFactory;
+  }
+
   // return default InMemory storage if provided one is not valid
-  return InMemoryStorageCSFactory;
+  return storage;
 }

package/src/utils/settingsValidation/types.ts

@@ -1,4 +1,3 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
 import { ISettings } from '../../types';
 
 /**
@@ -19,14 +18,6 @@ export interface ISettingsValidationParams {
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator */
   logger: (settings: ISettings) => ISettings['log'],
-}
-
-/**
- * Settings interface extended with private properties used for internal purposes.
- */
-export interface ISettingsInternal extends ISettings {
-  readonly sync: ISettings['sync'] & {
-    __splitFiltersValidation: ISplitFiltersValidation
-  }
-  readonly impressionListener?: unknown
+  /** Localhost mode validator */
+  localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
 }

package/src/utils/settingsValidation/url.ts

@@ -1,7 +1,7 @@
 import { ISettings } from '../../types';
 
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-const authEndpointMatcher = /^\/auth/;
+const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
 
 /**

package/types/evaluator/matchers/matcherTypes.d.ts

@@ -1,5 +1,5 @@
 export declare const matcherTypes: Record<string, number>;
-export declare const dataTypes: {
+export declare const matcherDataTypes: {
     BOOLEAN: string;
     STRING: string;
     NUMBER: string;
@@ -7,4 +7,4 @@ export declare const dataTypes: {
     DATETIME: string;
     NOT_SPECIFIED: string;
 };
-export declare function mapper(matcherType: string): number;
+export declare function matcherTypesMapper(matcherType: string): number;

package/types/listeners/browser.d.ts

@@ -2,17 +2,17 @@ import { ISignalListener } from './types';
 import { IStorageSync } from '../storages/types';
 import { ISplitApi } from '../services/types';
 import { ISettings } from '../types';
-import { MaybeThenable } from '../dtos/types';
+import { ISyncManager } from '../sync/types';
 /**
  * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
  */
 export default class BrowserSignalListener implements ISignalListener {
+    private syncManager;
     private settings;
     private storage;
     private serviceApi;
     private fromImpressionsCollector;
-    constructor(handler: (() => MaybeThenable<void>) | undefined, // Not used, but passed by sdkFactory for NodeSignalListener
-    settings: ISettings, storage: IStorageSync, serviceApi: ISplitApi);
+    constructor(syncManager: ISyncManager | undefined, settings: ISettings, storage: IStorageSync, serviceApi: ISplitApi);
     /**
      * start method.
      * Called when SplitFactory is initialized.

package/types/listeners/node.d.ts

@@ -1,6 +1,6 @@
 import { ISignalListener } from './types';
-import { MaybeThenable } from '../dtos/types';
 import { ISettings } from '../types';
+import { ISyncManager } from '../sync/types';
 /**
  * We'll listen for SIGTERM since it's the standard signal for server shutdown.
  *
@@ -11,7 +11,8 @@ import { ISettings } from '../types';
 export default class NodeSignalListener implements ISignalListener {
     private handler;
     private settings;
-    constructor(handler: () => MaybeThenable<void>, settings: ISettings);
+    constructor(syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,
+    settings: ISettings);
     start(): void;
     stop(): void;
     /**

package/types/logger/constants.d.ts

@@ -91,6 +91,7 @@ export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_STORAGE_INVALID = 222;
 export declare const WARN_API_KEY = 223;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;
@@ -114,6 +115,7 @@ export declare const ERROR_EMPTY = 319;
 export declare const ERROR_EMPTY_ARRAY = 320;
 export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export declare const ERROR_HTTP = 322;
+export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/sdkFactory/types.d.ts

@@ -1,4 +1,3 @@
-import { MaybeThenable } from '../dtos/types';
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
@@ -9,9 +8,9 @@ import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStor
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
-import { ISettingsInternal } from '../utils/settingsValidation/types';
 /**
- * Environment related dependencies
+ * Environment related dependencies.
+ * These getters are called a fixed number of times per factory instantiation.
  */
 export interface IPlatform {
     getOptions?: () => object;
@@ -23,7 +22,7 @@ export interface IPlatform {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
-    settings: ISettingsInternal;
+    settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;
@@ -33,7 +32,7 @@ export interface ISdkFactoryParams {
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
-    SignalListener?: new (handler: (() => MaybeThenable<void>) | undefined, // Used by NodeSignalListener
+    SignalListener?: new (syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;

package/types/services/types.d.ts

@@ -7,8 +7,10 @@ export declare type IResponse = {
     ok: boolean;
     status: number;
     json: () => Promise<any>;
+    text: () => Promise<string>;
 };
 export declare type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>;
+export declare type IHealthCheckAPI = () => Promise<boolean>;
 export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, logErrorsAsInfo?: boolean) => Promise<IResponse>;
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>;
@@ -20,6 +22,8 @@ export declare type IPostTestImpressionsCount = (body: string, headers?: Record<
 export declare type IPostMetricsCounters = (body: string) => Promise<IResponse>;
 export declare type IPostMetricsTimes = (body: string) => Promise<IResponse>;
 export interface ISplitApi {
+    getSdkAPIHealthCheck: IHealthCheckAPI;
+    getEventsAPIHealthCheck: IHealthCheckAPI;
     fetchAuth: IFetchAuth;
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;

package/types/storages/inLocalStorage/index.d.ts

@@ -1,8 +1,8 @@
-import { IStorageFactoryParams, IStorageSyncCS } from '../types';
+import { IStorageSyncFactory } from '../types';
 export interface InLocalStorageOptions {
     prefix?: string;
 }
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export declare function InLocalStorage(options?: InLocalStorageOptions): (params: IStorageFactoryParams) => IStorageSyncCS;
+export declare function InLocalStorage(options?: InLocalStorageOptions): IStorageSyncFactory;

package/types/storages/inMemory/InMemoryStorage.d.ts

@@ -5,3 +5,6 @@ import { IStorageFactoryParams, IStorageSync } from '../types';
  * @param params parameters required by EventsCacheSync
  */
 export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace InMemoryStorageFactory {
+    var type: import("../types").StorageType;
+}

package/types/storages/inMemory/InMemoryStorageCS.d.ts

@@ -5,3 +5,6 @@ import { IStorageSyncCS, IStorageFactoryParams } from '../types';
  * @param params parameters required by EventsCacheSync
  */
 export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS;
+export declare namespace InMemoryStorageCSFactory {
+    var type: import("../types").StorageType;
+}

package/types/storages/inRedis/index.d.ts

@@ -1,4 +1,4 @@
-import { IStorageAsync, IStorageFactoryParams } from '../types';
+import { IStorageAsyncFactory } from '../types';
 export interface InRedisStorageOptions {
     prefix?: string;
     options?: Record<string, any>;
@@ -7,4 +7,4 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export declare function InRedisStorage(options?: InRedisStorageOptions): ({ log, metadata, onReadyCb }: IStorageFactoryParams) => IStorageAsync;
+export declare function InRedisStorage(options?: InRedisStorageOptions): IStorageAsyncFactory;

package/types/storages/pluggable/index.d.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
+import { ICustomStorageWrapper, IStorageAsyncFactory } from '../types';
 export interface PluggableStorageOptions {
     prefix?: string;
     wrapper: ICustomStorageWrapper;
@@ -6,4 +6,4 @@ export interface PluggableStorageOptions {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export declare function PluggableStorage(options: PluggableStorageOptions): ({ log, metadata, onReadyCb }: IStorageFactoryParams) => IStorageAsync;
+export declare function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory;

package/types/storages/types.d.ts

@@ -54,15 +54,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`.
      *
@@ -78,19 +69,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 */
     /**
      * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
@@ -243,8 +234,8 @@ export interface ISegmentsCacheBase {
     clear(): MaybeThenable<boolean | void>;
 }
 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[];
@@ -353,3 +344,12 @@ export interface IStorageFactoryParams {
     onReadyCb?: (error?: any) => void;
     metadata: IMetadata;
 }
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+export declare type IStorageSyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageSync;
+};
+export declare type IStorageAsyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageAsync;
+};

package/types/sync/offline/splitsParser/splitsParserFromFile.d.ts

@@ -1,7 +1,2 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { SplitIO } from '../../../types';
-import { ILogger } from '../../../logger/types';
-export default function splitsParserFromFile({ features, log }: {
-    features?: SplitIO.MockedFeaturesFilePath;
-    log: ILogger;
-}): false | Record<string, ISplitPartial>;
+import { ISplitsParser } from './types';
+export declare function splitsParserFromFileFactory(): ISplitsParser;

package/types/sync/offline/splitsParser/splitsParserFromSettings.d.ts

@@ -1,7 +1,3 @@
 import { ISplitPartial } from '../../../dtos/types';
 import { ISettings } from '../../../types';
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-export default function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial>;
+export declare function splitsParserFromSettingsFactory(): (settings: ISettings) => false | Record<string, ISplitPartial>;

package/types/sync/polling/types.d.ts

@@ -2,10 +2,11 @@ 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/types/sync/streaming/AuthClient/indexV1.d.ts

@@ -0,0 +1,12 @@
+import { IFetchAuth } from '../../../services/types';
+import { IAuthenticate } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate;
+/**
+ * Returns the hash of a given user key
+ */
+export declare function hashUserKey(userKey: string): string;

package/types/sync/streaming/AuthClient/indexV2.d.ts

@@ -0,0 +1,8 @@
+import { IFetchAuthV2 } from '../../../services/types';
+import { IAuthenticateV2 } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuthV2: IFetchAuthV2): IAuthenticateV2;

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

@@ -6,6 +6,7 @@ export interface IAuthTokenPushEnabled {
     channels: {
         [channel: string]: string[];
     };
+    connDelay?: number;
 }
 export interface IAuthTokenPushDisabled {
     pushEnabled: false;
@@ -13,3 +14,4 @@ export interface IAuthTokenPushDisabled {
 }
 export declare type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled;
 export declare type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>;
+export declare type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>;

package/types/sync/streaming/SSEClient/index.d.ts

@@ -1,3 +1,4 @@
+import { ISettings } from '../../../types';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 /**
@@ -8,29 +9,25 @@ export default class SSEClient implements ISSEClient {
     streamingUrl: string;
     connection?: InstanceType<typeof EventSource>;
     handler?: ISseEventHandler;
-    authToken?: IAuthTokenPushEnabled;
+    useHeaders?: boolean;
+    headers: Record<string, string>;
     /**
      * SSEClient constructor.
      *
-     * @param streamingUrl URL
-     * @param eventSource optional EventSource constructor to use instead of the global one
-     * @throws 'EventSource API is not available. ' if EventSource is not passed and global one is not available
+     * @param settings Validated settings.
+     * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.
+     * @param getEventSource Function to get the EventSource constructor.
+     * @throws 'EventSource API is not available. ' if EventSource is not available.
      */
-    constructor(streamingUrl: string, getEventSource?: () => typeof EventSource | undefined);
+    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (typeof EventSource | undefined));
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken
      *
      * @param {IAuthTokenPushEnabled} authToken
-     * @throws {TypeError} if `authToken` is undefined
+     * @throws {TypeError} Will throw an error if `authToken` is undefined
      */
     open(authToken: IAuthTokenPushEnabled): void;
     /** Close connection  */
     close(): void;
-    /**
-     * Re-open the connection with the last given authToken.
-     *
-     * @throws {TypeError} if `open` has not been previously called with an authToken
-     */
-    reopen(): void;
 }

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

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

package/types/sync/streaming/SSEHandler/NotificationParser.d.ts

@@ -13,7 +13,8 @@ export declare 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 declare function messageParser(message: MessageEvent): INotificationMessage;
+export declare function messageParser(message: MessageEvent): INotificationMessage | undefined;

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

@@ -1,11 +1,34 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
 export interface IMySegmentsUpdateData {
     type: MY_SEGMENTS_UPDATE;
     changeNumber: number;
     includesPayload: boolean;
     segmentList?: string[];
 }
+export declare enum Compression {
+    None = 0,
+    Gzip = 1,
+    Zlib = 2
+}
+export declare enum UpdateStrategy {
+    UnboundedFetchRequest = 0,
+    BoundedFetchRequest = 1,
+    KeyList = 2,
+    SegmentRemoval = 3
+}
+export interface KeyList {
+    a?: string[];
+    r?: string[];
+}
+export interface IMySegmentsUpdateV2Data {
+    type: MY_SEGMENTS_UPDATE_V2;
+    changeNumber: number;
+    segmentName: string;
+    c: Compression;
+    d: string;
+    u: UpdateStrategy;
+}
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
     changeNumber: number;
@@ -31,7 +54,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;
@@ -40,4 +63,9 @@ export declare type INotificationMessage = {
 };
 export declare type INotificationError = Event & {
     parsedData?: any;
+    message?: string;
+};
+export declare type SegmentsData = string[] | {
+    name: string;
+    add: boolean;
 };

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,6 +1,7 @@
 import { ISegmentsSyncTask } from '../../polling/types';
 import Backoff from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
+import { SegmentsData } from '../SSEHandler/types';
 /**
  * MySegmentsUpdateWorker class
  */
@@ -8,7 +9,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
     private readonly mySegmentsSyncTask;
     private maxChangeNumber;
     private handleNewEvent;
-    private segmentList?;
+    private segmentsData?;
     private currentChangeNumber;
     readonly backoff: Backoff;
     /**
@@ -20,7 +21,7 @@ export default class MySegmentsUpdateWorker implements IUpdateWorker {
      * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
      *
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {string[] | undefined} segmentList might be undefined
+     * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    put(changeNumber: number, segmentList?: string[]): void;
+    put(changeNumber: number, segmentsData?: SegmentsData): void;
 }

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,6 +1,7 @@
 import { ISegmentsCacheSync } from '../../../storages/types';
 import Backoff from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentUpdateWorker class
@@ -23,5 +24,5 @@ export default class SegmentsUpdateWorker implements IUpdateWorker {
      * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
      * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
      */
-    put(changeNumber: number, segmentName: string): void;
+    put({ changeNumber, segmentName }: ISegmentUpdateData): void;
 }