@splitsoftware/splitio 10.17.3 → 10.17.4-rc.2

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

@@ -1,18 +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) {
-  var esReference = getEventSource();
-
-  if (!esReference) {
-    logger.warn('EventSource API is not available. Falling back to polling mode.');
-    return false;
-  }
-
-  return true;
-}

package/es/sync/SSEClient/index.js

@@ -1,93 +0,0 @@
-import getEventSource from '../../services/getEventSource';
-var VERSION = '1.1';
-var CONTROL_CHANNEL_REGEX = /^control_/;
-/**
- * Build metadata headers for SSE connection.
- *
- * @param {Object} settings Validated settings.
- */
-
-function buildSSEHeaders(settings) {
-  var headers = {
-    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
-    SplitSDKVersion: settings.version
-  }; // ip and hostname are false if IPAddressesEnabled is false
-
-  var _settings$runtime = settings.runtime,
-      ip = _settings$runtime.ip,
-      hostname = _settings$runtime.hostname;
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
-  return headers;
-}
-
-var SSEClient = /*#__PURE__*/function () {
-  /**
-   * 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.
-   */
-  SSEClient.getInstance = function getInstance(settings, useHeaders) {
-    var 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
-  ;
-
-  function SSEClient(EventSource, settings, useHeaders) {
-    this.EventSource = EventSource;
-    this.streamingUrl = settings.url('/sse');
-    this.useHeaders = useHeaders;
-    this.headers = buildSSEHeaders(settings);
-  }
-
-  var _proto = SSEClient.prototype;
-
-  _proto.setEventHandler = function 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
-   */
-  ;
-
-  _proto.open = function open(authToken) {
-    this.close(); // it closes connection if previously opened
-
-    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( // 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  */
-  ;
-
-  _proto.close = function close() {
-    if (this.connection) this.connection.close();
-  };
-
-  return SSEClient;
-}();
-
-export { SSEClient as default };

package/es/sync/SSEHandler/NotificationKeeper.js

@@ -1,97 +0,0 @@
-import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN, PUSH_NONRETRYABLE_ERROR, ControlTypes } from '../constants';
-var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-export default function notificationKeeperFactory(feedbackLoopEmitter) {
-  var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) {
-    return {
-      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
-
-  var hasPublishers = true; // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
-
-  var hasResumed = true;
-
-  function getHasPublishers() {
-    // computes the value of `hasPublishers`
-    return channels.some(function (c) {
-      return c.hasPublishers;
-    });
-  }
-
-  return {
-    handleOpen: function handleOpen() {
-      feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_UP);
-    },
-    isStreamingUp: function isStreamingUp() {
-      return hasResumed && hasPublishers;
-    },
-    handleOccupancyEvent: function handleOccupancyEvent(publishers, channel, timestamp) {
-      for (var i = 0; i < channels.length; i++) {
-        var c = channels[i];
-
-        if (c.regex.test(channel)) {
-          if (timestamp > c.oTime) {
-            c.oTime = timestamp;
-            c.hasPublishers = publishers !== 0;
-            var 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: function 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 (var i = 0; i < channels.length; i++) {
-        var 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/es/sync/SSEHandler/NotificationParser.js

@@ -1,31 +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) {
-  var 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;
-}

package/es/sync/SSEHandler/index.js

@@ -1,110 +0,0 @@
-import { errorParser, messageParser } from './NotificationParser';
-import notificationKeeperFactory from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, SPLIT_UPDATE, SEGMENT_UPDATE, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SPLIT_KILL, OCCUPANCY, CONTROL } from '../constants';
-import logFactory from '../../utils/logger';
-var log = logFactory('splitio-sync:sse-handler');
-
-function isRetryableError(error) {
-  if (error.parsedData && error.parsedData.code) {
-    var code = error.parsedData.code; // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
-
-    if (40140 <= code && code <= 40149) return true; // Others 4XX errors (e.g., bad request from the SDK)
-
-    if (40000 <= code && code <= 49999) return false;
-  } // network errors or 5XX HTTP errors
-
-
-  return true;
-}
-/**
- * Factory for SSEHandler
- *
- * @param {Object} pushEmitter emitter for emitting events related to feedback-loop & update queues
- */
-
-
-export default function SSEHandlerFactory(pushEmitter) {
-  var notificationKeeper = notificationKeeperFactory(pushEmitter);
-  return {
-    handleOpen: function handleOpen() {
-      notificationKeeper.handleOpen();
-    },
-
-    /* HTTP & Network errors */
-    handleError: function handleError(error) {
-      var errorWithParsedData = error;
-
-      try {
-        errorWithParsedData = errorParser(error);
-      } catch (err) {
-        log.warn("Error parsing SSE error notification: " + err);
-      }
-
-      var errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
-      log.error("Fail to connect to streaming" + (errorMessage ? ", with error message: \"" + errorMessage + "\"" : ''));
-
-      if (isRetryableError(errorWithParsedData)) {
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      } else {
-        pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-      }
-    },
-
-    /* NotificationProcessor */
-    handleMessage: function handleMessage(message) {
-      var messageWithParsedData;
-
-      try {
-        messageWithParsedData = messageParser(message);
-      } catch (err) {
-        log.warn("Error parsing new SSE message notification: " + err);
-        return;
-      }
-
-      var _messageWithParsedDat = messageWithParsedData,
-          parsedData = _messageWithParsedDat.parsedData,
-          data = _messageWithParsedDat.data,
-          channel = _messageWithParsedDat.channel,
-          timestamp = _messageWithParsedDat.timestamp;
-      log.debug("New SSE message received, with data: " + data + "."); // we only handle update events if streaming is up.
-
-      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);
-          break;
-
-        case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(MY_SEGMENTS_UPDATE, parsedData, channel);
-          break;
-
-        case MY_SEGMENTS_UPDATE_V2:
-          pushEmitter.emit(MY_SEGMENTS_UPDATE_V2, parsedData);
-          break;
-
-        case SPLIT_KILL:
-          pushEmitter.emit(SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
-          break;
-
-        /* occupancy & control events, handled by NotificationManagerKeeper */
-
-        case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-          break;
-
-        case CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-          break;
-
-        default:
-          break;
-      }
-    }
-  };
-}

package/es/sync/SegmentUpdateWorker/browser.js

@@ -1,74 +0,0 @@
-import Backoff from '../../utils/backoff';
-/**
- * MySegmentUpdateWorker class
- */
-
-var MySegmentUpdateWorker = /*#__PURE__*/function () {
-  /**
-   *
-   * @param {Object} mySegmentsStorage
-   * @param {Object} mySegmentsProducer
-   */
-  function MySegmentUpdateWorker(mySegmentsStorage, mySegmentsProducer) {
-    this.mySegmentsStorage = mySegmentsStorage;
-    this.mySegmentsProducer = mySegmentsProducer;
-    this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-
-    this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-
-    this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
-
-    this.put = this.put.bind(this);
-    this.__handleMySegmentUpdateCall = this.__handleMySegmentUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleMySegmentUpdateCall);
-  } // Private method
-  // Preconditions: this.mySegmentsProducer.isSynchronizingMySegments === false
-  // @TODO update this block similar to SplitUpdateWorker, once `/mySegments` endpoint provides the changeNumber
-
-
-  var _proto = MySegmentUpdateWorker.prototype;
-
-  _proto.__handleMySegmentUpdateCall = function __handleMySegmentUpdateCall() {
-    var _this = this;
-
-    if (this.maxChangeNumber > this.currentChangeNumber) {
-      this.handleNewEvent = false;
-      var currentMaxChangeNumber = this.maxChangeNumber; // fetch mySegments revalidating data if cached
-
-      this.mySegmentsProducer.synchronizeMySegments(this.segmentsData, true).then(function (result) {
-        if (result !== false) // Unlike `Split\SegmentUpdateWorker`, we cannot use `mySegmentsStorage.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-          _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-
-        if (_this.handleNewEvent) {
-          _this.__handleMySegmentUpdateCall();
-        } else {
-          _this.backoff.scheduleCall();
-        }
-      });
-    }
-  }
-  /**
-   * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-   *
-   * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData might be undefined
-   */
-  ;
-
-  _proto.put = function put(changeNumber, segmentsData) {
-    // @TODO uncomment next line once `/mySegments` endpoint provides the changeNumber
-    // const currentChangeNumber = this.mySegmentsStorage.getChangeNumber();
-    if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-    this.segmentsData = segmentsData;
-    if (this.mySegmentsProducer.isSynchronizingMySegments()) return;
-
-    this.__handleMySegmentUpdateCall();
-  };
-
-  return MySegmentUpdateWorker;
-}();
-
-export { MySegmentUpdateWorker as default };

package/es/sync/SegmentUpdateWorker/node.js

@@ -1,79 +0,0 @@
-import Backoff from '../../utils/backoff';
-/**
- * SegmentUpdateWorker class
- */
-
-var SegmentUpdateWorker = /*#__PURE__*/function () {
-  /**
-   * @param {Object} segmentsStorage
-   * @param {Object} segmentsProducer
-   */
-  function SegmentUpdateWorker(segmentsStorage, segmentsProducer) {
-    this.segmentsStorage = segmentsStorage;
-    this.segmentsProducer = segmentsProducer;
-    this.maxChangeNumbers = {};
-    this.put = this.put.bind(this);
-    this.__handleSegmentUpdateCall = this.__handleSegmentUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleSegmentUpdateCall);
-  } // Private method
-  // Preconditions: this.segmentsProducer.isSynchronizingSegments === false
-  // Approach similar to MySegmentUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
-
-
-  var _proto = SegmentUpdateWorker.prototype;
-
-  _proto.__handleSegmentUpdateCall = function __handleSegmentUpdateCall() {
-    var _this = this;
-
-    var segmentsToFetch = Object.keys(this.maxChangeNumbers).filter(function (segmentName) {
-      return _this.maxChangeNumbers[segmentName] > _this.segmentsStorage.getChangeNumber(segmentName);
-    });
-
-    if (segmentsToFetch.length > 0) {
-      this.handleNewEvent = false;
-      var currentMaxChangeNumbers = segmentsToFetch.map(function (segmentToFetch) {
-        return _this.maxChangeNumbers[segmentToFetch];
-      }); // fetch segments revalidating data if cached
-
-      this.segmentsProducer.synchronizeSegment(segmentsToFetch, true).then(function (result) {
-        // Unlike `SplitUpdateWorker` where changeNumber is consistent between notification and endpoint, if there is no error,
-        // we must clean the `maxChangeNumbers` of those segments that didn't receive a new update notification during the fetch.
-        if (result !== false) {
-          segmentsToFetch.forEach(function (fetchedSegment, index) {
-            if (_this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers[index]) _this.maxChangeNumbers[fetchedSegment] = -1;
-          });
-        } else {
-          // recursive invocation with backoff if there was some error
-          _this.backoff.scheduleCall();
-        } // immediate recursive invocation if a new notification was queued during fetch
-
-
-        if (_this.handleNewEvent) {
-          _this.__handleSegmentUpdateCall();
-        }
-      });
-    }
-  }
-  /**
-   * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-   *
-   * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-   * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
-   */
-  ;
-
-  _proto.put = function put(changeNumber, segmentName) {
-    var currentChangeNumber = this.segmentsStorage.getChangeNumber(segmentName);
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName]) return;
-    this.maxChangeNumbers[segmentName] = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-    if (this.segmentsProducer.isSynchronizingSegments()) return;
-
-    this.__handleSegmentUpdateCall();
-  };
-
-  return SegmentUpdateWorker;
-}();
-
-export { SegmentUpdateWorker as default };

package/es/sync/SplitUpdateWorker/index.js

@@ -1,86 +0,0 @@
-import Backoff from '../../utils/backoff';
-/**
- * SplitUpdateWorker class
- */
-
-var SplitUpdateWorker = /*#__PURE__*/function () {
-  /**
-   * @param {Object} splitStorage splits cache
-   * @param {Object} splitProducer node producer or full browser producer
-   * @param {Object} splitsEventEmitter
-   */
-  function SplitUpdateWorker(splitStorage, splitProducer, splitsEventEmitter) {
-    this.splitStorage = splitStorage;
-    this.splitProducer = splitProducer;
-    this.maxChangeNumber = 0;
-    this.splitsEventEmitter = splitsEventEmitter;
-    this.put = this.put.bind(this);
-    this.killSplit = this.killSplit.bind(this);
-    this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
-    this.backoff = new Backoff(this.__handleSplitUpdateCall);
-  } // Private method
-  // Preconditions: this.splitProducer.isSynchronizingSplits === false
-
-
-  var _proto = SplitUpdateWorker.prototype;
-
-  _proto.__handleSplitUpdateCall = function __handleSplitUpdateCall() {
-    var _this = this;
-
-    if (this.maxChangeNumber > this.splitStorage.getChangeNumber()) {
-      this.handleNewEvent = false; // fetch splits revalidating data if cached
-
-      this.splitProducer.synchronizeSplits(true).then(function () {
-        if (_this.handleNewEvent) {
-          _this.__handleSplitUpdateCall();
-        } else {
-          // fetch new registered segments for server-side API. Not retrying on error
-          if (_this.splitProducer.synchronizeSegment) _this.splitProducer.synchronizeSegment(undefined, false, true);
-
-          _this.backoff.scheduleCall();
-        }
-      });
-    }
-  }
-  /**
-   * Invoked by NotificationProcessor on SPLIT_UPDATE event
-   *
-   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-   */
-  ;
-
-  _proto.put = function put(changeNumber) {
-    var currentChangeNumber = this.splitStorage.getChangeNumber();
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
-    if (this.splitProducer.isSynchronizingSplits()) return;
-
-    this.__handleSplitUpdateCall();
-  }
-  /**
-   * Invoked by NotificationProcessor on SPLIT_KILL event
-   *
-   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-   * @param {string} splitName name of split to kill
-   * @param {string} defaultTreatment default treatment value
-   */
-  ;
-
-  _proto.killSplit = function killSplit(changeNumber, splitName, defaultTreatment) {
-    var _this2 = this;
-
-    // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
-    this.splitStorage.killLocally(splitName, defaultTreatment, changeNumber).then(function (updated) {
-      // trigger an SDK_UPDATE if Split was killed locally
-      if (updated) _this2.splitsEventEmitter.emit(_this2.splitsEventEmitter.SDK_SPLITS_ARRIVED, true); // queues the SplitChanges fetch (only if changeNumber is newer)
-
-      _this2.put(changeNumber);
-    });
-  };
-
-  return SplitUpdateWorker;
-}();
-
-export { SplitUpdateWorker as default };