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

package/lib/storage/SplitCache/InRedis.js

@@ -0,0 +1,224 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lang = require("../../utils/lang");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var log = (0, _logger.default)('splitio-storage:redis');
+/**
+ * Discard errors for an answer of multiple operations.
+ */
+
+var processPipelineAnswer = function processPipelineAnswer(results) {
+  return results.reduce(function (accum, errValuePair) {
+    if (errValuePair[0] === null) accum.push(errValuePair[1]);
+    return accum;
+  }, []);
+};
+
+var SplitCacheInRedis = /*#__PURE__*/function () {
+  function SplitCacheInRedis(keys, redis) {
+    var _this = this;
+
+    this.redis = redis;
+    this.keys = keys;
+    this.redisError = false;
+    this.redis.on('error', function (e) {
+      _this.redisError = e;
+    });
+    this.redis.on('connect', function () {
+      _this.redisError = false;
+    });
+  }
+
+  var _proto = SplitCacheInRedis.prototype;
+
+  _proto.addSplit = function addSplit(splitName, split) {
+    return this.redis.set(this.keys.buildSplitKey(splitName), split).then(function (status) {
+      return status === 'OK';
+    });
+  };
+
+  _proto.addSplits = function addSplits(entries) {
+    var _this2 = this;
+
+    if (entries.length) {
+      var cmds = entries.map(function (keyValuePair) {
+        return ['set', _this2.keys.buildSplitKey(keyValuePair[0]), keyValuePair[1]];
+      });
+      return this.redis.pipeline(cmds).exec().then(processPipelineAnswer).then(function (answers) {
+        return answers.map(function (status) {
+          return status === 'OK';
+        });
+      });
+    } else {
+      return [true];
+    }
+  }
+  /**
+   * Remove a given split from Redis. Returns the number of deleted keys.
+   */
+  ;
+
+  _proto.removeSplit = function removeSplit(splitName) {
+    return this.redis.del(this.keys.buildSplitKey(splitName));
+  }
+  /**
+   * Bulk delete of splits from Redis. Returns the number of deleted keys.
+   */
+  ;
+
+  _proto.removeSplits = function removeSplits(names) {
+    var _this3 = this;
+
+    if (names.length) {
+      return this.redis.del(names.map(function (n) {
+        return _this3.keys.buildSplitKey(n);
+      }));
+    } else {
+      return Promise.resolve(0);
+    }
+  }
+  /**
+   * Get split definition or null if it's not defined.
+   */
+  ;
+
+  _proto.getSplit = function getSplit(splitName) {
+    if (this.redisError) {
+      log.error(this.redisError);
+      throw this.redisError;
+    }
+
+    return this.redis.get(this.keys.buildSplitKey(splitName));
+  }
+  /**
+   * Set till number.
+   *
+   * @TODO pending error handling
+   */
+  ;
+
+  _proto.setChangeNumber = function setChangeNumber(changeNumber) {
+    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(function (status) {
+      return status === 'OK';
+    });
+  }
+  /**
+   * Get till number or null if it's not defined.
+   *
+   * @TODO pending error handling
+   */
+  ;
+
+  _proto.getChangeNumber = function getChangeNumber() {
+    return this.redis.get(this.keys.buildSplitsTillKey()).then(function (value) {
+      var i = parseInt(value, 10);
+      return (0, _lang.numberIsNaN)(i) ? -1 : i;
+    });
+  }
+  /**
+   * @TODO we need to benchmark which is the maximun number of commands we could
+   *       pipeline without kill redis performance.
+   */
+  ;
+
+  _proto.getAll = function getAll() {
+    var _this4 = this;
+
+    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) {
+      return _this4.redis.pipeline(listOfKeys.map(function (k) {
+        return ['get', k];
+      })).exec();
+    }).then(processPipelineAnswer);
+  };
+
+  _proto.getKeys = function getKeys() {
+    var _this5 = this;
+
+    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) {
+      return listOfKeys.map(_this5.keys.extractKey);
+    });
+  };
+
+  _proto.trafficTypeExists = function trafficTypeExists(trafficType) {
+    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
+    return this.redis.get(this.keys.buildTrafficTypeKey(trafficType)).then(function (ttCount) {
+      ttCount = parseInt(ttCount, 10);
+
+      if (!(0, _lang.numberIsFinite)(ttCount) || ttCount < 0) {
+        log.info("Could not validate traffic type existance of " + trafficType + " due to data corruption of some sorts.");
+        return false;
+      }
+
+      return ttCount > 0;
+    }).catch(function (e) {
+      log.error("Could not validate traffic type existance of " + trafficType + " due to an error: " + e + "."); // If there is an error, bypass the validation so the event can get tracked.
+
+      return true;
+    });
+  } // noop, just keeping the interface. This is used by client-side implementations only.
+  ;
+
+  _proto.usesSegments = function usesSegments() {
+    return true;
+  }
+  /**
+   * Delete everything in the current database.
+   *
+   * @NOTE documentation says it never fails.
+   */
+  ;
+
+  _proto.flush = function flush() {
+    return this.redis.flushdb().then(function (status) {
+      return status === 'OK';
+    });
+  }
+  /**
+   * Fetches multiple splits definitions.
+   */
+  ;
+
+  _proto.fetchMany = function fetchMany(splitNames) {
+    var _this6 = this,
+        _this$redis;
+
+    if (this.redisError) {
+      log.error(this.redisError);
+      throw this.redisError;
+    }
+
+    var splits = {};
+    var keys = splitNames.map(function (splitName) {
+      return _this6.keys.buildSplitKey(splitName);
+    });
+    return (_this$redis = this.redis).mget.apply(_this$redis, keys).then(function (splitDefinitions) {
+      splitNames.forEach(function (splitName, idx) {
+        splits[splitName] = splitDefinitions[idx];
+      });
+      return Promise.resolve(splits);
+    }).catch(function (e) {
+      log.error("Could not grab splits due to an error: " + e + ".");
+      return Promise.reject(e);
+    });
+  }
+  /**
+   * Check if the splits information is already stored in cache. Redis would actually be the cache.
+   */
+  ;
+
+  _proto.checkCache = function checkCache() {
+    return false;
+  };
+
+  return SplitCacheInRedis;
+}();
+
+var _default = SplitCacheInRedis;
+exports.default = _default;

