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

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;