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

package/lib/utils/inputValidation/attribute.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateAttribute = validateAttribute;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+
+function validateAttribute(attributeKey, attributeValue, method) {
+  if (!(0, _lang.isString)(attributeKey) || attributeKey.length === 0) {
+    log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+    return false;
+  }
+
+  var isStringVal = (0, _lang.isString)(attributeValue);
+  var isFiniteVal = (0, _lang.numberIsFinite)(attributeValue);
+  var isBoolVal = (0, _lang.isBoolean)(attributeValue);
+  var isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) {
+    // If it's not of valid type.
+    log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+    return false;
+  }
+
+  return true;
+}

package/lib/utils/inputValidation/attributes.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateAttributes = validateAttributes;
+exports.validateAttributesDeep = validateAttributesDeep;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _attribute = require("./attribute");
+
+var log = (0, _logger.default)('');
+
+function validateAttributes(maybeAttrs, method) {
+  // Attributes are optional
+  if ((0, _lang.isObject)(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+    return maybeAttrs;
+  log.error(method + ": attributes must be a plain object.");
+  return false;
+}
+
+function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  var result = true;
+  Object.keys(maybeAttributes).forEach(function (attributeKey) {
+    if (!(0, _attribute.validateAttribute)(attributeKey, maybeAttributes[attributeKey], method)) result = false;
+  });
+  return result;
+}

package/lib/utils/inputValidation/event.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateEvent = validateEvent;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+var EVENT_TYPE_REGEX = /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/;
+
+function validateEvent(maybeEvent, method) {
+  if (maybeEvent == undefined) {
+    // eslint-disable-line eqeqeq
+    log.error(method + ": you passed a null or undefined event_type, event_type must be a non-empty string.");
+  } else if (!(0, _lang.isString)(maybeEvent)) {
+    log.error(method + ": you passed an invalid event_type, event_type must be a non-empty string.");
+  } else {
+    // It is a string.
+    if (maybeEvent.length === 0) {
+      log.error(method + ": you passed an empty event_type, event_type must be a non-empty string.");
+    } else if (!EVENT_TYPE_REGEX.test(maybeEvent)) {
+      log.error(method + ": you passed \"" + maybeEvent + "\", event_type must adhere to the regular expression /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/g. This means an event_type must be alphanumeric, cannot be more than 80 characters long, and can only include a dash, underscore, period, or colon as separators of alphanumeric characters.");
+    } else {
+      return maybeEvent;
+    }
+  }
+
+  return false;
+}

package/lib/utils/inputValidation/eventProperties.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateEventProperties = validateEventProperties;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+var ECMA_SIZES = {
+  NULL: 0,
+  // While on the JSON it's going to occupy more space, we'll take it as 0 for the approximation.
+  STRING: 2,
+  BOOLEAN: 4,
+  NUMBER: 8
+};
+var MAX_PROPERTIES_AMOUNT = 300;
+var MAX_PROPERTIES_SIZE = 1024 * 32;
+var BASE_EVENT_SIZE = 1024; // We assume 1kb events without properties (avg measured)
+
+function validateEventProperties(maybeProperties, method) {
+  if (maybeProperties == undefined) return {
+    properties: null,
+    size: BASE_EVENT_SIZE
+  }; // eslint-disable-line eqeqeq
+
+  if (!(0, _lang.isObject)(maybeProperties)) {
+    log.error(method + ": properties must be a plain object.");
+    return {
+      properties: false,
+      size: BASE_EVENT_SIZE
+    };
+  }
+
+  var keys = Object.keys(maybeProperties);
+  var clone = (0, _lang.shallowClone)(maybeProperties); // To avoid calculating the size twice we'll return it from here.
+
+  var output = {
+    properties: clone,
+    size: BASE_EVENT_SIZE // We assume 1kb events without properties (avg measured)
+
+  };
+
+  if (keys.length > MAX_PROPERTIES_AMOUNT) {
+    log.warn(method + ": Event has more than 300 properties. Some of them will be trimmed when processed.");
+  }
+
+  for (var i = 0; i < keys.length; i++) {
+    output.size += keys[i].length * ECMA_SIZES.STRING; // Count the size of the key which is always a string.
+
+    var val = clone[keys[i]];
+    var isStringVal = (0, _lang.isString)(val);
+    var isFiniteVal = (0, _lang.numberIsFinite)(val);
+    var isBoolVal = (0, _lang.isBoolean)(val);
+    var isNullVal = val === null;
+
+    if (!(isStringVal || isFiniteVal || isBoolVal || isNullVal)) {
+      // If it's not of valid type.
+      clone[keys[i]] = null;
+      val = null;
+      isNullVal = true;
+      log.warn(method + ": Property " + keys[i] + " is of invalid type. Setting value to null.");
+    }
+
+    if (isNullVal) output.size += ECMA_SIZES.NULL;else if (isFiniteVal) output.size += ECMA_SIZES.NUMBER;else if (isBoolVal) output.size += ECMA_SIZES.BOOLEAN;else if (isStringVal) output.size += val.length * ECMA_SIZES.STRING;
+
+    if (output.size > MAX_PROPERTIES_SIZE) {
+      log.error(method + ": The maximum size allowed for the properties is 32768 bytes, which was exceeded. Event not queued.");
+      output.properties = false;
+      break;
+    }
+  }
+
+  return output;
+}

package/lib/utils/inputValidation/eventValue.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateEventValue = validateEventValue;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+
+function validateEventValue(maybeValue, method) {
+  if ((0, _lang.numberIsFinite)(maybeValue) || maybeValue == undefined) // eslint-disable-line eqeqeq
+    return maybeValue;
+  log.error(method + ": value must be a finite number.");
+  return false;
+}

package/lib/utils/inputValidation/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports.validateIfReady = exports.validateIfDestroyed = exports.validateTrafficTypeExistance = exports.validateTrafficType = exports.validateSplits = exports.validateSplitExistance = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateApiKey = void 0;
+
+var _apiKey = require("./apiKey");
+
+exports.validateApiKey = _apiKey.validateApiKey;
+exports.releaseApiKey = _apiKey.releaseApiKey;
+
+var _attributes = require("./attributes");
+
+exports.validateAttributes = _attributes.validateAttributes;
+
+var _event = require("./event");
+
+exports.validateEvent = _event.validateEvent;
+
+var _eventValue = require("./eventValue");
+
+exports.validateEventValue = _eventValue.validateEventValue;
+
+var _eventProperties = require("./eventProperties");
+
+exports.validateEventProperties = _eventProperties.validateEventProperties;
+
+var _key = require("./key");
+
+exports.validateKey = _key.validateKey;
+
+var _split = require("./split");
+
+exports.validateSplit = _split.validateSplit;
+exports.validateSplitExistance = _split.validateSplitExistance;
+
+var _splits = require("./splits");
+
+exports.validateSplits = _splits.validateSplits;
+
+var _trafficType = require("./trafficType");
+
+exports.validateTrafficType = _trafficType.validateTrafficType;
+exports.validateTrafficTypeExistance = _trafficType.validateTrafficTypeExistance;
+
+var _isOperational = require("./isOperational");
+
+exports.validateIfDestroyed = _isOperational.validateIfDestroyed;
+exports.validateIfReady = _isOperational.validateIfReady;

package/lib/utils/inputValidation/isOperational.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateIfDestroyed = validateIfDestroyed;
+exports.validateIfReady = validateIfReady;
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('', {
+  displayAllErrors: true
+});
+
+function validateIfDestroyed(context) {
+  if (!context.get(context.constants.DESTROYED, true)) return true;
+  log.error('Client has already been destroyed - no calls possible.');
+  return false;
+}
+
+function validateIfReady(context, method) {
+  if (context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true)) return true;
+  log.warn(method + ": the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.");
+  return false;
+}