package/lib/storage/SplitCache/killLocally.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = killLocally;
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+ * Kill `splitName` at `this` split storage, setting `defaultTreatment` and `changeNumber`,
+ * only if the split exists and its `changeNumber` is older than the given one.
+ * Used for SPLIT_KILL push notifications.
+ *
+ * @param {string} splitName
+ * @param {string} defaultTreatment
+ * @param {number} changeNumber
+ * @returns {Promise} a promise that is resolved once the split kill is performed.
+ * The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated, for instance,
+ * if the `changeNumber` is old, if the `splitName` is not found, or if the storage fails to apply the update.
+ */
+function killLocally(splitName, defaultTreatment, changeNumber) {
+  var _this = this;
+
+  var split = this.getSplit(splitName);
+  var splitPromise = (0, _thenable.default)(split) ? split : Promise.resolve(split);
+  return splitPromise.then(function (split) {
+    if (split) {
+      var parsedSplit = JSON.parse(split);
+
+      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
+        parsedSplit.killed = true;
+        parsedSplit.defaultTreatment = defaultTreatment;
+        parsedSplit.changeNumber = changeNumber;
+        var newSplit = JSON.stringify(parsedSplit);
+        return _this.addSplit(splitName, newSplit);
+      }
+    }
+
+    return false;
+  });
+}

