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

package/es/storage/RedisAdapter.js

@@ -0,0 +1,198 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import ioredis from 'ioredis';
+import { merge, isString } from '../utils/lang';
+import { _Set, setToArray } from '../utils/lang/Sets';
+import thenable from '../utils/promise/thenable';
+import timeout from '../utils/promise/timeout';
+import LogFactory from '../utils/logger';
+var log = LogFactory('splitio-storage:redis-adapter'); // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
+
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget']; // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
+
+var DEFAULT_OPTIONS = {
+  connectionTimeout: 10000,
+  operationTimeout: 5000
+}; // Library specifics.
+
+var DEFAULT_LIBRARY_OPTIONS = {
+  enableOfflineQueue: false,
+  connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
+  lazyConnect: false
+};
+/**
+ * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ */
+
+var RedisAdapter = /*#__PURE__*/function (_ioredis) {
+  _inheritsLoose(RedisAdapter, _ioredis);
+
+  function RedisAdapter(storageSettings) {
+    var _this;
+
+    var options = RedisAdapter._defineOptions(storageSettings); // Call the ioredis constructor
+
+
+    _this = _ioredis.call.apply(_ioredis, [this].concat(RedisAdapter._defineLibrarySettings(options))) || this;
+    _this._options = options;
+    _this._notReadyCommandsQueue = [];
+    _this._runningCommands = new _Set();
+
+    _this._listenToEvents();
+
+    _this._setTimeoutWrappers();
+
+    _this._setDisconnectWrapper();
+
+    return _this;
+  }
+
+  var _proto = RedisAdapter.prototype;
+
+  _proto._listenToEvents = function _listenToEvents() {
+    var _this2 = this;
+
+    this.once('ready', function () {
+      var commandsCount = _this2._notReadyCommandsQueue ? _this2._notReadyCommandsQueue.length : 0;
+      log.info("Redis connection established. Queued commands: " + commandsCount + ".");
+      commandsCount && _this2._notReadyCommandsQueue.forEach(function (queued) {
+        log.info("Executing queued " + queued.name + " command.");
+        queued.command().then(queued.resolve).catch(queued.reject);
+      }); // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
+
+      _this2._notReadyCommandsQueue = false;
+    });
+    this.once('close', function () {
+      log.info('Redis connection closed.');
+    });
+  };
+
+  _proto._setTimeoutWrappers = function _setTimeoutWrappers() {
+    var instance = this;
+    METHODS_TO_PROMISE_WRAP.forEach(function (method) {
+      var originalMethod = instance[method];
+
+      instance[method] = function () {
+        var params = arguments;
+
+        function commandWrapper() {
+          log.debug("Executing " + method + "."); // Return original method
+
+          var result = originalMethod.apply(instance, params);
+
+          if (thenable(result)) {
+            // For handling pending commands on disconnect, add to the set and remove once finished.
+            // On sync commands there's no need, only thenables.
+            instance._runningCommands.add(result);
+
+            var cleanUpRunningCommandsCb = function cleanUpRunningCommandsCb(res) {
+              instance._runningCommands.delete(result);
+
+              return res;
+            }; // Both success and error remove from queue.
+
+
+            result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
+            return timeout(instance._options.operationTimeout, result).catch(function (err) {
+              log.error(method + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err); // Handling is not the adapter responsibility.
+
+              throw err;
+            });
+          }
+
+          return result;
+        }
+
+        if (instance._notReadyCommandsQueue) {
+          return new Promise(function (res, rej) {
+            instance._notReadyCommandsQueue.unshift({
+              resolve: res,
+              reject: rej,
+              command: commandWrapper,
+              name: method.toUpperCase()
+            });
+          });
+        } else {
+          return commandWrapper();
+        }
+      };
+    });
+  };
+
+  _proto._setDisconnectWrapper = function _setDisconnectWrapper() {
+    var instance = this;
+    var originalMethod = instance.disconnect;
+
+    instance.disconnect = function disconnect() {
+      var params = arguments;
+      setTimeout(function deferedDisconnect() {
+        if (instance._runningCommands.size > 0) {
+          log.info("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish.");
+          Promise.all(setToArray(instance._runningCommands)).then(function () {
+            log.debug('Pending commands finished successfully, disconnecting.');
+            originalMethod.apply(instance, params);
+          }).catch(function (e) {
+            log.warn("Pending commands finished with error: " + e + ". Proceeding with disconnection.");
+            originalMethod.apply(instance, params);
+          });
+        } else {
+          log.debug('No commands pending execution, disconnect.'); // Nothing pending, just proceed.
+
+          originalMethod.apply(instance, params);
+        }
+      }, 10);
+    };
+  }
+  /**
+   * Receives the options and returns an array of parameters for the ioredis constructor.
+   * Keeping both redis setup options for backwards compatibility.
+   */
+  ;
+
+  RedisAdapter._defineLibrarySettings = function _defineLibrarySettings(options) {
+    var opts = merge({}, DEFAULT_LIBRARY_OPTIONS);
+    var result = [opts];
+
+    if (!isString(options.url)) {
+      merge(opts, {
+        // If it's not the string URL, merge the params separately.
+        host: options.host,
+        port: options.port,
+        db: options.db,
+        password: options.pass
+      });
+    } else {
+      // If it IS the string URL, that'll be the first param for ioredis.
+      result.unshift(options.url);
+    }
+
+    return result;
+  }
+  /**
+   * Parses the options into what we care about.
+   */
+  ;
+
+  RedisAdapter._defineOptions = function _defineOptions(_ref) {
+    var connectionTimeout = _ref.connectionTimeout,
+        operationTimeout = _ref.operationTimeout,
+        url = _ref.url,
+        host = _ref.host,
+        port = _ref.port,
+        db = _ref.db,
+        pass = _ref.pass;
+    var parsedOptions = {
+      connectionTimeout: connectionTimeout,
+      operationTimeout: operationTimeout,
+      url: url,
+      host: host,
+      port: port,
+      db: db,
+      pass: pass
+    };
+    return merge({}, DEFAULT_OPTIONS, parsedOptions);
+  };
+
+  return RedisAdapter;
+}(ioredis);
+
+export { RedisAdapter as default };

