@splitsoftware/splitio 10.17.1-rc.0 → 10.17.3-rc.0

package/lib/sync/SSEHandler/NotificationKeeper.js

@@ -1,104 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.default = notificationKeeperFactory;
-
-var _constants = require("../constants");
-
-var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-
-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(_constants.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(_constants.PUSH_SUBSYSTEM_DOWN);
-              } else if (hasPublishersNow && !hasPublishers) {
-                feedbackLoopEmitter.emit(_constants.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 === _constants.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 === _constants.ControlTypes.STREAMING_DISABLED) {
-              feedbackLoopEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
-            } else if (hasPublishers) {
-              if (controlType === _constants.ControlTypes.STREAMING_PAUSED && hasResumed) {
-                feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_DOWN);
-              } else if (controlType === _constants.ControlTypes.STREAMING_RESUMED && !hasResumed) {
-                feedbackLoopEmitter.emit(_constants.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 === _constants.ControlTypes.STREAMING_RESUMED;
-          }
-
-          return;
-        }
-      }
-    }
-  };
-}

package/lib/sync/SSEHandler/NotificationParser.js

@@ -1,39 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.errorParser = errorParser;
-exports.messageParser = messageParser;
-
-var _constants = require("../constants");
-
-var _lang = require("../../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
- */
-function errorParser(error) {
-  if ((0, _lang.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
- */
-
-
-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 = _constants.OCCUPANCY;
-  return messageData;
-}

package/lib/sync/SSEHandler/index.js

@@ -1,121 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = SSEHandlerFactory;
-
-var _NotificationParser = require("./NotificationParser");
-
-var _NotificationKeeper = _interopRequireDefault(require("./NotificationKeeper"));
-
-var _constants = require("../constants");
-
-var _logger = _interopRequireDefault(require("../../utils/logger"));
-
-var log = (0, _logger.default)('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
- */
-
-
-function SSEHandlerFactory(pushEmitter) {
-  var notificationKeeper = (0, _NotificationKeeper.default)(pushEmitter);
-  return {
-    handleOpen: function handleOpen() {
-      notificationKeeper.handleOpen();
-    },
-
-    /* HTTP & Network errors */
-    handleError: function handleError(error) {
-      var errorWithParsedData = error;
-
-      try {
-        errorWithParsedData = (0, _NotificationParser.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(_constants.PUSH_RETRYABLE_ERROR);
-      } else {
-        pushEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
-      }
-    },
-
-    /* NotificationProcessor */
-    handleMessage: function handleMessage(message) {
-      var messageWithParsedData;
-
-      try {
-        messageWithParsedData = (0, _NotificationParser.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() && [_constants.OCCUPANCY, _constants.CONTROL].indexOf(parsedData.type) === -1) return;
-
-      switch (parsedData.type) {
-        /* update events */
-        case _constants.SPLIT_UPDATE:
-          pushEmitter.emit(_constants.SPLIT_UPDATE, parsedData.changeNumber);
-          break;
-
-        case _constants.SEGMENT_UPDATE:
-          pushEmitter.emit(_constants.SEGMENT_UPDATE, parsedData.changeNumber, parsedData.segmentName);
-          break;
-
-        case _constants.MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(_constants.MY_SEGMENTS_UPDATE, parsedData, channel);
-          break;
-
-        case _constants.MY_SEGMENTS_UPDATE_V2:
-          pushEmitter.emit(_constants.MY_SEGMENTS_UPDATE_V2, parsedData);
-          break;
-
-        case _constants.SPLIT_KILL:
-          pushEmitter.emit(_constants.SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
-          break;
-
-        /* occupancy & control events, handled by NotificationManagerKeeper */
-
-        case _constants.OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-          break;
-
-        case _constants.CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-          break;
-
-        default:
-          break;
-      }
-    }
-  };
-}

package/lib/sync/SegmentUpdateWorker/browser.js

@@ -1,81 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _backoff = _interopRequireDefault(require("../../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.default(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;
-}();
-
-exports.default = MySegmentUpdateWorker;

package/lib/sync/SegmentUpdateWorker/node.js

@@ -1,86 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _backoff = _interopRequireDefault(require("../../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.default(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;
-}();
-
-exports.default = SegmentUpdateWorker;

package/lib/sync/SegmentUpdateWorker/package.json

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

package/lib/sync/SplitUpdateWorker/index.js

@@ -1,93 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _backoff = _interopRequireDefault(require("../../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.default(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;
-}();
-
-exports.default = SplitUpdateWorker;

package/lib/sync/browser.js

@@ -1,139 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = BrowserSyncManagerFactory;
-
-var _PushManager = _interopRequireDefault(require("./PushManager"));
-
-var _producer = _interopRequireDefault(require("../producer"));
-
-var _Partial = _interopRequireDefault(require("../producer/browser/Partial"));
-
-var _factory = require("../utils/key/factory");
-
-var _lang = require("../utils/lang");
-
-var _logger = _interopRequireDefault(require("../utils/logger"));
-
-var _constants = require("./constants");
-
-var log = (0, _logger.default)('splitio-sync:sync-manager');
-/**
- * Factory of sync manager for browser
- *
- * @param context main client context
- */
-
-function BrowserSyncManagerFactory(mainContext) {
-  // map of user keys to client contexts
-  var contexts = {};
-  var settings = mainContext.get(mainContext.constants.SETTINGS); // call `createInstance` before creating PushManager, since it is in charge of creating the full producer and adding it into the main context.
-
-  var syncManager = createInstance(false, mainContext);
-  var pushManager = settings.streamingEnabled ? (0, _PushManager.default)(mainContext, contexts) : undefined;
-  var mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-
-  function startPolling() {
-    if (!mainProducer.isRunning()) {
-      log.info('Streaming not available. Starting periodic fetch of data.');
-      (0, _lang.forOwn)(contexts, function (context) {
-        var producer = context.get(context.constants.PRODUCER);
-        producer.start();
-      });
-    } else {
-      log.info('Streaming couldn\'t connect. Continue periodic fetch of data.');
-    }
-  }
-
-  function stopPollingAndSyncAll() {
-    if (mainProducer.isRunning()) {
-      log.info('PUSH (re)connected. Syncing and stopping periodic fetch of data.'); // if polling, stop
-
-      (0, _lang.forOwn)(contexts, function (context) {
-        var producer = context.get(context.constants.PRODUCER);
-        producer.stop();
-      });
-    }
-
-    syncAll();
-  }
-
-  function syncAll() {
-    // fetch splits and segments
-    var mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-    mainProducer.synchronizeSplits();
-    (0, _lang.forOwn)(contexts, function (context) {
-      var producer = context.get(context.constants.PRODUCER);
-      producer.synchronizeMySegments();
-    });
-  }
-  /**
-   * Creates a SyncManager that handles the synchronization of clients (main and shared ones).
-   * Internally, it creates the client producer, adds it into its context, and defines the `start` and `stop` methods that handle synchronization.
-   *
-   * @param {Object} context
-   * @param {boolean} isSharedClient
-   */
-
-
-  function createInstance(isSharedClient, context) {
-    var producer = isSharedClient ? (0, _Partial.default)(context) : (0, _producer.default)(context);
-    var settings = context.get(context.constants.SETTINGS); // we need to stringify the user key (or matching key) in case it is not an string, to hash and pass as query param for authentication
-
-    var userKey = (0, _lang.toString)((0, _factory.matching)(settings.core.key));
-    context.put(context.constants.PRODUCER, producer);
-    if (contexts[userKey]) log.warn('A client with the same user key has already been created. Only the new instance will be properly synchronized.');
-    contexts[userKey] = context;
-    return {
-      start: function start() {
-        // start syncing
-        if (pushManager) {
-          if (!isSharedClient) {
-            syncAll(); // initial syncAll (only when main client is created)
-
-            pushManager.on(_constants.PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-            pushManager.on(_constants.PUSH_SUBSYSTEM_DOWN, startPolling);
-          } else {
-            if (mainProducer.isRunning()) {
-              // if doing polling, we must start the producer periodic fetch of data
-              producer.start();
-            } else {
-              // if not doing polling, we must perform a `producer.synchronizeMySegments` for the initial fetch
-              // of segments since `syncAll` was already executed when starting the main client
-              producer.synchronizeMySegments();
-            }
-          }
-
-          pushManager.startNewClient(userKey, context);
-        } else {
-          producer.start();
-        }
-      },
-      stop: function stop() {
-        var context = contexts[userKey];
-
-        if (context) {
-          // check in case `client.destroy()` has been invoked more than once for the same client
-          delete contexts[userKey];
-
-          if (pushManager) {
-            pushManager.removeClient(userKey); // stop push if stoping main client
-
-            if (!isSharedClient) pushManager.stop(); // We don't reconnect pushmanager when removing a shared client,
-            // since it is more costly than continue listening the channel
-          }
-
-          if (producer.isRunning()) producer.stop();
-        }
-      }
-    };
-  } // For the main client we return a SyncManager with 3 methods: start, stop and shared. The last is used to instantiate "partial SyncManagers".
-
-
-  syncManager.shared = createInstance.bind(null, true); // pushManager is exposed to close SSE connection in browser on 'unload' DOM event.
-
-  syncManager.pushManager = pushManager;
-  return syncManager;
-}