package/lib/utils/inputValidation/key.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateKey = validateKey;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+var KEY_MAX_LENGTH = 250;
+
+function validateKeyValue(maybeKey, method, type) {
+  if (maybeKey == undefined) {
+    // eslint-disable-line eqeqeq
+    log.error(method + ": you passed a null or undefined " + type + ", " + type + " must be a non-empty string.");
+    return false;
+  }
+
+  if ((0, _lang.numberIsFinite)(maybeKey)) {
+    log.warn(method + ": " + type + " \"" + maybeKey + "\" is not of type string, converting.");
+    return (0, _lang.toString)(maybeKey);
+  }
+
+  if ((0, _lang.isString)(maybeKey)) {
+    // It's a string, start by trimming the value.
+    maybeKey = maybeKey.trim(); // It's aaaaaall good.
+
+    if (maybeKey.length > 0 && maybeKey.length <= KEY_MAX_LENGTH) return maybeKey;
+
+    if (maybeKey.length === 0) {
+      log.error(method + ": you passed an empty string, " + type + " must be a non-empty string.");
+    } else if (maybeKey.length > KEY_MAX_LENGTH) {
+      log.error(method + ": " + type + " too long, " + type + " must be 250 characters or less.");
+    }
+  } else {
+    log.error(method + ": you passed an invalid " + type + " type, " + type + " must be a non-empty string.");
+  }
+
+  return false;
+}
+
+function validateKey(maybeKey, method) {
+  if ((0, _lang.isObject)(maybeKey)) {
+    // Validate key object
+    var matchingKey = validateKeyValue(maybeKey.matchingKey, method, 'matchingKey');
+    var bucketingKey = validateKeyValue(maybeKey.bucketingKey, method, 'bucketingKey');
+    if (matchingKey && bucketingKey) return {
+      matchingKey: matchingKey,
+      bucketingKey: bucketingKey
+    };
+    log.error(method + ": Key must be an object with bucketingKey and matchingKey with valid string properties.");
+    return false;
+  } else {
+    return validateKeyValue(maybeKey, method, 'key');
+  }
+}

