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

package/esm/sync/offline/splitsParser/splitsParserFromFile.js

@@ -8,7 +8,6 @@ import { isString, endsWith, find, forOwn, uniq, } from '../../../utils/lang';
 import parseCondition from './parseCondition';
 var logPrefix = 'sync:offline:splits-fetcher: ';
 var DEFAULT_FILENAME = '.split';
-var previousMock = 'NO_MOCK_LOADED';
 function configFilesPath(configFilePath) {
     if (configFilePath === DEFAULT_FILENAME || !isString(configFilePath)) {
         var root = process.env.HOME;
@@ -25,81 +24,6 @@ function configFilesPath(configFilePath) {
         throw new Error("Split configuration not found in " + configFilePath + " - Please review your Split file location.");
     return configFilePath;
 }
-// Parse `.split` configuration file and return a map of "Split Objects"
-function readSplitConfigFile(log, filePath) {
-    var SPLIT_POSITION = 0;
-    var TREATMENT_POSITION = 1;
-    var data;
-    try {
-        data = fs.readFileSync(filePath, 'utf-8');
-    }
-    catch (e) {
-        log.error(e.message);
-        return {};
-    }
-    if (data === previousMock)
-        return false;
-    previousMock = data;
-    var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
-        var tuple = 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 {
-                var splitName = tuple[SPLIT_POSITION];
-                var condition = parseCondition({ treatment: tuple[TREATMENT_POSITION] });
-                accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
-            }
-        }
-        return accum;
-    }, {});
-    return splitObjects;
-}
-// Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
-function readYAMLConfigFile(log, filePath) {
-    var data = '';
-    var 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.
-    var mocksData = yamldoc.reduce(function (accum, splitEntry) {
-        var splitName = Object.keys(splitEntry)[0];
-        if (!splitName || !isString(splitEntry[splitName].treatment))
-            log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
-        var 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.
-        var 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;
-    }, {});
-    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) {
@@ -127,18 +51,96 @@ function arrangeConditions(mocksData) {
         delete data.treatments;
     });
 }
-// Load the content of a configuration file into an Object
-export default function splitsParserFromFile(_a) {
-    var features = _a.features, log = _a.log;
-    var filePath = configFilesPath(features);
-    var mockData;
-    // 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);
+export function splitsParserFromFileFactory() {
+    var previousMock = 'NO_MOCK_LOADED';
+    // Parse `.split` configuration file and return a map of "Split Objects"
+    function readSplitConfigFile(log, filePath) {
+        var SPLIT_POSITION = 0;
+        var TREATMENT_POSITION = 1;
+        var data;
+        try {
+            data = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (e) {
+            log.error(e.message);
+            return {};
+        }
+        if (data === previousMock)
+            return false;
+        previousMock = data;
+        var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
+            var tuple = 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 {
+                    var splitName = tuple[SPLIT_POSITION];
+                    var condition = parseCondition({ treatment: tuple[TREATMENT_POSITION] });
+                    accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
+                }
+            }
+            return accum;
+        }, {});
+        return splitObjects;
     }