package/lib/storage/browser.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = void 0;
+
+var _InMemory = _interopRequireDefault(require("./SplitCache/InMemory"));
+
+var _InLocalStorage = _interopRequireDefault(require("./SplitCache/InLocalStorage"));
+
+var _InMemory2 = _interopRequireDefault(require("./SegmentCache/InMemory"));
+
+var _InLocalStorage2 = _interopRequireDefault(require("./SegmentCache/InLocalStorage"));
+
+var _InMemory3 = _interopRequireDefault(require("./ImpressionsCache/InMemory"));
+
+var _InMemory4 = _interopRequireDefault(require("./LatencyCache/InMemory"));
+
+var _InMemory5 = _interopRequireDefault(require("./CountCache/InMemory"));
+
+var _InMemory6 = _interopRequireDefault(require("./EventsCache/InMemory"));
+
+var _Keys = _interopRequireDefault(require("./Keys"));
+
+var _KeysLocalStorage = _interopRequireDefault(require("./KeysLocalStorage"));
+
+var _constants = require("../utils/constants");
+
+// This value might be eventually set via a config parameter
+var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
+
+exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+
+var BrowserStorageFactory = function BrowserStorageFactory(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var storage = settings.storage;
+
+  switch (storage.type) {
+    case _constants.STORAGE_MEMORY:
+      {
+        var keys = new _Keys.default(settings);
+        return {
+          splits: new _InMemory.default(),
+          segments: new _InMemory2.default(keys),
+          impressions: new _InMemory3.default(),
+          metrics: new _InMemory4.default(),
+          count: new _InMemory5.default(),
+          events: new _InMemory6.default(context),
+          // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
+          shared: function shared(settings) {
+            var childKeyBuilder = new _Keys.default(settings);
+            return {
+              splits: this.splits,
+              segments: new _InMemory2.default(childKeyBuilder),
+              impressions: this.impressions,
+              metrics: this.metrics,
+              count: this.count,
+              events: this.events,
+              destroy: function destroy() {
+                this.splits = new _InMemory.default();
+                this.segments.flush();
+              }
+            };
+          },
+          destroy: function destroy() {
+            this.splits.flush();
+            this.segments.flush();
+            this.impressions.clear();
+            this.metrics.clear();
+            this.count.clear();
+            this.events.clear();
+          }
+        };
+      }
+
+    case _constants.STORAGE_LOCALSTORAGE:
+      {
+        var _keys = new _KeysLocalStorage.default(settings);
+
+        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        return {
+          splits: new _InLocalStorage.default(_keys, expirationTimestamp, settings.sync.__splitFiltersValidation),
+          segments: new _InLocalStorage2.default(_keys),
+          impressions: new _InMemory3.default(),
+          metrics: new _InMemory4.default(),
+          count: new _InMemory5.default(),
+          events: new _InMemory6.default(context),
+          // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
+          shared: function shared(settings) {
+            var childKeysBuilder = new _KeysLocalStorage.default(settings);
+            return {
+              splits: this.splits,
+              segments: new _InLocalStorage2.default(childKeysBuilder),
+              impressions: this.impressions,
+              metrics: this.metrics,
+              count: this.count,
+              events: this.events,
+              destroy: function destroy() {
+                this.splits = new _InMemory.default();
+                this.segments = new _InMemory2.default(childKeysBuilder);
+              }
+            };
+          },
+          destroy: function destroy() {
+            this.splits = new _InMemory.default();
+            this.segments = new _InMemory2.default(new _Keys.default(settings));
+            this.impressions.clear();
+            this.metrics.clear();
+            this.count.clear();
+            this.events.clear();
+          }
+        };
+      }
+
+    default:
+      throw new Error('Unsupported storage type');
+  }
+};
+
+var _default = BrowserStorageFactory;
+exports.default = _default;

package/lib/storage/node.js