package/lib/utils/inputValidation/split.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateSplit = validateSplit;
+exports.validateSplitExistance = validateSplitExistance;
+
+var _lang = require("../lang");
+
+var _labels = require("../labels");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)(''); // include BOM and nbsp
+
+var TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
+
+function validateSplit(maybeSplit, method, item) {
+  if (item === void 0) {
+    item = 'split name';
+  }
+
+  if (maybeSplit == undefined) {
+    // eslint-disable-line eqeqeq
+    log.error(method + ": you passed a null or undefined " + item + ", " + item + " must be a non-empty string.");
+  } else if (!(0, _lang.isString)(maybeSplit)) {
+    log.error(method + ": you passed an invalid " + item + ", " + item + " must be a non-empty string.");
+  } else {
+    if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
+      log.warn(method + ": " + item + " \"" + maybeSplit + "\" has extra whitespace, trimming.");
+      maybeSplit = maybeSplit.trim();
+    }
+
+    if (maybeSplit.length > 0) {
+      return maybeSplit;
+    } else {
+      log.error(method + ": you passed an empty " + item + ", " + item + " must be a non-empty string.");
+    }
+  }
+
+  return false;
+}
+/**
+ * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
+ * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
+ */
+
+
+function validateSplitExistance(context, splitName, labelOrSplitObj, method) {
+  if (context.get(context.constants.READY, true)) {
+    // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
+    if (labelOrSplitObj === _labels.SPLIT_NOT_FOUND || labelOrSplitObj == null) {
+      log.warn(method + ": you passed \"" + splitName + "\" that does not exist in this environment, please double check what Splits exist in the web console.");
+      return false;
+    }
+  }
+
+  return true;
+}

