@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/producer/node.js

@@ -0,0 +1,142 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _repeat = _interopRequireDefault(require("../utils/fn/repeat"));
+
+var _SplitChanges = _interopRequireDefault(require("./updater/SplitChanges"));
+
+var _SegmentChanges = _interopRequireDefault(require("./updater/SegmentChanges"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-producer:updater');
+
+/**
+ * Expose start / stop mechanism for pulling data from services.
+ */
+var NodeUpdater = function NodeUpdater(context) {
+  var splitsUpdater = (0, _SplitChanges.default)(context, true
+  /* tell split updater we are in node */
+  );
+  var segmentsUpdater = (0, _SegmentChanges.default)(context);
+  var settings = context.get(context.constants.SETTINGS);
+  var stopSplitsUpdate = false;
+  var stopSegmentsUpdate = false;
+  var splitFetchCompleted = false;
+  var _isRunning = false;
+  var _isSynchronizingSplits = false;
+  var _isSynchronizingSegments = false;
+  /**
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  function synchronizeSplits(noCache) {
+    _isSynchronizingSplits = true; // `splitsUpdater` promise always resolves, and with a false value if it fails to fetch or store splits
+
+    return splitsUpdater(0, noCache).then(function (res) {
+      // Mark splits as ready (track first successfull call to start downloading segments)
+      splitFetchCompleted = true;
+      _isSynchronizingSplits = false;
+      return res;
+    });
+  }
+  /**
+   * @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.
+   */
+
+
+  function synchronizeSegment(segmentNames, noCache, fetchOnlyNew) {
+    _isSynchronizingSegments = true; // `segmentsUpdater` promise always resolves, and with a false value if it fails to fetch or store some segment
+
+    return segmentsUpdater(segmentNames, noCache, fetchOnlyNew).then(function (res) {
+      _isSynchronizingSegments = false;
+      return res;
+    });
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start: function start() {
+      log.info('Starting NODEJS updater');
+      log.debug("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis");
+      log.debug("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"); // Schedule incremental update of segments only if needed
+
+      var spinUpSegmentUpdater = function spinUpSegmentUpdater() {
+        // We must check that Split polling is running (i.e. `stopSplitsUpdate !== false`),
+        // in case that `spinUpSegmentUpdater` is called once the client has been destroyed.
+        if (stopSplitsUpdate && !stopSegmentsUpdate) {
+          stopSegmentsUpdate = (0, _repeat.default)(function (scheduleSegmentsUpdate) {
+            if (splitFetchCompleted) {
+              log.debug('Fetching segments');
+              synchronizeSegment().then(function () {
+                return scheduleSegmentsUpdate();
+              });
+            } else {
+              scheduleSegmentsUpdate();
+            }
+          }, settings.scheduler.segmentsRefreshRate);
+        }
+      };
+
+      stopSplitsUpdate = (0, _repeat.default)(function (scheduleSplitsUpdate) {
+        log.debug('Fetching splits');
+        synchronizeSplits().then(function () {
+          // Spin up the segments update if needed
+          spinUpSegmentUpdater(); // Re-schedule update
+
+          scheduleSplitsUpdate();
+        });
+      }, settings.scheduler.featuresRefreshRate);
+      _isRunning = true;
+    },
+    // Stop periodic fetching (polling)
+    stop: function stop() {
+      log.info('Stopping NODEJS updater');
+      stopSplitsUpdate && stopSplitsUpdate();
+      stopSplitsUpdate = false; // Mark polling stopped, to be able to call `start` again and to avoid polling segments if `spinUpSegmentUpdater` is called after the client has been destroyed.
+
+      stopSegmentsUpdate && stopSegmentsUpdate();
+      stopSegmentsUpdate = false;
+      _isRunning = false;
+    },
+    // Used by SyncManager to know if running in polling mode.
+    isRunning: function isRunning() {
+      return _isRunning;
+    },
+    // Used by SplitUpdateWorker
+    isSynchronizingSplits: function isSynchronizingSplits() {
+      return _isSynchronizingSplits;
+    },
+    synchronizeSplits: synchronizeSplits,
+    // Used by SegmentUpdateWorker
+    isSynchronizingSegments: function isSynchronizingSegments() {
+      return _isSynchronizingSegments;
+    },
+    synchronizeSegment: synchronizeSegment
+  };
+};
+
+var _default = NodeUpdater;
+exports.default = _default;

package/lib/producer/offline/browser.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _task = _interopRequireDefault(require("../task"));
+
+var _SplitChangesFromFeatures = _interopRequireDefault(require("../updater/SplitChangesFromFeatures"));
+
+/**
+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.
+**/
+var OfflineFeatureProducer = function OfflineFeatureProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var updater = (0, _SplitChangesFromFeatures.default)(context);
+  var updaterTask = (0, _task.default)(updater, settings.scheduler.offlineRefreshRate);
+  return updaterTask;
+};
+
+var _default = OfflineFeatureProducer;
+exports.default = _default;

package/lib/producer/offline/node.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _task = _interopRequireDefault(require("../task"));
+
+var _SplitChangesFromFileSystem = _interopRequireDefault(require("../updater/SplitChangesFromFileSystem"));
+
+/**
+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.
+**/
+var OfflineFileSystemProducer = function OfflineFileSystemProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var updater = (0, _SplitChangesFromFileSystem.default)(context);
+  var updaterTask = (0, _task.default)(updater, settings.scheduler.offlineRefreshRate);
+  return updaterTask;
+};
+
+var _default = OfflineFileSystemProducer;
+exports.default = _default;

