@splitsoftware/splitio 10.17.1-rc.0 → 10.17.3-rc.0

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

@@ -1,120 +0,0 @@
-import logFactory from '../../../utils/logger';
-const log = logFactory('splitio-storage:localstorage');
-
-const DEFINED = '1';
-
-class SegmentCacheInLocalStorage {
-
-  constructor(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
-  }
-
-  addToSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    try {
-      localStorage.setItem(segmentKey, DEFINED);
-      return true;
-    } catch (e) {
-      log.error(e);
-      return false;
-    }
-  }
-
-  removeFromSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const 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)
-   */
-  resetSegments(segmentNames) {
-    let isDiff = false;
-    let index;
-
-    // Scan current values from localStorage
-    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
-      const segmentName = this.keys.extractSegmentName(key);
-
-      if (segmentName) accum.push(segmentName);
-
-      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(segmentName => this.removeFromSegment(segmentName));
-      segmentNames.forEach(segmentName => 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(segmentName => this.removeFromSegment(segmentName));
-        segmentNames.forEach(segmentName => this.addToSegment(segmentName));
-      }
-    }
-
-    return isDiff;
-  }
-
-  isInSegment(segmentName/*, key: string*/) {
-    return localStorage.getItem(this.keys.buildSegmentNameKey(segmentName)) === DEFINED;
-  }
-
-  setChangeNumber(/*segmentName: string, changeNumber: number*/) {
-    return true;
-  }
-
-  getChangeNumber(/*segmentName: string*/) {
-    return -1;
-  }
-
-  registerSegment(/*segment: string*/) {
-    return false;
-  }
-
-  registerSegments(/*segments: Iterable<string>*/) {
-    return false;
-  }
-
-  getRegisteredSegments() {
-    return [];
-  }
-
-  /**
-   * Removes list of segments from localStorage
-   * @NOTE this method is not being used at the moment
-   */
-  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([]);
-  }
-}
-
-export default SegmentCacheInLocalStorage;

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

@@ -1,99 +0,0 @@
-class SegmentCacheInMemory {
-
-  constructor(keys) {
-    this.keys = keys;
-    this.flush();
-  }
-
-  flush() {
-    this.segmentCache = {};
-  }
-
-  addToSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    this.segmentCache[segmentKey] = true;
-
-    return true;
-  }
-
-  removeFromSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const 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)
-   */
-  resetSegments(segmentNames) {
-    let isDiff = false;
-    let index;
-
-    const 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 (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 (s => {
-          this.addToSegment(s);
-        });
-      }
-    }
-
-    return isDiff;
-  }
-
-  isInSegment(segmentName/*, key: string*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    return this.segmentCache[segmentKey] === true;
-  }
-
-  setChangeNumber(/*segmentName: string, changeNumber: number*/) {
-    return true;
-  }
-
-  getChangeNumber(/*segmentName: string*/) {
-    return -1;
-  }
-
-  registerSegment(/*segment: string*/) {
-    return false;
-  }
-
-  registerSegments(/*segments: Iterable<string>*/) {
-    return false;
-  }
-
-  getRegisteredSegments() {
-    return [];
-  }
-}
-
-export default SegmentCacheInMemory;

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

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

package/src/storage/SegmentCache/InMemory/package.json

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

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

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

package/src/storage/SplitCache/InLocalStorage.js