-    else {
-        mockData = readYAMLConfigFile(log, filePath);
+    // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
+    function readYAMLConfigFile(log, filePath) {
+        var data = '';
+        var 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.
+        var mocksData = yamldoc.reduce(function (accum, splitEntry) {
+            var splitName = Object.keys(splitEntry)[0];
+            if (!splitName || !isString(splitEntry[splitName].treatment))
+                log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
+            var 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.
+            var 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;
+        }, {});
+        arrangeConditions(mocksData);
+        return mocksData;
     }
-    return mockData;
+    // Load the content of a configuration file into an Object
+    return function splitsParserFromFile(_a) {
+        var features = _a.features, log = _a.log;
+        var filePath = configFilesPath(features);
+        var mockData;
+        // 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/esm/sync/offline/splitsParser/splitsParserFromSettings.js

@@ -1,6 +1,5 @@
 import { isObject, forOwn } from '../../../utils/lang';
 import parseCondition from './parseCondition';
-var previousMock = { 'emptyMock': '1' };
 function hasTreatmentChanged(prev, curr) {
     if (typeof prev !== typeof curr)
         return true;
@@ -11,46 +10,49 @@ function hasTreatmentChanged(prev, curr) {
         return prev.treatment !== curr.treatment || prev.config !== curr.config;
     }
 }
-function mockUpdated(currentData) {
-    var names = Object.keys(currentData);
-    // Different amount of items
-    if (names.length !== Object.keys(previousMock).length) {
-        previousMock = currentData;
-        return true;
-    }
-    return names.some(function (name) {
-        var newSplit = !previousMock[name];
-        var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-        var changed = newSplit || newTreatment;
-        if (changed)
+export function splitsParserFromSettingsFactory() {
+    var previousMock = { 'emptyMock': '1' };
+    function mockUpdated(currentData) {
+        var names = Object.keys(currentData);
+        // Different amount of items
+        if (names.length !== Object.keys(previousMock).length) {
             previousMock = currentData;
-        return changed;
-    });
-}
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-export default function splitsParserFromSettings(settings) {
-    var features = settings.features || {};
-    if (!mockUpdated(features))
-        return false;
-    var splitObjects = {};
-    forOwn(features, function (data, splitName) {
-        var treatment = data;
-        var config = null;
-        if (isObject(data)) {
-            treatment = data.treatment;
-            config = data.config || config;
+            return true;
         }
-        var configurations = {};
-        if (config !== null)
-            configurations[treatment] = config;
-        splitObjects[splitName] = {
-            trafficTypeName: 'localhost',
-            conditions: [parseCondition({ treatment: treatment })],
-            configurations: configurations
-        };
-    });
-    return splitObjects;
+        return names.some(function (name) {
+            var newSplit = !previousMock[name];
+            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
+            var changed = newSplit || newTreatment;
+            if (changed)
+                previousMock = currentData;
+            return changed;
+        });
+    }
+    /**
+     *
+     * @param settings validated object with mocked features mapping.
+     */
+    return function splitsParserFromSettings(settings) {
+        var features = settings.features || {};
+        if (!mockUpdated(features))
+            return false;
+        var splitObjects = {};
+        forOwn(features, function (data, splitName) {
+            var treatment = data;
+            var config = null;
+            if (isObject(data)) {
+                treatment = data.treatment;
+                config = data.config || config;
+            }
+            var configurations = {};
+            if (config !== null)
+                configurations[treatment] = config;
+            splitObjects[splitName] = {
+                trafficTypeName: 'localhost',
+                conditions: [parseCondition({ treatment: treatment })],
+                configurations: configurations
+            };
+        });
+        return splitObjects;
+    };
 }

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -1,13 +1,14 @@
 import { forOwn } from '../../../utils/lang';
 import syncTaskFactory from '../../syncTask';
 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';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 export function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log;
+    var log = settings.log, splitsCache = storage.splits;
+    var startingUp = true;
     return function objectUpdater() {
         var splits = [];
         var loadError = null;
@@ -37,11 +38,20 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 ]);
             });
             return Promise.all([
-                storage.splits.clear(),
-                storage.splits.addSplits(splits)
+                splitsCache.clear(),
+                splitsCache.addSplits(splits)
             ]).then(function () {
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                if (startingUp) {
+                    startingUp = false;
+                    Promise.resolve(splitsCache.checkCache()).then(function (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;
             });
         }

package/esm/sync/polling/fetchers/segmentChangesFetcher.js

@@ -12,14 +12,6 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
                 return __spreadArrays([flatMe[0]], flatMe[1]);
             });
         }
