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

package/lib/services/splitChanges/offline/browser.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = createGetConfigurationFromSettings;
+
+var _lang = require("../../../utils/lang");
+
+var _parseCondition = _interopRequireDefault(require("./parseCondition"));
+
+function hasTreatmentChanged(prev, curr) {
+  if (typeof prev !== typeof curr) return true;
+
+  if (typeof prev === 'string') {
+    // strings treatments, just compare
+    return prev !== curr;
+  } else {
+    // has treatment and config, compare both
+    return prev.treatment !== curr.treatment || prev.config !== curr.config;
+  }
+}
+
+function createGetConfigurationFromSettings() {
+  var previousMock = {
+    'emptyMock': 1
+  };
+
+  function mockUpdated(currentData) {
+    var names = Object.keys(currentData); // Different amount of items
+
+    if (names.length !== Object.keys(previousMock).length) {
+      previousMock = currentData;
+      return true;
+    }
+
+    return names.some(function (name) {
+      var newSplit = !previousMock[name];
+      var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
+      var changed = newSplit || newTreatment;
+      if (changed) previousMock = currentData;
+      return changed;
+    });
+  }
+
+  return function getConfigurationFromSettings(settings) {
+    var mockSettings = settings.features || {};
+    if (!mockUpdated(mockSettings)) return false;
+    var splitObjects = {};
+    (0, _lang.forOwn)(mockSettings, function (data, splitName) {
+      var treatment = data;
+      var config = null;
+
+      if ((0, _lang.isObject)(data)) {
+        treatment = data.treatment;
+        config = data.config || config;
+      }
+
+      var configurations = {};
+      if (config !== null) configurations[treatment] = config;
+      splitObjects[splitName] = {
+        trafficTypeName: 'localhost',
+        conditions: [(0, _parseCondition.default)({
+          treatment: treatment
+        })],
+        configurations: configurations
+      };
+    });
+    return splitObjects;
+  };
+}