@@ -1,324 +0,0 @@
-import { numberIsFinite, toNumber, numberIsNaN } from '../../utils/lang';
-import usesSegments from '../../utils/splits/usesSegments';
-import logFactory from '../../utils/logger';
-const log = logFactory('splitio-storage:localstorage');
-import killLocally from './killLocally';
-
-class SplitCacheLocalStorage {
-
-  /**
-   * @param {Object} keys
-   * @param {number} expirationTimestamp
-   * @param {Object} splitFiltersValidation
-   */
-  constructor(keys, expirationTimestamp, splitFiltersValidation = { validFilters: [], queryString: null, groupedFilters: { byName: [], byPrefix: [] } }) {
-    this.keys = keys;
-    this.splitFiltersValidation = splitFiltersValidation;
-
-    this.__checkExpiration(expirationTimestamp);
-
-    this.__checkFilterQuery();
-  }
-
-  decrementCount(key) {
-    const count = toNumber(localStorage.getItem(key)) - 1;
-
-    if (count > 0) localStorage.setItem(key, count);
-    else localStorage.removeItem(key);
-  }
-
-  decrementCounts(split) {
-    try {
-      if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          this.decrementCount(ttKey);
-        }
-
-        if (usesSegments(split.conditions)) {
-          const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-          this.decrementCount(segmentsCountKey);
-        }
-      }
-    } catch (e) {
-      log.error(e);
-    }
-  }
-
-  incrementCounts(split) {
-    try {
-      if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-        }
-
-        if (usesSegments(split.conditions)) {
-          const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-          localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-        }
-      }
-    } catch (e) {
-      log.error(e);
-    }
-  }
-
-  addSplit(splitName, split) {
-    try {
-      const splitKey = this.keys.buildSplitKey(splitName);
-      const splitFromLocalStorage = localStorage.getItem(splitKey);
-      const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-      this.decrementCounts(previousSplit);
-
-      localStorage.setItem(splitKey, split);
-
-      const parsedSplit = split ? JSON.parse(split) : null;
-
-      this.incrementCounts(parsedSplit);
-
-      return true;
-    } catch (e) {
-      log.error(e);
-      return false;
-    }
-  }
-
-  addSplits(entries) {
-    let results = [];
-
-    entries.forEach(keyValuePair => {
-      results.push(this.addSplit(keyValuePair[0], keyValuePair[1]));
-    });
-
-    return results;
-  }
-
-  removeSplit(splitName) {
-    try {
-      const split = this.getSplit(splitName);
-      localStorage.removeItem(this.keys.buildSplitKey(splitName));
-
-      const parsedSplit = JSON.parse(split);
-      this.decrementCounts(parsedSplit);
-
-      return 1;
-    } catch (e) {
-      log.error(e);
-      return 0;
-    }
-  }
-
-  /**
-   * Bulk delete of splits from LocalStorage. Returns the number of deleted keys.
-   */
-  removeSplits(names) {
-    let i = 0;
-    let len = names.length;
-    let counter = 0;
-
-    for (; i < len; i++) {
-      counter += this.removeSplit(names[i]);
-    }
-
-    return counter;
-  }
-
-  getSplit(splitName) {
-    return localStorage.getItem(this.keys.buildSplitKey(splitName));
-  }
-
-  setChangeNumber(changeNumber) {
-    // when cache is ready but using a new split query, we must flush all split data
-    if (this.cacheReadyButNeedsToFlush) {
-      this.flush();
-      this.cacheReadyButNeedsToFlush = false;
-    }
-
-    // when using a new split query, we must update it at the store
-    if (this.updateNewFilter) {
-      log.info('Split filter query was modified. Updating cache.');
-      const queryKey = this.keys.buildSplitsFilterQueryKey();
-      const { queryString } = this.splitFiltersValidation;
-      try {
-        if (queryString) localStorage.setItem(queryKey, queryString);
-        else localStorage.removeItem(queryKey);
-      } catch (e) {
-        log.error(e);
-      }
-      this.updateNewFilter = false;
-    }
-
-    try {
-      localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
-      // update "last updated" timestamp with current time
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-      this.hasSync = true;
-      return true;
-    } catch (e) {
-      log.error(e);
-      return false;
-    }
-  }
-
-  getChangeNumber() {
-    const n = -1;
-    let value = localStorage.getItem(this.keys.buildSplitsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return numberIsNaN(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  getAll() {
-    const len = localStorage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = localStorage.key(cur);
-      const value = key && localStorage.getItem(key);
-
-      if (key != null && this.keys.isSplitKey(key) && value) accum.push(value);
-
-      cur++;
-    }
-
-    return accum;
-  }
-
-  getKeys() {
-    const len = localStorage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = localStorage.key(cur);
-
-      if (key != null && this.keys.isSplitKey(key)) accum.push(this.keys.extractKey(key));
-
-      cur++;
-    }
-
-    return accum;
-  }
-
-  trafficTypeExists(trafficType) {
-    const ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-    return numberIsFinite(ttCount) && ttCount > 0;
-  }
-
-  usesSegments() {
-    // If cache hasn't been synchronized with the cloud, assume we need them.
-    if (!this.hasSync) return true;
-
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    if (numberIsFinite(splitsWithSegmentsCount)) {
-      return splitsWithSegmentsCount > 0;
-    } else {
-      return true;
-    }
-  }
-
-  /**
-   * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
-   * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-   */
-  flush() {
-    log.info('Flushing Splits data from localStorage');
-
-    // collect item keys
-    const len = localStorage.length;
-    const accum = [];
-    for (let cur = 0; cur < len; cur++) {
-      const key = localStorage.key(cur);
-      if (key != null && this.keys.isSplitCacheKey(key)) accum.push(key);
-    }
-    // remove items
-    accum.forEach(key => {
-      localStorage.removeItem(key);
-    });
-
-    this.hasSync = false;
-  }
-
-  /**
-   * Fetches multiple splits definitions.
-   */
-  fetchMany(splitNames) {
-    const splits = {};
-    splitNames.forEach(splitName => {
-      splits[splitName] = localStorage.getItem(this.keys.buildSplitKey(splitName));
-    });
-    return splits;
-  }
-
-  /**
-   * Check if the splits information is already stored in cache.
-   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-   * In this function we could add more code to check if the data is valid.
-   */
-  checkCache() {
-    return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
-  }
-
-  /**
-   * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-   * Clean operation (flush) also updates `lastUpdated` timestamp with current time.
-   *
-   * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
-   */
-  __checkExpiration(expirationTimestamp) {
-    let value = localStorage.getItem(this.keys.buildLastUpdatedKey());
-    if (value !== null) {
-      value = parseInt(value, 10);
-      if (!numberIsNaN(value) && value < expirationTimestamp) this.flush();
-    }
-  }
-
-  __checkFilterQuery() {
-    const { queryString, groupedFilters } = this.splitFiltersValidation;
-    const queryKey = this.keys.buildSplitsFilterQueryKey();
-    const currentQueryString = localStorage.getItem(queryKey);
-
-    if (currentQueryString !== queryString) {
-      try {
-        // mark cache to update the new query filter on first successful splits fetch
-        this.updateNewFilter = true;
-
-        // if cache is ready:
-        if (this.checkCache()) {
-          // * set change number to -1, to fetch splits with -1 `since` value.
-          localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');
-
-          // * remove from cache splits that doesn't match with the new filters
-          this.getKeys().forEach((splitName) => {
-            if (queryString && (
-              groupedFilters.byName.indexOf(splitName) > -1 ||
-              groupedFilters.byPrefix.some(prefix => splitName.startsWith(prefix + '__'))
-            )) {
-              // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is flushed before updating on first successful splits fetch
-              this.cacheReadyButNeedsToFlush = true;
-              return;
-            }
-            this.removeSplit(splitName);
-          });
-        }
-      } catch (e) {
-        log.error(e);
-      }
-    }
-    // if the filter didn't change, nothing is done
-  }
-}
-
-SplitCacheLocalStorage.prototype.killLocally = killLocally;
-
-export default SplitCacheLocalStorage;