package/lib/producer/offline/package.json

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

package/lib/producer/package.json

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

package/lib/producer/task.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _repeat = _interopRequireDefault(require("../utils/fn/repeat"));
+
+var _lang = require("../utils/lang");
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-producer:task');
+
+/**
+ * Startable task factory.
+ */
+var TaskFactory = function TaskFactory(updater, period) {
+  var updaterName = (0, _lang.getFnName)(updater);
+  var stopUpdater = false;
+  return {
+    start: function start() {
+      if (!stopUpdater) {
+        log.debug("Starting " + updaterName + " refreshing each " + period);
+        stopUpdater = (0, _repeat.default)(function (reschedule) {
+          log.debug("Running " + updaterName);
+          updater().then(function () {
+            return reschedule();
+          });
+        }, period);
+      }
+    },
+    stop: function stop() {
+      log.debug("Stopping " + updaterName);
+      stopUpdater && stopUpdater();
+      stopUpdater = false;
+    },
+    isRunning: function isRunning() {
+      return stopUpdater ? true : false;
+    }
+  };
+};
+
+var _default = TaskFactory;
+exports.default = _default;

package/lib/producer/updater/MySegments.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = MySegmentsUpdaterFactory;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _MySegments = _interopRequireDefault(require("../fetcher/MySegments"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-producer:my-segments');
+
+function MySegmentsUpdaterFactory(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 readyOnAlreadyExistentState = true;
+  var startingUp = true; // @TODO if allowing custom storages, handle async execution and wrap errors as SplitErrors to distinguish from user callback errors
+
+  function updateSegments(segmentsData) {
+    var mySegmentsCache = storage.segments;
+    var shouldNotifyUpdate;
+
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    } else {
+      // Add/Delete the segment
+      var name = segmentsData.name,
+          add = segmentsData.add;
+
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
+    } // Notify update if required
+
+
+    if (storage.splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+      readyOnAlreadyExistentState = false;
+      segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+    }
+  }
+  /**
+   * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData it can be:
+   *  (1) the list of segment names to sync in the storage,
+   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+   *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+
+  return function MySegmentsUpdater(retry, segmentsData, noCache) {
+    if (retry === void 0) {
+      retry = 0;
+    }
+
+    var updaterPromise;
+
+    if (segmentsData) {
+      // If segmentsData is provided, there is no need to fetch mySegments
+      updaterPromise = new Promise(function (res) {
+        updateSegments(segmentsData);
+        res();
+      });
+    } else {
+      // NOTE: We only collect metrics on startup.
+      updaterPromise = (0, _MySegments.default)(settings, startingUp, metricCollectors, noCache).then(function (segments) {
+        // Only when we have downloaded segments completely, we should not keep retrying anymore
+        startingUp = false;
+        updateSegments(segments);
+      });
+    }
+
+    return updaterPromise.catch(function (error) {
+      // handle user callback errors
+      if (!(error instanceof _Errors.SplitError)) setTimeout(function () {
+        throw error;
+      }, 0);
+
+      if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+        retry += 1;
+        log.warn("Retrying download of segments #" + retry + ". Reason: " + error);
+        return MySegmentsUpdater(retry);
+      } else {
+        startingUp = false;
+      }
+
+      return false; // shouldUpdate = false
+    });
+  };
+}

package/lib/producer/updater/SegmentChanges.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = SegmentChangesUpdaterFactory;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _SegmentChanges = _interopRequireDefault(require("../fetcher/SegmentChanges"));
+
+var _lang = require("../../utils/lang");
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-producer:segment-changes');
+var inputValidationLog = (0, _logger.default)('', {
+  displayAllErrors: true
+});
+
+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((0, _SegmentChanges.default)(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 ((0, _thenable.default)(result)) promises.push(result);
+              }
+
+              if (x.removed.length > 0) {
+                var _result = segmentsStorage.removeFromSegment(segmentName, x.removed);
+
+                if ((0, _thenable.default)(_result)) promises.push(_result);
+              }
+
+              if (x.added.length > 0 || x.removed.length > 0) {
+                var _result2 = segmentsStorage.setChangeNumber(segmentName, x.till);
+
+                if ((0, _thenable.default)(_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 = (0, _thenable.default)(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 ((0, _lang.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 _Errors.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 (0, _thenable.default)(segments) ? segments.then(segmentsUpdater) : segmentsUpdater(segments);
+  };
+}