-    })
-        .catch(function (err) {
-        // If the operation is forbidden it may be due to permissions, don't recover and propagate the error.
-        if (err.statusCode === 403)
-            throw err;
-        // if something goes wrong with the request to the server, we are going to
-        // stop requesting information till the next round of downloading
-        return [];
     });
 }
 /**

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -20,19 +20,36 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
         // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
     }
     // @TODO if allowing custom storages, handle async execution
-    function updateSegments(segments) {
-        // Update the list of segment names available
-        var shouldNotifyUpdate = mySegmentsCache.resetSegments(segments);
+    function updateSegments(segmentsData) {
+        var shouldNotifyUpdate;
+        if (Array.isArray(segmentsData)) {
+            // Update the list of segment names available
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        }
+        else {
+            // Add/Delete the segment
+            var name_1 = segmentsData.name, add = segmentsData.add;
+            if (mySegmentsCache.isInSegment(name_1) !== add) {
+                shouldNotifyUpdate = true;
+                if (add)
+                    mySegmentsCache.addToSegment(name_1);
+                else
+                    mySegmentsCache.removeFromSegment(name_1);
+            }
+            else {
+                shouldNotifyUpdate = false;
+            }
+        }
         // Notify update if required
         if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentList, noCache) {
-        var updaterPromise = segmentList ?
-            // If segmentList is provided, there is no need to fetch mySegments
-            new Promise(function (res) { updateSegments(segmentList); res(true); }) :
+    function _mySegmentsUpdater(retry, segmentsData, noCache) {
+        var updaterPromise = segmentsData ?
+            // If segmentsData is provided, there is no need to fetch mySegments
+            new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
             mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
@@ -56,10 +73,13 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
      * 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, noCache) {
-        return _mySegmentsUpdater(0, segmentList, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -78,15 +78,13 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                     if (readiness)
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
                 }
-                // if at least one segment fetch fails, return false to indicate that there was some error (e.g., invalid json, HTTP error, etc)
-                if (shouldUpdateFlags.indexOf(-1) !== -1)
-                    return false;
                 return true;
             });
         })
             // Handles rejected promises at `segmentChangesFetcher`, `segments.getRegisteredSegments` and other segment storage operations.
             .catch(function (error) {
-            if (error.statusCode === 403) {
+            if (error && error.statusCode === 403) {
+                // If the operation is forbidden, it may be due to permissions. Destroy the SDK instance.
                 // @TODO although factory status is destroyed, synchronization is not stopped
                 if (readiness)
                     readiness.destroy();

package/esm/sync/streaming/SSEClient/index.js

@@ -1,5 +1,24 @@
 var VERSION = '1.1';
 var CONTROL_CHANNEL_REGEX = /^control_/;
+/**
+ * Build metadata headers for SSE connection.
+ *
+ * @param {ISettings} settings Validated settings.
+ * @returns {Record<string, string>} Headers object
+ */
+function buildSSEHeaders(settings) {
+    var headers = {
+        SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+        SplitSDKVersion: settings.version,
+    };
+    // ip and hostname are false if IPAddressesEnabled is false
+    var _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+    if (ip)
+        headers['SplitSDKMachineIP'] = ip;
+    if (hostname)
+        headers['SplitSDKMachineName'] = hostname;
+    return headers;
+}
 /**
  * Handles streaming connections with EventSource API
  */