package/es/storage/SegmentCache/InLocalStorage/index.js

@@ -0,0 +1,162 @@
+import logFactory from '../../../utils/logger';
+var log = logFactory('splitio-storage:localstorage');
+var DEFINED = '1';
+
+var SegmentCacheInLocalStorage = /*#__PURE__*/function () {
+  function SegmentCacheInLocalStorage(keys) {
+    this.keys = keys; // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
+  }
+
+  var _proto = SegmentCacheInLocalStorage.prototype;
+
+  _proto.addToSegment = function addToSegment(segmentName
+  /*, segmentKeys: Array<string>*/
+  ) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    try {
+      localStorage.setItem(segmentKey, DEFINED);
+      return true;
+    } catch (e) {
+      log.error(e);
+      return false;
+    }
+  };
+
+  _proto.removeFromSegment = function removeFromSegment(segmentName
+  /*, segmentKeys: Array<string>*/
+  ) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    try {
+      localStorage.removeItem(segmentKey);
+      return true;
+    } catch (e) {
+      log.error(e);
+      return false;
+    }
+  }
+  /**
+   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+   *
+   * @param {string[]} segmentNames list of segment names
+   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+   */
+  ;
+
+  _proto.resetSegments = function resetSegments(segmentNames) {
+    var _this = this;
+
+    var isDiff = false;
+    var index; // Scan current values from localStorage
+
+    var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
+      var segmentName = _this.keys.extractSegmentName(key);
+
+      if (segmentName) {
+        accum.push(segmentName);
+      } else {
+        // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+        segmentName = _this.keys.extractOldSegmentKey(key);
+
+        if (segmentName) {
+          // this was an old segment key, let's clean up.
+          var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
+
+          try {
+            // If the new format key is not there, create it.
+            if (!localStorage.getItem(newSegmentKey) && segmentNames.indexOf(segmentName) > -1) {
+              localStorage.setItem(newSegmentKey, DEFINED); // we are migrating a segment, let's track it.
+
+              accum.push(segmentName);
+            }
+
+            localStorage.removeItem(key); // we migrated the current key, let's delete it.
+          } catch (e) {
+            log.error(e);
+          }
+        }
+      }
+
+      return accum;
+    }, []); // Extreme fast => everything is empty
+
+    if (segmentNames.length === 0 && storedSegmentNames.length === segmentNames.length) return isDiff; // Quick path
+
+    if (storedSegmentNames.length !== segmentNames.length) {
+      isDiff = true;
+      storedSegmentNames.forEach(function (segmentName) {
+        return _this.removeFromSegment(segmentName);
+      });
+      segmentNames.forEach(function (segmentName) {
+        return _this.addToSegment(segmentName);
+      });
+    } else {
+      // Slowest path => we need to find at least 1 difference because
+      for (index = 0; index < segmentNames.length && storedSegmentNames.indexOf(segmentNames[index]) !== -1; index++) {// TODO: why empty statement?
+      }
+
+      if (index < segmentNames.length) {
+        isDiff = true;
+        storedSegmentNames.forEach(function (segmentName) {
+          return _this.removeFromSegment(segmentName);
+        });
+        segmentNames.forEach(function (segmentName) {
+          return _this.addToSegment(segmentName);
+        });
+      }
+    }
+
+    return isDiff;
+  };
+
+  _proto.isInSegment = function isInSegment(segmentName
+  /*, key: string*/
+  ) {
+    return localStorage.getItem(this.keys.buildSegmentNameKey(segmentName)) === DEFINED;
+  };
+
+  _proto.setChangeNumber = function setChangeNumber()
+  /*segmentName: string, changeNumber: number*/
+  {
+    return true;
+  };
+
+  _proto.getChangeNumber = function getChangeNumber()
+  /*segmentName: string*/
+  {
+    return -1;
+  };
+
+  _proto.registerSegment = function registerSegment()
+  /*segment: string*/
+  {
+    return false;
+  };
+
+  _proto.registerSegments = function registerSegments()
+  /*segments: Iterable<string>*/
+  {
+    return false;
+  };
+
+  _proto.getRegisteredSegments = function getRegisteredSegments() {
+    return [];
+  }
+  /**
+   * Removes list of segments from localStorage
+   * @NOTE this method is not being used at the moment
+   */
+  ;
+
+  _proto.flush = function flush() {
+    log.info('Flushing MySegments data from localStorage'); // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+    // We could optimize next sentence, since it implies iterating over all localStorage items
+
+    this.resetSegments([]);
+  };
+
+  return SegmentCacheInLocalStorage;
+}();
+
+export default SegmentCacheInLocalStorage;

