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

package/es/producer/updater/SegmentChanges.js

@@ -0,0 +1,135 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-producer:segment-changes');
+var inputValidationLog = logFactory('', {
+  displayAllErrors: true
+});
+import segmentChangesFetcher from '../fetcher/SegmentChanges';
+import { findIndex } from '../../utils/lang';
+import { SplitError } from '../../utils/lang/Errors';
+import thenable from '../../utils/promise/thenable';
+export default function SegmentChangesUpdaterFactory(context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var segmentsEventEmitter = readiness.segments;
+  var segmentsStorage = storage.segments;
+  var readyOnAlreadyExistentState = true;
+  /**
+   * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
+   * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
+   *
+   * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+   * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+   * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+   */
+
+  return function SegmentChangesUpdater(segmentNames, noCache, fetchOnlyNew) {
+    log.debug('Started segments update'); // Async fetchers are collected here.
+
+    var updaters = [];
+
+    function segmentsUpdater(segments) {
+      var sincePromises = [];
+
+      var _loop = function _loop(index) {
+        var segmentName = segments[index];
+
+        var segmentUpdater = function segmentUpdater(since) {
+          log.debug("Processing segment " + segmentName);
+          updaters.push(segmentChangesFetcher(settings, segmentName, since, metricCollectors, noCache).then(function (changes) {
+            var changeNumber = -1;
+            var changePromises = [];
+            changes.forEach(function (x) {
+              var promises = [];
+
+              if (x.added.length > 0) {
+                var result = segmentsStorage.addToSegment(segmentName, x.added);
+                if (thenable(result)) promises.push(result);
+              }
+
+              if (x.removed.length > 0) {
+                var _result = segmentsStorage.removeFromSegment(segmentName, x.removed);
+
+                if (thenable(_result)) promises.push(_result);
+              }
+
+              if (x.added.length > 0 || x.removed.length > 0) {
+                var _result2 = segmentsStorage.setChangeNumber(segmentName, x.till);
+
+                if (thenable(_result2)) promises.push(_result2);
+                changeNumber = x.till;
+              }
+
+              log.debug("Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+              if (promises.length > 0) changePromises.push.apply(changePromises, promises);
+            });
+            return Promise.all(changePromises).then(function () {
+              return changeNumber;
+            });
+          }));
+        };
+
+        var since = segmentsStorage.getChangeNumber(segmentName);
+        var sincePromise = thenable(since) ? since.then(segmentUpdater) : segmentUpdater(since);
+        sincePromises.push(sincePromise);
+      };
+
+      for (var index = 0; index < segments.length; index++) {
+        _loop(index);
+      }
+
+      return Promise.all(sincePromises).then(function () {
+        return Promise.all(updaters).then(function (shouldUpdateFlags) {
+          // if at least one segment fetch successes, mark segments ready
+          if (findIndex(shouldUpdateFlags, function (v) {
+            return v !== -1;
+          }) !== -1 || readyOnAlreadyExistentState) {
+            readyOnAlreadyExistentState = false;
+            segmentsEventEmitter.emit(segmentsEventEmitter.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;
+        }).catch(function (error) {
+          // handle user callback errors
+          if (!(error instanceof SplitError)) setTimeout(function () {
+            throw error;
+          }, 0);
+
+          if (error.statusCode === 403) {
+            context.put(context.constants.DESTROYED, true);
+            inputValidationLog.error('Factory instantiation: you passed a Browser type authorizationKey, please grab an Api Key from the Split web console that is of type SDK.');
+          }
+
+          return false;
+        });
+      });
+    } // If not a segment name provided, read list of available segments names to be updated.
+
+
+    var segments = segmentNames ? segmentNames : segmentsStorage.getRegisteredSegments();
+    if (fetchOnlyNew) segments = segments.filter(function (segmentName) {
+      return segmentsStorage.getChangeNumber(segmentName) === -1;
+    });
+    return thenable(segments) ? segments.then(segmentsUpdater) : segmentsUpdater(segments);
+  };
+}

package/es/producer/updater/SplitChanges.js

@@ -0,0 +1,131 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-producer:split-changes');
+import splitChangesFetcher from '../fetcher/SplitChanges';
+import parseSegments from '../../engine/parser/segments';
+import { SplitError } from '../../utils/lang/Errors';
+import { _Set, setToArray } from '../../utils/lang/Sets';
+import thenable from '../../utils/promise/thenable'; // For server-side segments storage, returns true if all registered segments have been fetched (changeNumber !== -1)
+
+function checkAllSegmentsExist(segmentsStorage) {
+  return segmentsStorage.getRegisteredSegments().every(function (segmentName) {
+    return segmentsStorage.getChangeNumber(segmentName) !== -1;
+  });
+}
+
+function computeSplitsMutation(entries) {
+  var computed = entries.reduce(function (accum, split) {
+    if (split.status === 'ACTIVE') {
+      accum.added.push([split.name, JSON.stringify(split)]);
+      parseSegments(split.conditions).forEach(function (segmentName) {
+        accum.segments.add(segmentName);
+      });
+    } else {
+      accum.removed.push(split.name);
+    }
+
+    return accum;
+  }, {
+    added: [],
+    removed: [],
+    segments: new _Set()
+  });
+  computed.segments = setToArray(computed.segments);
+  return computed;
+}
+
+export default function SplitChangesUpdaterFactory(context, isNode) {
+  if (isNode === void 0) {
+    isNode = false;
+  }
+
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var splitsEventEmitter = readiness.splits;
+  var startingUp = true;
+  var readyOnAlreadyExistentState = true;
+  /**
+   * Split updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  return function SplitChangesUpdater(retry, noCache) {
+    if (retry === void 0) {
+      retry = 0;
+    }
+
+    function splitChanges(since) {
+      log.debug("Spin up split update using since = " + since);
+      var fetcherPromise = splitChangesFetcher(settings, since, startingUp, metricCollectors, isNode, noCache).then(function (splitChanges) {
+        startingUp = false;
+        var mutation = computeSplitsMutation(splitChanges.splits);
+        log.debug("New splits " + mutation.added.length);
+        log.debug("Removed splits " + mutation.removed.length);
+        log.debug("Segment names collected " + mutation.segments); // Write into storage
+        // @TODO if allowing custom storages, wrap errors as SplitErrors to distinguish from user callback errors
+
+        return Promise.all([// calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
+        storage.splits.setChangeNumber(splitChanges.till), storage.splits.addSplits(mutation.added), storage.splits.removeSplits(mutation.removed), storage.segments.registerSegments(mutation.segments)]).then(function () {
+          // On server-side SDK, we must check that all registered segments have been fetched
+          if (readyOnAlreadyExistentState || since !== splitChanges.till && (!isNode || checkAllSegmentsExist(storage.segments))) {
+            readyOnAlreadyExistentState = false;
+            splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_ARRIVED);
+          }
+        });
+      }).catch(function (error) {
+        // handle user callback errors
+        if (!(error instanceof SplitError)) {
+          setTimeout(function () {
+            throw error;
+          }, 0);
+          startingUp = false; // Stop retrying.
+        }
+
+        log.warn("Error while doing fetch of Splits. " + error);
+
+        if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+          retry += 1;
+          log.info("Retrying download of splits #" + retry + ". Reason: " + error);
+          return SplitChangesUpdater(retry, noCache);
+        } else {
+          startingUp = false;
+        }
+
+        return false;
+      }); // After triggering the requests, if we have cached splits information let's notify that.
+      // There is no need to emit the event asynchronously to let attach a listener for SDK_READY_FROM_CACHE,
+      // because the current event-loop callback executes after SplitFactory is created.
+
+      if (startingUp && storage.splits.checkCache()) {
+        splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_CACHE_LOADED);
+      }
+
+      return fetcherPromise;
+    } // @TODO check why e2e tests take so much time when sync storage result is not handled in a promise
+
+
+    var since = storage.splits.getChangeNumber();
+    var sincePromise = thenable(since) ? since : Promise.resolve(since);
+    return sincePromise.then(splitChanges);
+  };
+}

package/es/producer/updater/SplitChangesFromFeatures.js

@@ -0,0 +1,21 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import FromSettingsFetcher from '../../services/splitChanges/offline';
+import SplitChangesFromObject from './SplitChangesFromObject';
+export default function createSplitChangesFromObject(context) {
+  var fetcher = FromSettingsFetcher();
+  return SplitChangesFromObject(fetcher, context);
+}

package/es/producer/updater/SplitChangesFromFileSystem.js

@@ -0,0 +1,21 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import FromFileSystemFetcher from '../../services/splitChanges/offline';
+import SplitChangesFromObject from './SplitChangesFromObject';
+export default function createSplitChangesFromObject(context) {
+  var fetcher = FromFileSystemFetcher();
+  return SplitChangesFromObject(fetcher, context);
+}

package/es/producer/updater/SplitChangesFromObject.js

@@ -0,0 +1,73 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { forOwn } from '../../utils/lang';
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-producer:offline');
+
+function FromObjectUpdaterFactory(Fetcher, context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE];
+
+  var startingUp = true;
+  return function ObjectUpdater() {
+    var splits = [];
+    var loadError = null;
+    var splitsMock = {};
+
+    try {
+      splitsMock = Fetcher(settings);
+    } catch (err) {
+      loadError = err;
+      log.error("There was an issue loading the mock Splits data, no changes will be applied to the current cache. " + err);
+    }
+
+    if (!loadError && splitsMock) {
+      log.debug('Splits data: ');
+      log.debug(JSON.stringify(splitsMock));
+      forOwn(splitsMock, function (val, name) {
+        splits.push([name, JSON.stringify({
+          name: name,
+          status: 'ACTIVE',
+          killed: false,
+          trafficAllocation: 100,
+          defaultTreatment: 'control',
+          conditions: val.conditions || [],
+          configurations: val.configurations,
+          trafficTypeName: val.trafficTypeName
+        })]);
+      });
+      return Promise.all([storage.splits.flush(), // required to sync removed splits from mock
+      storage.splits.addSplits(splits)]).then(function () {
+        readiness.splits.emit(readiness.splits.SDK_SPLITS_ARRIVED);
+
+        if (startingUp) {
+          startingUp = false; // Emits SDK_READY_FROM_CACHE
+
+          if (settings.storage.__originalType === STORAGE_LOCALSTORAGE) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED); // Only emits SDK_SEGMENTS_ARRIVED the first time for SDK_READY
+
+          readiness.segments.emit(readiness.segments.SDK_SEGMENTS_ARRIVED);
+        }
+      });
+    } else {
+      return Promise.resolve();
+    }
+  };
+}
+
+export default FromObjectUpdaterFactory;

package/es/readiness/index.js

@@ -0,0 +1,123 @@
+import EventEmitter from 'events';
+var SPLITS_READY = 2;
+var SEGMENTS_READY = 4;
+var SDK_FIRE_READY = SPLITS_READY | SEGMENTS_READY; // 2 + 4 = 6
+
+var SDK_NOTIFY_UPDATE_SINCE_NOW = 8;
+var SDK_FIRE_UPDATE = SDK_FIRE_READY | SDK_NOTIFY_UPDATE_SINCE_NOW; // 6 + 8 = 14
+
+var Events = {
+  SDK_READY_TIMED_OUT: 'init::timeout',
+  SDK_READY: 'init::ready',
+  SDK_READY_FROM_CACHE: 'init::cache-ready',
+  SDK_SPLITS_ARRIVED: 'state::splits-arrived',
+  SDK_SEGMENTS_ARRIVED: 'state::segments-arrived',
+  SDK_SPLITS_CACHE_LOADED: 'state::splits-cache-loaded',
+  SDK_UPDATE: 'state::update',
+  READINESS_GATE_CHECK_STATE: 'state::check'
+};
+/**
+ * Machine state to handle the ready / update event propagation.
+ */
+
+function GateContext() {
+  // Splits are shared through all instances of the same SDK.
+  var splitsStatus = 0;
+  var splits = new EventEmitter();
+  splits.SDK_SPLITS_CACHE_LOADED = Events.SDK_SPLITS_CACHE_LOADED;
+  splits.SDK_SPLITS_ARRIVED = Events.SDK_SPLITS_ARRIVED; // references counter: how many
+
+  var refCount = 0;
+
+  function ReadinessGateFactory(splits, segments) {
+    var gate = new EventEmitter();
+    var segmentsStatus = 0;
+    var status = 0;
+    gate.on(Events.READINESS_GATE_CHECK_STATE, function () {
+      // @TODO catch and handle user callback errors. Required for localhost and consumer modes. In standalone mode, it is done in 'SplitChangesUpdater'.
+      if (status !== SDK_FIRE_UPDATE && splitsStatus + segmentsStatus === SDK_FIRE_READY) {
+        status = SDK_FIRE_UPDATE;
+        gate.emit(Events.SDK_READY);
+      } else if (status === SDK_FIRE_UPDATE) {
+        gate.emit(Events.SDK_UPDATE);
+      }
+    });
+    splits.on(Events.SDK_SPLITS_ARRIVED, function (isSplitKill) {
+      // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
+      // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+      // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
+      if (!isSplitKill) splitsStatus = SPLITS_READY;
+      gate.emit(Events.READINESS_GATE_CHECK_STATE);
+    });
+    splits.once(Events.SDK_SPLITS_CACHE_LOADED, function () {
+      try {
+        gate.emit(Events.SDK_READY_FROM_CACHE);
+      } catch (e) {
+        // handle user callback errors
+        setTimeout(function () {
+          throw e;
+        }, 0);
+      }
+    });
+    segments.on(Events.SDK_SEGMENTS_ARRIVED, function () {
+      segmentsStatus = SEGMENTS_READY;
+      gate.emit(Events.READINESS_GATE_CHECK_STATE);
+    });
+    return gate;
+  }
+  /**
+   * SDK Readiness Gate Factory
+   *
+   * The ready state in the browser relay on sharing the splits ready flag across
+   * all the gates, and have an extra flag for the segments which is per gate
+   * instance.
+   */
+
+
+  function SDKReadinessGateFactory(timeout) {
+    if (timeout === void 0) {
+      timeout = 0;
+    }
+
+    var readinessTimeoutId = 0;
+    var segments = new EventEmitter();
+    segments.SDK_SEGMENTS_ARRIVED = Events.SDK_SEGMENTS_ARRIVED;
+    var gate = ReadinessGateFactory(splits, segments);
+
+    if (timeout > 0) {
+      // Add the timeout.
+      readinessTimeoutId = setTimeout(function () {
+        gate.emit(Events.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
+      }, timeout); // Clear it if the SDK get's ready.
+
+      gate.once(Events.SDK_READY, function () {
+        return clearTimeout(readinessTimeoutId);
+      });
+    }
+
+    gate.SDK_READY = Events.SDK_READY;
+    gate.SDK_READY_FROM_CACHE = Events.SDK_READY_FROM_CACHE;
+    gate.SDK_UPDATE = Events.SDK_UPDATE;
+    gate.SDK_READY_TIMED_OUT = Events.SDK_READY_TIMED_OUT; // New Gate has been created, so increase the counter
+
+    refCount++;
+    return {
+      // Emitters
+      splits: splits,
+      segments: segments,
+      gate: gate,
+      // Cleanup listeners
+      destroy: function destroy() {
+        segments.removeAllListeners();
+        gate.removeAllListeners();
+        clearTimeout(readinessTimeoutId);
+        if (refCount > 0) refCount--;
+        if (refCount === 0) splits.removeAllListeners();
+      }
+    };
+  }
+
+  return SDKReadinessGateFactory;
+}
+
+export default GateContext;

package/es/readiness/statusManager.js

@@ -0,0 +1,114 @@
+import objectAssign from 'object-assign';
+import promiseWrapper from '../utils/promise/wrapper';
+import logFactory from '../utils/logger';
+var log = logFactory('');
+var NEW_LISTENER_EVENT = 'newListener';
+var REMOVE_LISTENER_EVENT = 'removeListener'; // default onRejected handler, that just logs the error, if ready promise doesn't have one.
+
+function defaultOnRejected(err) {
+  log.error(err);
+}
+/**
+ * StatusManager factory.
+ * Responsable of exposing public status API: ready promise, event emitter and constants (SDK_READY, etc).
+ * It also updates client context according to status events and logs related warnings and errors.
+ *
+ * @param {Object} context client context
+ * @param {number} internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
+ * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+ */
+
+
+export default function callbackHandlerContext(context, internalReadyCbCount) {
+  if (internalReadyCbCount === void 0) {
+    internalReadyCbCount = 0;
+  }
+
+  var gate = context.get(context.constants.READINESS).gate;
+  var readyCbCount = 0;
+  var isReady = false;
+  var hasTimedout = false;
+  var SDK_READY = gate.SDK_READY,
+      SDK_READY_FROM_CACHE = gate.SDK_READY_FROM_CACHE,
+      SDK_UPDATE = gate.SDK_UPDATE,
+      SDK_READY_TIMED_OUT = gate.SDK_READY_TIMED_OUT;
+  gate.on(REMOVE_LISTENER_EVENT, function (event) {
+    if (event === SDK_READY) readyCbCount--;
+  });
+  gate.on(NEW_LISTENER_EVENT, function (event) {
+    if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
+      if (isReady) {
+        log.error("A listener was added for " + (event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT') + " on the SDK, which has already fired and won't be emitted again. The callback won't be executed.");
+      } else if (event === SDK_READY) {
+        readyCbCount++;
+      }
+    }
+  });
+  var readyPromise = generateReadyPromise();
+  gate.once(SDK_READY_FROM_CACHE, function () {
+    log.info('Split SDK is ready from cache.');
+    context.put(context.constants.READY_FROM_CACHE, true);
+  });
+
+  function generateReadyPromise() {
+    var promise = promiseWrapper(new Promise(function (resolve, reject) {
+      gate.once(SDK_READY, function () {
+        log.info('Split SDK is ready.');
+        if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn('No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.');
+        context.put(context.constants.READY, true);
+        isReady = true;
+        resolve();
+      });
+      gate.once(SDK_READY_TIMED_OUT, function (error) {
+        context.put(context.constants.HAS_TIMEDOUT, true);
+        hasTimedout = true;
+        reject(error);
+      });
+    }), defaultOnRejected);
+    return promise;
+  }
+
+  return objectAssign( // Expose Event Emitter functionality
+  Object.create(gate), {
+    // Expose the event constants without changing the interface
+    Event: {
+      SDK_READY: SDK_READY,
+      SDK_READY_FROM_CACHE: SDK_READY_FROM_CACHE,
+      SDK_UPDATE: SDK_UPDATE,
+      SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT
+    },
+
+    /**
+     * Returns a promise that will be resolved once the SDK has finished loading (SDK_READY event emitted) or rejected if the SDK has timedout (SDK_READY_TIMED_OUT event emitted).
+     * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, calling the `ready` method after the
+     * SDK had timed out will return a new promise that should eventually resolve if the SDK gets ready.
+     *
+     * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
+     * However, when using async/await syntax, the rejection should be explicitly propagated like in the following example:
+     * ```
+     * try {
+     *   await client.ready().catch((e) => { throw e; });
+     *   // SDK is ready
+     * } catch(e) {
+     *   // SDK has timedout
+     * }
+     * ```
+     *
+     * @function ready
+     * @returns {Promise<void>}
+     */
+    ready: function ready() {
+      if (hasTimedout) {
+        if (!isReady) {
+          return promiseWrapper(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+        } else {
+          return Promise.resolve();
+        }
+      }
+
+      return readyPromise;
+    },
+    // Expose context for internal purposes only. Not considered part of the public API, and will be removed eventually.
+    __context: context
+  });
+}

package/es/services/auth/auth.js

@@ -0,0 +1,25 @@
+import base from '../request';
+
+function userKeyToQueryParam(userKey) {
+  // no need to check availability of `encodeURIComponent`, since it is a function highly supported in browsers, node and other platforms.
+  return 'users=' + encodeURIComponent(userKey);
+}
+/**
+ *
+ * @param {Object} settings Split factory config.
+ * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for Node.
+ */
+
+
+export default function GET(settings, userKeys) {
+  var relativeUrl = '/v2/auth';
+
+  if (userKeys) {
+    // accounting the possibility that `userKeys` is undefined (in node)
+    var queryParams = userKeys.map(userKeyToQueryParam).join('&');
+    if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
+      relativeUrl += '?' + queryParams;
+  }
+
+  return base(settings, relativeUrl);
+}

package/es/services/auth/index.js

@@ -0,0 +1,2 @@
+import transport from '../transport';
+export default transport;

package/es/services/events/bulk.js

@@ -0,0 +1,22 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import objectAssign from 'object-assign';
+import base from '../request';
+export default function BULK(settings, params) {
+  return base(settings, '/events/bulk', objectAssign({
+    method: 'POST'
+  }, params));
+}