@splitsoftware/splitio 10.17.3-rc.4 → 10.17.4-rc.1

package/src/sync/SSEClient/index.js

@@ -1,92 +0,0 @@
-import getEventSource from '../../services/getEventSource';
-
-const VERSION = '1.1';
-
-const CONTROL_CHANNEL_REGEX = /^control_/;
-
-/**
- * Build metadata headers for SSE connection.
- *
- * @param {Object} settings Validated settings.
- */
-function buildSSEHeaders(settings) {
-  const headers = {
-    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
-    SplitSDKVersion: settings.version,
-  };
-
-  // ip and hostname are false if IPAddressesEnabled is false
-  const { ip, hostname } = settings.runtime;
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
-
-  return headers;
-}
-
-export default class SSEClient {
-
-  /**
-   * 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.
-   */
-  static getInstance(settings, useHeaders) {
-    const 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
-
-  constructor(EventSource, settings, useHeaders) {
-    this.EventSource = EventSource;
-    this.streamingUrl = settings.url('/sse');
-    this.useHeaders = useHeaders;
-    this.headers = buildSSEHeaders(settings);
-  }
-
-  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
-   */
-  open(authToken) {
-    this.close(); // it closes connection if previously opened
-
-    const channelsQueryParam = Object.keys(authToken.channels).map(
-      function (channel) {
-        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-        return encodeURIComponent(params + channel);
-      }
-    ).join(',');
-    const 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  */
-  close() {
-    if (this.connection) this.connection.close();
-  }
-}

package/src/sync/SSEHandler/NotificationKeeper.js

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

@@ -1,35 +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) {
-  const 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/src/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';
-const log = logFactory('splitio-sync:sse-handler');
-
-function isRetryableError(error) {
-  if (error.parsedData && error.parsedData.code) {
-    const 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) {
-
-  const notificationKeeper = notificationKeeperFactory(pushEmitter);
-
-  return {
-    handleOpen() {
-      notificationKeeper.handleOpen();
-    },
-
-    /* HTTP & Network errors */
-    handleError(error) {
-      let errorWithParsedData = error;
-      try {
-        errorWithParsedData = errorParser(error);
-      } catch (err) {
-        log.warn(`Error parsing SSE error notification: ${err}`);
-      }
-
-      let 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(message) {
-      let messageWithParsedData;
-      try {
-        messageWithParsedData = messageParser(message);
-      } catch (err) {
-        log.warn(`Error parsing new SSE message notification: ${err}`);
-        return;
-      }
-
-      const { parsedData, data, channel, timestamp } = messageWithParsedData;
-      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/src/sync/SegmentUpdateWorker/browser.js

@@ -1,67 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * MySegmentUpdateWorker class
- */
-export default class MySegmentUpdateWorker {
-
-  /**
-   *
-   * @param {Object} mySegmentsStorage
-   * @param {Object} mySegmentsProducer
-   */
-  constructor(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
-  __handleMySegmentUpdateCall() {
-    if (this.maxChangeNumber > this.currentChangeNumber) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumber = this.maxChangeNumber;
-
-      // fetch mySegments revalidating data if cached
-      this.mySegmentsProducer.synchronizeMySegments(this.segmentsData, true).then((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
-   */
-  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();
-  }
-
-}

package/src/sync/SegmentUpdateWorker/node.js

@@ -1,73 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * SegmentUpdateWorker class
- */
-export default class SegmentUpdateWorker {
-
-  /**
-   * @param {Object} segmentsStorage
-   * @param {Object} segmentsProducer
-   */
-  constructor(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
-  __handleSegmentUpdateCall() {
-    const segmentsToFetch = Object.keys(this.maxChangeNumbers).filter((segmentName) => {
-      return this.maxChangeNumbers[segmentName] > this.segmentsStorage.getChangeNumber(segmentName);
-    });
-    if (segmentsToFetch.length > 0) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumbers = segmentsToFetch.map(segmentToFetch => this.maxChangeNumbers[segmentToFetch]);
-
-      // fetch segments revalidating data if cached
-      this.segmentsProducer.synchronizeSegment(segmentsToFetch, true).then((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((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
-   */
-  put(changeNumber, segmentName) {
-    const 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();
-  }
-
-}

package/src/sync/SegmentUpdateWorker/package.json

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

package/src/sync/SplitUpdateWorker/index.js

@@ -1,79 +0,0 @@
-import Backoff from '../../utils/backoff';
-
-/**
- * SplitUpdateWorker class
- */
-export default class SplitUpdateWorker {
-
-  /**
-   * @param {Object} splitStorage splits cache
-   * @param {Object} splitProducer node producer or full browser producer
-   * @param {Object} splitsEventEmitter
-   */
-  constructor(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
-  __handleSplitUpdateCall() {
-    if (this.maxChangeNumber > this.splitStorage.getChangeNumber()) {
-      this.handleNewEvent = false;
-
-      // fetch splits revalidating data if cached
-      this.splitProducer.synchronizeSplits(true).then(() => {
-        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
-   */
-  put(changeNumber) {
-    const 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
-   */
-  killSplit(changeNumber, splitName, defaultTreatment) {
-    // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
-    this.splitStorage.killLocally(splitName, defaultTreatment, changeNumber).then((updated) => {
-      // trigger an SDK_UPDATE if Split was killed locally
-      if (updated) this.splitsEventEmitter.emit(this.splitsEventEmitter.SDK_SPLITS_ARRIVED, true);
-      // queues the SplitChanges fetch (only if changeNumber is newer)
-      this.put(changeNumber);
-    });
-  }
-
-}

package/src/sync/browser.js

@@ -1,130 +0,0 @@
-import PushManagerFactory from './PushManager';
-import FullProducerFactory from '../producer';
-import PartialProducerFactory from '../producer/browser/Partial';
-import { matching } from '../utils/key/factory';
-import { forOwn, toString } from '../utils/lang';
-import logFactory from '../utils/logger';
-import { PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP } from './constants';
-const log = logFactory('splitio-sync:sync-manager');
-
-/**
- * Factory of sync manager for browser
- *
- * @param context main client context
- */
-export default function BrowserSyncManagerFactory(mainContext) {
-
-  // map of user keys to client contexts
-  const contexts = {};
-  const 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.
-  const syncManager = createInstance(false, mainContext);
-  const pushManager = settings.streamingEnabled ? PushManagerFactory(mainContext, contexts) : undefined;
-  const mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-
-  function startPolling() {
-    if (!mainProducer.isRunning()) {
-      log.info('Streaming not available. Starting periodic fetch of data.');
-      forOwn(contexts, function (context) {
-        const 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
-      forOwn(contexts, function (context) {
-        const producer = context.get(context.constants.PRODUCER);
-        producer.stop();
-      });
-    }
-    syncAll();
-  }
-
-  function syncAll() {
-    // fetch splits and segments
-    const mainProducer = mainContext.get(mainContext.constants.PRODUCER);
-    mainProducer.synchronizeSplits();
-    forOwn(contexts, function (context) {
-      const 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) {
-    const producer = isSharedClient ? PartialProducerFactory(context) : FullProducerFactory(context);
-    const 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
-    const userKey = toString(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() {
-        // start syncing
-        if (pushManager) {
-          if (!isSharedClient) {
-            syncAll(); // initial syncAll (only when main client is created)
-            pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-            pushManager.on(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() {
-        const 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;
-}