package/es/storage/SegmentCache/InMemory/browser.js

@@ -0,0 +1,107 @@
+var SegmentCacheInMemory = /*#__PURE__*/function () {
+  function SegmentCacheInMemory(keys) {
+    this.keys = keys;
+    this.flush();
+  }
+
+  var _proto = SegmentCacheInMemory.prototype;
+
+  _proto.flush = function flush() {
+    this.segmentCache = {};
+  };
+
+  _proto.addToSegment = function addToSegment(segmentName
+  /*, segmentKeys: Array<string>*/
+  ) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+    this.segmentCache[segmentKey] = true;
+    return true;
+  };
+
+  _proto.removeFromSegment = function removeFromSegment(segmentName
+  /*, segmentKeys: Array<string>*/
+  ) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+    delete this.segmentCache[segmentKey];
+    return true;
+  }
+  /**
+   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+   * @NOTE based on the way we use segments in the browser, this way is the best option
+   *
+   * @param {string[]} segmentNames list of segment names
+   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+   */
+  ;
+
+  _proto.resetSegments = function resetSegments(segmentNames) {
+    var _this = this;
+
+    var isDiff = false;
+    var index;
+    var storedSegmentKeys = Object.keys(this.segmentCache); // Extreme fast => everything is empty
+
+    if (segmentNames.length === 0 && storedSegmentKeys.length === segmentNames.length) return isDiff; // Quick path
+
+    if (storedSegmentKeys.length !== segmentNames.length) {
+      isDiff = true;
+      this.segmentCache = {};
+      segmentNames.forEach(function (s) {
+        _this.addToSegment(s);
+      });
+    } else {
+      // Slowest path => we need to find at least 1 difference because
+      for (index = 0; index < segmentNames.length && this.isInSegment(segmentNames[index]); index++) {// TODO: why empty statement?
+      }
+
+      if (index < segmentNames.length) {
+        isDiff = true;
+        this.segmentCache = {};
+        segmentNames.forEach(function (s) {
+          _this.addToSegment(s);
+        });
+      }
+    }
+
+    return isDiff;
+  };
+
+  _proto.isInSegment = function isInSegment(segmentName
+  /*, key: string*/
+  ) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+    return this.segmentCache[segmentKey] === true;
+  };
+
+  _proto.setChangeNumber = function setChangeNumber()
+  /*segmentName: string, changeNumber: number*/
+  {
+    return true;
+  };
+
+  _proto.getChangeNumber = function getChangeNumber()
+  /*segmentName: string*/
+  {
+    return -1;
+  };
+
+  _proto.registerSegment = function registerSegment()
+  /*segment: string*/
+  {
+    return false;
+  };
+
+  _proto.registerSegments = function registerSegments()
+  /*segments: Iterable<string>*/
+  {
+    return false;
+  };
+
+  _proto.getRegisteredSegments = function getRegisteredSegments() {
+    return [];
+  };
+
+  return SegmentCacheInMemory;
+}();
+
+export default SegmentCacheInMemory;

package/es/storage/SegmentCache/InMemory/node.js