@@ -7,18 +26,21 @@ var SSEClient = /** @class */ (function () {
     /**
      * 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.
      */
-    function SSEClient(streamingUrl, getEventSource) {
+    function SSEClient(settings, useHeaders, getEventSource) {
         // @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 = streamingUrl + '/sse';
-        this.reopen = this.reopen.bind(this);
+        this.streamingUrl = settings.urls.streaming + '/sse';
+        // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
+        this.useHeaders = useHeaders;
+        this.headers = buildSSEHeaders(settings);
     }
     SSEClient.prototype.setEventHandler = function (handler) {
         this.handler = handler;
@@ -27,21 +49,25 @@ var SSEClient = /** @class */ (function () {
      * 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
      */
     SSEClient.prototype.open = function (authToken) {
         this.close(); // it closes connection if previously opened
-        this.authToken = authToken;
         var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
             var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
             return encodeURIComponent(params + channel);
         }).join(',');
         var url = this.streamingUrl + "?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
-        this.connection = new this.eventSource(url);
+        this.connection = new this.eventSource(
+        // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is 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), 
+        // @ts-ignore. For server-side SDKs, metadata is passed via headers. EventSource must support headers, like 'eventsource' package for Node.
+        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;
+            this.connection.addEventListener('open', this.handler.handleOpen);
+            this.connection.addEventListener('message', this.handler.handleMessage);
+            this.connection.addEventListener('error', this.handler.handleError);
         }
     };
     /** Close connection  */
@@ -49,14 +75,6 @@ var SSEClient = /** @class */ (function () {
         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
-     */
-    SSEClient.prototype.reopen = function () {
-        this.open(this.authToken);
-    };
     return SSEClient;
 }());
 export default SSEClient;

package/esm/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -52,6 +52,13 @@ export default function notificationKeeperFactory(pushEmitter) {
             }
         },
         handleControlEvent: function (controlType, channel, timestamp) {
+            /* 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 (var i = 0; i < channels.length; i++) {
                 var c = channels[i];
                 if (c.regex.test(channel)) {

package/esm/sync/streaming/SSEHandler/NotificationParser.js

@@ -19,10 +19,13 @@ export function errorParser(error) {
  * 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) {
+    if (!message.data)
+        return;
     var messageData = JSON.parse(message.data);
     messageData.parsedData = JSON.parse(messageData.data);
     // set the event type to OCCUPANCY, to handle all events uniformely

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import notificationKeeperFactory from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 function isRetryableError(error) {
     if (error.parsedData && error.parsedData.code) {
@@ -36,7 +36,7 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             catch (err) {
                 log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);
             }
-            var errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
+            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
             log.error(ERROR_STREAMING_SSE, [errorMessage]);
             if (isRetryableError(errorWithParsedData)) {
                 pushEmitter.emit(PUSH_RETRYABLE_ERROR);
@@ -50,6 +50,8 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             var messageWithParsedData;
             try {
                 messageWithParsedData = messageParser(message);
+                if (!messageWithParsedData)
+                    return; // Messages with empty data are ignored
             }
             catch (err) {
                 log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);
@@ -58,21 +60,18 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(STREAMING_NEW_MESSAGE, [data]);
             // we only handle update events if streaming is up.
-            if (!notificationKeeper.isStreamingUp() && parsedData.type !== OCCUPANCY && parsedData.type !== CONTROL)
+            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
-                    pushEmitter.emit(SPLIT_UPDATE, parsedData.changeNumber);
-                    break;
                 case SEGMENT_UPDATE:
-                    pushEmitter.emit(SEGMENT_UPDATE, parsedData.changeNumber, parsedData.segmentName);
+                case MY_SEGMENTS_UPDATE_V2:
+                case SPLIT_KILL:
+                    pushEmitter.emit(parsedData.type, parsedData);
                     break;
                 case MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(MY_SEGMENTS_UPDATE, parsedData, channel);
-                    break;
-                case SPLIT_KILL:
-                    pushEmitter.emit(SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
+                    pushEmitter.emit(parsedData.type, parsedData, channel);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:

package/esm/sync/streaming/SSEHandler/types.js

@@ -1 +1,13 @@
-export {};
+export var Compression;
+(function (Compression) {
+    Compression[Compression["None"] = 0] = "None";
+    Compression[Compression["Gzip"] = 1] = "Gzip";
+    Compression[Compression["Zlib"] = 2] = "Zlib";
+})(Compression || (Compression = {}));
+export var UpdateStrategy;
+(function (UpdateStrategy) {
+    UpdateStrategy[UpdateStrategy["UnboundedFetchRequest"] = 0] = "UnboundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["BoundedFetchRequest"] = 1] = "BoundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["KeyList"] = 2] = "KeyList";
+    UpdateStrategy[UpdateStrategy["SegmentRemoval"] = 3] = "SegmentRemoval";
+})(UpdateStrategy || (UpdateStrategy = {}));