package/lib/utils/inputValidation/splitFilters.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = validateSplitFilters;
+
+var _constants = require("../constants");
+
+var _splits = require("./splits");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('splitio-settings');
+
+function validateFilterType(filterType) {
+  return _constants.FILTERS_METADATA.some(function (filterMetadata) {
+    return filterMetadata.type === filterType;
+  });
+}
+/**
+ * Validate, deduplicate and sort a given list of filter values.
+ *
+ * @param {string} type filter type string used for log messages
+ * @param {string[]} values list of values to validate, deduplicate and sort
+ * @param {number} maxLength
+ * @returns list of valid, unique and alphabetically sorted non-empty strings. The list is empty if `values` param is not a non-empty array or all its values are invalid.
+ *
+ * @throws Error if the sanitized list exceeds the length indicated by `maxLength`
+ */
+
+
+function validateSplitFilter(type, values, maxLength) {
+  // validate and remove invalid and duplicated values
+  var result = (0, _splits.validateSplits)(values, 'settings', type + " filter", type + " filter value");
+
+  if (result) {
+    // check max length
+    if (result.length > maxLength) throw new Error(maxLength + " unique values can be specified at most for '" + type + "' filter. You passed " + result.length + ". Please consider reducing the amount or using other filter."); // sort values
+
+    result.sort();
+  }
+
+  return result || []; // returns empty array if `result` is `false`
+}
+/**
+ * Returns a string representing the URL encoded query component of /splitChanges URL.
+ *
+ * The possible formats of the query string are:
+ *  - null: if all filters are empty
+ *  - '&names=<comma-separated-values>': if only `byPrefix` filter is undefined
+ *  - '&prefixes=<comma-separated-values>': if only `byName` filter is undefined
+ *  - '&names=<comma-separated-values>&prefixes=<comma-separated-values>': if no one is undefined
+ *
+ * @param {Object} groupedFilters object of filters. Each filter must be a list of valid, unique and ordered string values.
+ * @returns null or string with the `split filter query` component of the URL.
+ */
+
+
+function queryStringBuilder(groupedFilters) {
+  var queryParams = [];
+
+  _constants.FILTERS_METADATA.forEach(function (_ref) {
+    var type = _ref.type,
+        queryParam = _ref.queryParam;
+    var filter = groupedFilters[type];
+    if (filter.length > 0) queryParams.push(queryParam + filter.map(function (value) {
+      return encodeURIComponent(value);
+    }).join(','));
+  });
+
+  return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
+}
+/**
+ * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.
+ *
+ * @param {Object|undefined} splitFilters split filters configuration param
+ * @param {string} mode settings mode
+ * @returns it returns an object with the following properties:
+ *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
+ *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
+ *  - `groupedFilters`: list of values grouped by filter type.
+ *
+ * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
+ */
+
+
+function validateSplitFilters(splitFilters, mode) {
+  // Validation result schema
+  var res = {
+    validFilters: [],
+    queryString: null,
+    groupedFilters: {
+      byName: [],
+      byPrefix: []
+    }
+  }; // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
+
+  if (!splitFilters) return res; // Warn depending on the mode
+
+  if (mode !== _constants.STANDALONE_MODE) {
+    log.warn("split filters have been configured but will have no effect if mode is not '" + _constants.STANDALONE_MODE + "', since synchronization is being deferred to an external tool.");
+    return res;
+  } // Check collection type
+
+
+  if (!Array.isArray(splitFilters) || splitFilters.length === 0) {
+    log.warn('splitFilters configuration must be a non-empty array of filter objects.');
+    return res;
+  } // Validate filters and group their values by filter type inside `groupedFilters` object
+
+
+  res.validFilters = splitFilters.filter(function (filter, index) {
+    if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
+      res.groupedFilters[filter.type] = res.groupedFilters[filter.type].concat(filter.values);
+      return true;
+    } else {
+      log.warn("split filter at position '" + index + "' is invalid. It must be an object with a valid filter type ('byName' or 'byPrefix') and a list of 'values'.");
+    }
+
+    return false;
+  }); // By filter type, remove invalid and duplicated values and order them
+
+  _constants.FILTERS_METADATA.forEach(function (_ref2) {
+    var type = _ref2.type,
+        maxLength = _ref2.maxLength;
+    if (res.groupedFilters[type].length > 0) res.groupedFilters[type] = validateSplitFilter(type, res.groupedFilters[type], maxLength);
+  }); // build query string
+
+
+  res.queryString = queryStringBuilder(res.groupedFilters);
+  log.debug("splits filtering criteria is '" + res.queryString + "'.");
+  return res;
+}