@@ -0,0 +1,82 @@
+import { numberIsInteger } from '../../../utils/lang';
+import { _Set } from '../../../utils/lang/Sets';
+
+var SegmentCacheInMemory = /*#__PURE__*/function () {
+  function SegmentCacheInMemory(keys) {
+    this.keys = keys;
+    this.flush();
+  }
+
+  var _proto = SegmentCacheInMemory.prototype;
+
+  _proto.addToSegment = function addToSegment(segmentName, segmentKeys) {
+    var values = this.segmentCache[segmentName];
+    var keySet = values ? values : new _Set();
+    segmentKeys.forEach(function (k) {
+      return keySet.add(k);
+    });
+    this.segmentCache[segmentName] = keySet;
+    return true;
+  };
+
+  _proto.removeFromSegment = function removeFromSegment(segmentName, segmentKeys) {
+    var values = this.segmentCache[segmentName];
+    var keySet = values ? values : new _Set();
+    segmentKeys.forEach(function (k) {
+      return keySet.delete(k);
+    });
+    this.segmentCache[segmentName] = keySet;
+    return true;
+  };
+
+  _proto.isInSegment = function isInSegment(segmentName, key) {
+    var segmentValues = this.segmentCache[segmentName];
+
+    if (segmentValues) {
+      return segmentValues.has(key);
+    }
+
+    return false;
+  };
+
+  _proto.registerSegment = function registerSegment(segmentName) {
+    if (!this.segmentCache[segmentName]) {
+      this.segmentCache[segmentName] = new _Set();
+    }
+
+    return true;
+  };
+
+  _proto.registerSegments = function registerSegments(segments) {
+    for (var i = 0; i < segments.length; i++) {
+      this.registerSegment(segments[i]);
+    }
+
+    return true;
+  };
+
+  _proto.getRegisteredSegments = function getRegisteredSegments() {
+    return Object.keys(this.segmentCache);
+  };
+
+  _proto.setChangeNumber = function setChangeNumber(segmentName, changeNumber) {
+    var segmentChangeNumberKey = this.keys.buildSegmentTillKey(segmentName);
+    this.segmentChangeNumber[segmentChangeNumberKey] = changeNumber;
+    return true;
+  };
+
+  _proto.getChangeNumber = function getChangeNumber(segmentName) {
+    var segmentChangeNumberKey = this.keys.buildSegmentTillKey(segmentName);
+    var value = this.segmentChangeNumber[segmentChangeNumberKey];
+    return numberIsInteger(value) ? value : -1;
+  };
+
+  _proto.flush = function flush() {
+    this.segmentCache = {};
+    this.segmentChangeNumber = {};
+  };
+
+  return SegmentCacheInMemory;
+}();
+
+export default SegmentCacheInMemory;

package/es/storage/SegmentCache/InRedis/index.js

@@ -0,0 +1,81 @@
+import { numberIsNaN } from '../../../utils/lang';
+
+var SegmentCacheInRedis = /*#__PURE__*/function () {
+  function SegmentCacheInRedis(keys, redis) {
+    this.redis = redis;
+    this.keys = keys;
+  }
+
+  var _proto = SegmentCacheInRedis.prototype;
+
+  _proto.addToSegment = function addToSegment(segmentName, segmentKeys) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    if (segmentKeys.length) {
+      return this.redis.sadd(segmentKey, segmentKeys).then(function () {
+        return true;
+      });
+    } else {
+      return Promise.resolve(true);
+    }
+  };
+
+  _proto.removeFromSegment = function removeFromSegment(segmentName, segmentKeys) {
+    var segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    if (segmentKeys.length) {
+      return this.redis.srem(segmentKey, segmentKeys).then(function () {
+        return true;
+      });
+    } else {
+      return Promise.resolve(true);
+    }
+  };
+
+  _proto.isInSegment = function isInSegment(segmentName, key) {
+    return this.redis.sismember(this.keys.buildSegmentNameKey(segmentName), key).then(function (matches) {
+      return matches !== 0;
+    });
+  };
+
+  _proto.setChangeNumber = function setChangeNumber(segmentName, changeNumber) {
+    return this.redis.set(this.keys.buildSegmentTillKey(segmentName), changeNumber + '').then(function (status) {
+      return status === 'OK';
+    });
+  };
+
+  _proto.getChangeNumber = function getChangeNumber(segmentName) {
+    return this.redis.get(this.keys.buildSegmentTillKey(segmentName)).then(function (value) {
+      var i = parseInt(value, 10);
+      return numberIsNaN(i) ? -1 : i;
+    });
+  };
+
+  _proto.registerSegment = function registerSegment(segment) {
+    return this.registerSegments(segment);
+  };
+
+  _proto.registerSegments = function registerSegments(segments) {
+    if (segments.length) {
+      return this.redis.sadd(this.keys.buildRegisteredSegmentsKey(), segments).then(function () {
+        return true;
+      });
+    } else {
+      return Promise.resolve(true);
+    }
+  };
+
+  _proto.getRegisteredSegments = function getRegisteredSegments() {
+    return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
+  };
+
+  _proto.flush = function flush() {
+    return this.redis.flushdb().then(function (status) {
+      return status === 'OK';
+    });
+  };
+
+  return SegmentCacheInRedis;
+}();
+
+export default SegmentCacheInRedis;