@@ -0,0 +1,104 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _RedisAdapter = _interopRequireDefault(require("./RedisAdapter"));
+
+var _InMemory = _interopRequireDefault(require("./SplitCache/InMemory"));
+
+var _InRedis = _interopRequireDefault(require("./SplitCache/InRedis"));
+
+var _InMemory2 = _interopRequireDefault(require("./SegmentCache/InMemory"));
+
+var _InRedis2 = _interopRequireDefault(require("./SegmentCache/InRedis"));
+
+var _InMemory3 = _interopRequireDefault(require("./ImpressionsCache/InMemory"));
+
+var _InRedis3 = _interopRequireDefault(require("./ImpressionsCache/InRedis"));
+
+var _InMemory4 = _interopRequireDefault(require("./LatencyCache/InMemory"));
+
+var _InRedis4 = _interopRequireDefault(require("./LatencyCache/InRedis"));
+
+var _InMemory5 = _interopRequireDefault(require("./CountCache/InMemory"));
+
+var _InRedis5 = _interopRequireDefault(require("./CountCache/InRedis"));
+
+var _InMemory6 = _interopRequireDefault(require("./EventsCache/InMemory"));
+
+var _InRedis6 = _interopRequireDefault(require("./EventsCache/InRedis"));
+
+var _Keys = _interopRequireDefault(require("./Keys"));
+
+var _Meta = _interopRequireDefault(require("./Meta"));
+
+var _constants = require("../utils/constants");
+
+var NodeStorageFactory = function NodeStorageFactory(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var storage = settings.storage;
+  var keys = new _Keys.default(settings);
+
+  switch (storage.type) {
+    case _constants.STORAGE_REDIS:
+      {
+        var redis = new _RedisAdapter.default(storage.options);
+        var meta = (0, _Meta.default)(settings); // subscription to Redis connect event in order to emit SDK_READY
+
+        var _context$get = context.get(context.constants.READINESS),
+            splits = _context$get.splits,
+            segments = _context$get.segments;
+
+        redis.on('connect', function () {
+          splits.emit(splits.SDK_SPLITS_ARRIVED);
+          segments.emit(segments.SDK_SEGMENTS_ARRIVED);
+        });
+        return {
+          splits: new _InRedis.default(keys, redis),
+          segments: new _InRedis2.default(keys, redis),
+          impressions: new _InRedis3.default(keys, redis, meta),
+          metrics: new _InRedis4.default(keys, redis),
+          count: new _InRedis5.default(keys, redis),
+          events: new _InRedis6.default(keys, redis, meta),
+          // When using REDIS we should:
+          // 1- Disconnect from the storage
+          // 2- Stop sending data to Redis and instance using empty in memory implementation
+          destroy: function destroy() {
+            redis.disconnect();
+            this.splits = new _InMemory.default();
+            this.segments = new _InMemory2.default(keys);
+            this.impressions = new _InMemory3.default();
+            this.metrics = new _InMemory4.default();
+            this.count = new _InMemory5.default();
+            this.events = new _InMemory6.default(context);
+          }
+        };
+      }
+
+    case _constants.STORAGE_MEMORY:
+    default:
+      return {
+        splits: new _InMemory.default(),
+        segments: new _InMemory2.default(keys),
+        impressions: new _InMemory3.default(),
+        metrics: new _InMemory4.default(),
+        count: new _InMemory5.default(),
+        events: new _InMemory6.default(context),
+        // When using MEMORY we should flush all the storages and leave them empty
+        destroy: function destroy() {
+          this.splits.flush();
+          this.segments.flush();
+          this.impressions.clear();
+          this.metrics.clear();
+          this.count.clear();
+          this.events.clear();
+        }
+      };
+  }
+};
+
+var _default = NodeStorageFactory;
+exports.default = _default;

package/lib/storage/package.json

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

package/lib/sync/AuthClient/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = authenticate;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _auth = _interopRequireDefault(require("../../services/auth"));
+
+var _auth2 = _interopRequireDefault(require("../../services/auth/auth"));
+
+var _jwt = require("../../utils/jwt");
+
+/**
+ * Run authentication requests to Auth Server, and handle response decoding the JTW token.
+ * Precondition:
+ *
+ * @param {Object} settings Split factory config, used to get authorizationKey and other params required by authRequest.
+ * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for Node.
+ * @throws {ReferenceError} if `atob` function is not defined
+ */
+function authenticate(settings, userKeys) {
+  var authPromise = (0, _auth.default)((0, _auth2.default)(settings, userKeys)); // errors handled by authService
+
+  return authPromise // no need to handle json parsing errors as SplitError, since no user callbacks are executed after this promise is resolved
+  .then(function (resp) {
+    return resp.json();
+  }).then(function (json) {
+    if (json.token) {
+      // empty token when `"pushEnabled": false`
+      var decodedToken = (0, _jwt.decodeJWTtoken)(json.token);
+      if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
+      var channels = JSON.parse(decodedToken['x-ably-capability']);
+      return (0, _objectAssign.default)({
+        decodedToken: decodedToken,
+        channels: channels
+      }, json);
+    }
+
+    return json;
+  });
+}