package/lib/utils/inputValidation/splits.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateSplits = validateSplits;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _split = require("./split");
+
+var log = (0, _logger.default)('');
+
+function validateSplits(maybeSplits, method, listName, item) {
+  if (listName === void 0) {
+    listName = 'split_names';
+  }
+
+  if (item === void 0) {
+    item = 'split name';
+  }
+
+  if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
+    var validatedArray = []; // Remove invalid values
+
+    maybeSplits.forEach(function (maybeSplit) {
+      var splitName = (0, _split.validateSplit)(maybeSplit, method, item);
+      if (splitName) validatedArray.push(splitName);
+    }); // Strip off duplicated values if we have valid split names then return
+
+    if (validatedArray.length) return (0, _lang.uniq)(validatedArray);
+  }
+
+  log.error(method + ": " + listName + " must be a non-empty array.");
+  return false;
+}

package/lib/utils/inputValidation/trafficType.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateTrafficType = validateTrafficType;
+exports.validateTrafficTypeExistance = validateTrafficTypeExistance;
+
+var _lang = require("../lang");
+
+var _thenable = _interopRequireDefault(require("../promise/thenable"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+var CAPITAL_LETTERS_REGEX = /[A-Z]/;
+
+function validateTrafficType(maybeTT, method) {
+  if (maybeTT == undefined) {
+    // eslint-disable-line eqeqeq
+    log.error(method + ": you passed a null or undefined traffic_type_name, traffic_type_name must be a non-empty string.");
+  } else if (!(0, _lang.isString)(maybeTT)) {
+    log.error(method + ": you passed an invalid traffic_type_name, traffic_type_name must be a non-empty string.");
+  } else {
+    if (maybeTT.length === 0) {
+      log.error(method + ": you passed an empty traffic_type_name, traffic_type_name must be a non-empty string.");
+    } else {
+      if (CAPITAL_LETTERS_REGEX.test(maybeTT)) {
+        log.warn(method + ": traffic_type_name should be all lowercase - converting string to lowercase.");
+        maybeTT = maybeTT.toLowerCase();
+      }
+
+      return maybeTT;
+    }
+  }
+
+  return false;
+}
+
+function logTTExistanceWarning(method, ttName) {
+  log.warn(method + ": Traffic Type " + ttName + " does not have any corresponding Splits in this environment, make sure you're tracking your events to a valid traffic type defined in the Split console.");
+}
+/**
+ * Separated from the previous method since on some cases it'll be async.
+ */
+
+
+function validateTrafficTypeExistance(maybeTT, context, method) {
+  var isReady = context.get(context.constants.READY, true);
+  var settings = context.get(context.constants.SETTINGS);
+  var splitsStorage = context.get(context.constants.STORAGE).splits; // If not ready or in localhost mode, we won't run the validation
+
+  if (!isReady || settings.mode === _constants.LOCALHOST_MODE) return true;
+  var res = splitsStorage.trafficTypeExists(maybeTT);
+
+  if ((0, _thenable.default)(res)) {
+    res.then(function (isValid) {
+      if (!isValid) logTTExistanceWarning(method, maybeTT);
+      return isValid; // propagate result
+    });
+  } else {
+    if (!res) logTTExistanceWarning(method, maybeTT);
+  }
+
+  return res;
+}

package/lib/utils/jwt/hashUserKey.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.hashUserKey = hashUserKey;
+
+var _base = require("../base64");
+
+var _murmur = _interopRequireDefault(require("../../engine/engine/murmur3/murmur3"));
+
+/**
+ * Returns the hash of a given user key
+ *
+ * @throws {ReferenceError} if `btoa` function is not defined (for browser)
+ */
+function hashUserKey(userKey) {
+  return (0, _base.encodeToBase64)(_murmur.default.hash(userKey, 0).toString());
+}

package/lib/utils/jwt/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.__esModule = true;
+exports.decodeJWTtoken = decodeJWTtoken;
+
+var _base = require("../base64");
+
+/**
+ * Decode a JWT token
+ */
+function decodeJWTtoken(token) {
+  var base64Url = token.split('.')[1];
+  var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/'); // no need to check availability of `encodeURIComponent`, since it is a function highly supported in browsers, node and other platforms.
+
+  var jsonPayload = decodeURIComponent((0, _base.decodeFromBase64)(base64).split('').map(function (c) {
+    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+  }).join(''));
+  return JSON.parse(jsonPayload);
+}