package/lib/services/splitChanges/offline/node.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = createGetSplitConfigForFile;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+
+var _logger = _interopRequireDefault(require("../../../utils/logger"));
+
+var _lang = require("../../../utils/lang");
+
+var _parseCondition = _interopRequireDefault(require("./parseCondition"));
+
+/**
+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-offline:splits-fetcher');
+var DEFAULT_FILENAME = '.split';
+
+function configFilesPath(config) {
+  if (config === void 0) {
+    config = {};
+  }
+
+  var configFilePath = config.features;
+
+  if (configFilePath === DEFAULT_FILENAME || !(0, _lang.isString)(configFilePath)) {
+    var root = process.env.HOME;
+    if (process.env.SPLIT_CONFIG_ROOT) root = process.env.SPLIT_CONFIG_ROOT;
+    if (!root) throw new Error('Missing split mock configuration root.');
+    configFilePath = _path.default.join(root, DEFAULT_FILENAME);
+  } // Validate the extensions
+
+
+  if (!((0, _lang.endsWith)(configFilePath, '.yaml', true) || (0, _lang.endsWith)(configFilePath, '.yml', true) || (0, _lang.endsWith)(configFilePath, '.split', true))) throw new Error("Invalid extension specified for Splits mock file. Accepted extensions are \".yml\" and \".yaml\". Your specified file is " + configFilePath);
+  if (!_fs.default.existsSync(configFilePath)) throw new Error("Split configuration not found in " + configFilePath + " - Please review your Split file location.");
+  return configFilePath;
+} // This function is not pure nor meant to be. Here we apply modifications to cover
+//  for behaviour that's ensured by the BE.
+
+
+function arrangeConditions(mocksData) {
+  // Iterate through each Split data
+  (0, _lang.forOwn)(mocksData, function (data) {
+    var conditions = data.conditions; // On the manager, as the split jsons come with all treatments on the partitions prop,
+    // we'll add all the treatments to the first condition.
+
+    var firstRolloutCondition = (0, _lang.find)(conditions, function (cond) {
+      return cond.conditionType === 'ROLLOUT';
+    }); // Malformed mocks may have
+
+    var treatments = (0, _lang.uniq)(data.treatments); // If they're only specifying a whitelist we add the treatments there.
+
+    var allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
+    var fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
+    treatments.forEach(function (treatment) {
+      if (treatment !== fullyAllocatedTreatment) {
+        allTreatmentsCondition.partitions.push({
+          treatment: treatment,
+          size: 0
+        });
+      }
+    }); // Don't need these anymore
+
+    delete data.treatments;
+  });
+}
+
+function createGetSplitConfigForFile() {
+  var previousMock = 'NO_MOCK_LOADED'; // Parse `.split` configuration file and return a map of "Split Objects"
+
+  function readSplitConfigFile(filePath) {
+    var SPLIT_POSITION = 0;
+    var TREATMENT_POSITION = 1;
+    var data;
+
+    try {
+      data = _fs.default.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+      log.error(e.message);
+      return {};
+    }
+
+    if (data === previousMock) return false;
+    previousMock = data;
+    var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
+      var tuple = line.trim();
+
+      if (tuple === '' || tuple.charAt(0) === '#') {
+        log.debug("Ignoring empty line or comment at #" + index);
+      } else {
+        tuple = tuple.split(/\s+/);
+
+        if (tuple.length !== 2) {
+          log.debug("Ignoring line since it does not have exactly two columns #" + index);
+        } else {
+          var splitName = tuple[SPLIT_POSITION];
+          var condition = (0, _parseCondition.default)({
+            treatment: tuple[TREATMENT_POSITION]
+          });
+          accum[splitName] = {
+            conditions: [condition],
+            configurations: {},
+            trafficTypeName: 'localhost'
+          };
+        }
+      }
+
+      return accum;
+    }, {});
+    return splitObjects;
+  } // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
+
+
+  function readYAMLConfigFile(filePath) {
+    var data = '';
+    var yamldoc = null;
+
+    try {
+      data = _fs.default.readFileSync(filePath, 'utf8');
+      if (data === previousMock) return false;
+      previousMock = data;
+      yamldoc = _jsYaml.default.safeLoad(data);
+    } catch (e) {
+      log.error(e);
+      return {};
+    } // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+
+
+    var mocksData = yamldoc.reduce(function (accum, splitEntry) {
+      var splitName = Object.keys(splitEntry)[0];
+      if (!splitName || !(0, _lang.isString)(splitEntry[splitName].treatment)) log.error('Ignoring entry on YAML since the format is incorrect.');
+      var mockData = splitEntry[splitName]; // "Template" for each split accumulated data
+
+      if (!accum[splitName]) {
+        accum[splitName] = {
+          configurations: {},
+          conditions: [],
+          treatments: [],
+          trafficTypeName: 'localhost'
+        };
+      } // Assign the config if there is one on the mock
+
+
+      if (mockData.config) accum[splitName].configurations[mockData.treatment] = mockData.config; // Parse the condition from the entry.
+
+      var condition = (0, _parseCondition.default)(mockData);
+      accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition); // Also keep track of the treatments, will be useful for manager functionality.
+
+      accum[splitName].treatments.push(mockData.treatment);
+      return accum;
+    }, {});
+    arrangeConditions(mocksData);
+    return mocksData;
+  } // Load the content of a configuration file into an Object
+
+
+  return function getSplitConfigForFile(settings) {
+    var filePath = configFilesPath(settings);
+    var mockData = null; // If we have a filePath, it means the extension is correct, choose the parser.
+
+    if ((0, _lang.endsWith)(filePath, '.split')) {
+      log.warn('.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+      mockData = readSplitConfigFile(filePath);
+    } else {
+      mockData = readYAMLConfigFile(filePath);
+    }
+
+    return mockData;
+  };
+}

package/lib/services/splitChanges/offline/package.json

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

package/lib/services/splitChanges/offline/parseCondition.js

@@ -0,0 +1,49 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = parseCondition;
+
+var _lang = require("../../../utils/lang");
+
+function parseCondition(data) {
+  var treatment = data.treatment;
+
+  if (data.keys) {
+    return {
+      conditionType: 'WHITELIST',
+      matcherGroup: {
+        combiner: 'AND',
+        matchers: [{
+          keySelector: null,
+          matcherType: 'WHITELIST',
+          negate: false,
+          whitelistMatcherData: {
+            whitelist: (0, _lang.isString)(data.keys) ? [data.keys] : data.keys
+          }
+        }]
+      },
+      partitions: [{
+        treatment: treatment,
+        size: 100
+      }],
+      label: "whitelisted " + treatment
+    };
+  } else {
+    return {
+      conditionType: 'ROLLOUT',
+      matcherGroup: {
+        combiner: 'AND',
+        matchers: [{
+          keySelector: null,
+          matcherType: 'ALL_KEYS',
+          negate: false
+        }]
+      },
+      partitions: [{
+        treatment: treatment,
+        size: 100
+      }],
+      label: 'default rule'
+    };
+  }
+}

package/lib/services/transport/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = Fetcher;
+
+var _getFetch = _interopRequireDefault(require("../getFetch"));
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var log = (0, _logger.default)('splitio-services:service');
+var messageNoFetch = 'Global fetch API is not available.';
+
+function Fetcher(request) {
+  // using `fetch(url, options)` signature to work with unfetch
+  var url = request.url;
+  var fetch = (0, _getFetch.default)();
+  return fetch ? fetch(url, request) // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
+  .then(function (response) {
+    if (!response.ok) {
+      return response.text().then(function (message) {
+        return Promise.reject({
+          response: response,
+          message: message
+        });
+      });
+    }
+
+    return response;
+  }).catch(function (error) {
+    var resp = error && error.response;
+    var msg = '';
+
+    if (resp) {
+      // An HTTP error
+      switch (resp.status) {
+        case 404:
+          msg = 'Invalid API key or resource not found.';
+          break;
+        // Don't use resp.statusText since reason phrase is removed in HTTP/2
+
+        default:
+          msg = error.message;
+          break;
+      }
+    } else {
+      // Something else, either an error making the request or a Network error.
+      msg = error.message;
+    }
+
+    if (!resp || resp.status !== 403) {
+      // 403's log we'll be handled somewhere else.
+      log[request.logErrorsAsInfo ? 'info' : 'error']("Response status is not OK. Status: " + (resp ? resp.status : 'NO_STATUS') + ". URL: " + url + ". Message: " + msg);
+    } // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
+
+
+    throw new _Errors.SplitNetworkError(msg, resp && resp.status);
+  }) : Promise.reject(new _Errors.SplitNetworkError(messageNoFetch));
+}

package/lib/storage/AttributesCache/InMemory.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var AttributesCacheInMemory = /*#__PURE__*/function () {
+  function AttributesCacheInMemory() {
+    this.attributesCache = {};
+  }
+  /**
+   * Create or update the value for the given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored
+   */
+
+
+  var _proto = AttributesCacheInMemory.prototype;
+
+  _proto.setAttribute = function setAttribute(attributeName, attributeValue) {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+  /**
+   * Retrieves the value of a given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  ;
+
+  _proto.getAttribute = function getAttribute(attributeName) {
+    return this.attributesCache[attributeName];
+  }
+  /**
+   * Create or update all the given attributes
+   *
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  ;
+
+  _proto.setAttributes = function setAttributes(attributes) {
+    this.attributesCache = (0, _objectAssign.default)(this.attributesCache, attributes);
+    return true;
+  }
+  /**
+   * Retrieve the full attributes map
+   *
+   * @returns {Map<string, Object>} stored attributes
+   */
+  ;
+
+  _proto.getAll = function getAll() {
+    return this.attributesCache;
+  }
+  /**
+   * Removes a given attribute from the map
+   *
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  ;
+
+  _proto.removeAttribute = function removeAttribute(attributeName) {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * Clears all attributes stored in the SDK
+   *
+   */
+  ;
+
+  _proto.clear = function clear() {
+    this.attributesCache = {};
+    return true;
+  };
+
+  return AttributesCacheInMemory;
+}();
+
+var _default = AttributesCacheInMemory;
+exports.default = _default;

package/lib/storage/BaseMetricsAsyncCache.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var BaseMetricsAsyncCache = /*#__PURE__*/function () {
+  function BaseMetricsAsyncCache() {}
+
+  var _proto = BaseMetricsAsyncCache.prototype;
+
+  /**
+   * Async storage caches will always count as empty from an SDK Producer point of view.
+   */
+  _proto.isEmpty = function isEmpty() {
+    return true;
+  }
+  /**
+   * On async storages we will save metrics on Redis but nothing more. No clean ups or consumptions.
+   */
+  ;
+
+  _proto.clear = function clear() {// noop.
+  };
+
+  return BaseMetricsAsyncCache;
+}();
+
+exports.default = BaseMetricsAsyncCache;

package/lib/storage/CountCache/InMemory.js

@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+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 CountCacheInMemory = /*#__PURE__*/function () {
+  function CountCacheInMemory() {
+    this.clear();
+  }
+
+  var _proto = CountCacheInMemory.prototype;
+
+  _proto.clear = function clear() {
+    this.counters = {};
+    return this;
+  };
+
+  _proto.state = function state() {
+    return this.counters;
+  };
+
+  _proto.track = function track(metricName) {
+    if (this.counters[metricName] === undefined) this.counters[metricName] = 1;else this.counters[metricName]++;
+    return this.counters[metricName];
+  };
+
+  _proto.isEmpty = function isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.counters;
+  };
+
+  return CountCacheInMemory;
+}();
+
+var _default = CountCacheInMemory;
+exports.default = _default;

package/lib/storage/CountCache/InRedis.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _BaseMetricsAsyncCache = _interopRequireDefault(require("../BaseMetricsAsyncCache"));
+
+/**
+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 CountCacheInRedis = /*#__PURE__*/function (_BaseMetricsAsyncCach) {
+  (0, _inheritsLoose2.default)(CountCacheInRedis, _BaseMetricsAsyncCach);
+
+  function CountCacheInRedis(keys, redis) {
+    var _this;
+
+    _this = _BaseMetricsAsyncCach.call(this) || this;
+    _this.keys = keys;
+    _this.redis = redis;
+    return _this;
+  }
+
+  var _proto = CountCacheInRedis.prototype;
+
+  _proto.track = function track(metricName) {
+    return this.redis.incr(this.keys.buildCountKey(metricName)).catch(function () {// noop, for telemetry metrics there's no need to throw.
+    });
+  };
+
+  return CountCacheInRedis;
+}(_BaseMetricsAsyncCache.default);
+
+var _default = CountCacheInRedis;
+exports.default = _default;