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

package/es/utils/inputValidation/attributes.js

@@ -0,0 +1,19 @@
+import { isObject } from '../lang';
+import logFactory from '../logger';
+import { validateAttribute } from './attribute';
+var log = logFactory('');
+export function validateAttributes(maybeAttrs, method) {
+  // Attributes are optional
+  if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+    return maybeAttrs;
+  log.error(method + ": attributes must be a plain object.");
+  return false;
+}
+export function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  var result = true;
+  Object.keys(maybeAttributes).forEach(function (attributeKey) {
+    if (!validateAttribute(attributeKey, maybeAttributes[attributeKey], method)) result = false;
+  });
+  return result;
+}

package/es/utils/inputValidation/event.js

@@ -0,0 +1,23 @@
+import { isString } from '../lang';
+import logFactory from '../logger';
+var log = logFactory('');
+var EVENT_TYPE_REGEX = /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/;
+export 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 (!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/es/utils/inputValidation/eventProperties.js

@@ -0,0 +1,69 @@
+import { isObject, shallowClone, isString, numberIsFinite, isBoolean } from '../lang';
+import logFactory from '../logger';
+var log = logFactory('');
+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)
+
+export function validateEventProperties(maybeProperties, method) {
+  if (maybeProperties == undefined) return {
+    properties: null,
+    size: BASE_EVENT_SIZE
+  }; // eslint-disable-line eqeqeq
+
+  if (!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 = 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 = isString(val);
+    var isFiniteVal = numberIsFinite(val);
+    var isBoolVal = 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/es/utils/inputValidation/eventValue.js

@@ -0,0 +1,9 @@
+import { numberIsFinite } from '../lang';
+import logFactory from '../logger';
+var log = logFactory('');
+export function validateEventValue(maybeValue, method) {
+  if (numberIsFinite(maybeValue) || maybeValue == undefined) // eslint-disable-line eqeqeq
+    return maybeValue;
+  log.error(method + ": value must be a finite number.");
+  return false;
+}

package/es/utils/inputValidation/index.js

@@ -0,0 +1,11 @@
+// This file is just here for easier consumption of the validators.
+export { validateApiKey, releaseApiKey } from './apiKey';
+export { validateAttributes } from './attributes';
+export { validateEvent } from './event';
+export { validateEventValue } from './eventValue';
+export { validateEventProperties } from './eventProperties';
+export { validateKey } from './key';
+export { validateSplit, validateSplitExistance } from './split';
+export { validateSplits } from './splits';
+export { validateTrafficType, validateTrafficTypeExistance } from './trafficType';
+export { validateIfDestroyed, validateIfReady } from './isOperational';

package/es/utils/inputValidation/isOperational.js

@@ -0,0 +1,14 @@
+import logFactory from '../logger';
+var log = logFactory('', {
+  displayAllErrors: true
+});
+export function validateIfDestroyed(context) {
+  if (!context.get(context.constants.DESTROYED, true)) return true;
+  log.error('Client has already been destroyed - no calls possible.');
+  return false;
+}
+export 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/es/utils/inputValidation/key.js

@@ -0,0 +1,50 @@
+import { isObject, isString, numberIsFinite, toString } from '../lang';
+import logFactory from '../logger';
+var log = logFactory('');
+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 (numberIsFinite(maybeKey)) {
+    log.warn(method + ": " + type + " \"" + maybeKey + "\" is not of type string, converting.");
+    return toString(maybeKey);
+  }
+
+  if (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;
+}
+
+export function validateKey(maybeKey, method) {
+  if (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/es/utils/inputValidation/split.js

@@ -0,0 +1,47 @@
+import { isString } from '../lang';
+import { SPLIT_NOT_FOUND } from '../labels';
+import logFactory from '../logger';
+var log = logFactory(''); // include BOM and nbsp
+
+var TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
+export 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 (!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.
+ */
+
+export 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 === 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/es/utils/inputValidation/splitFilters.js

@@ -0,0 +1,121 @@
+import { STANDALONE_MODE, FILTERS_METADATA } from '../constants';
+import { validateSplits } from './splits';
+import logFactory from '../logger';
+var log = logFactory('splitio-settings');
+
+function validateFilterType(filterType) {
+  return 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 = 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 = [];
+  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
+ */
+
+
+export default 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 !== STANDALONE_MODE) {
+    log.warn("split filters have been configured but will have no effect if mode is not '" + 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
+
+  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/es/utils/inputValidation/splits.js

@@ -0,0 +1,27 @@
+import { uniq } from '../lang';
+import logFactory from '../logger';
+import { validateSplit } from './split';
+var log = logFactory('');
+export 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 = 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 uniq(validatedArray);
+  }
+
+  log.error(method + ": " + listName + " must be a non-empty array.");
+  return false;
+}

package/es/utils/inputValidation/trafficType.js

@@ -0,0 +1,55 @@
+import { isString } from '../lang';
+import thenable from '../promise/thenable';
+import { LOCALHOST_MODE } from '../constants';
+import logFactory from '../logger';
+var log = logFactory('');
+var CAPITAL_LETTERS_REGEX = /[A-Z]/;
+export 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 (!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.
+ */
+
+
+export 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 === LOCALHOST_MODE) return true;
+  var res = splitsStorage.trafficTypeExists(maybeTT);
+
+  if (thenable(res)) {
+    res.then(function (isValid) {
+      if (!isValid) logTTExistanceWarning(method, maybeTT);
+      return isValid; // propagate result
+    });
+  } else {
+    if (!res) logTTExistanceWarning(method, maybeTT);
+  }
+
+  return res;
+}

package/es/utils/jwt/hashUserKey.js

@@ -0,0 +1,11 @@
+import { encodeToBase64 } from '../base64';
+import murmur from '../../engine/engine/murmur3/murmur3';
+/**
+ * Returns the hash of a given user key
+ *
+ * @throws {ReferenceError} if `btoa` function is not defined (for browser)
+ */
+
+export function hashUserKey(userKey) {
+  return encodeToBase64(murmur.hash(userKey, 0).toString());
+}

package/es/utils/jwt/index.js

@@ -0,0 +1,14 @@
+import { decodeFromBase64 } from '../base64';
+/**
+ * Decode a JWT token
+ */
+
+export 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(decodeFromBase64(base64).split('').map(function (c) {
+    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+  }).join(''));
+  return JSON.parse(jsonPayload);
+}

package/es/utils/key/factory.js

@@ -0,0 +1,38 @@
+/**
+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.
+**/
+import { isObject } from '../lang';
+/**
+ * Verify type of key and return the set key property
+ * If undefinedIfNotObj === true, it means that unless explicitly defined (using the Key object)
+ * we will return undefined. (if it was a string, there's no bucketingKey)
+ */
+
+function KeyGetterFactory(keyProperty, undefinedIfNotObj) {
+  if (undefinedIfNotObj === void 0) {
+    undefinedIfNotObj = false;
+  }
+
+  return function getKeyProperty(key) {
+    if (isObject(key)) {
+      return key[keyProperty];
+    }
+
+    return undefinedIfNotObj ? undefined : key;
+  };
+}
+
+export var matching = KeyGetterFactory('matchingKey');
+export var bucketing = KeyGetterFactory('bucketingKey', true);

package/es/utils/key/parser.js

@@ -0,0 +1,34 @@
+/**
+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.
+**/
+import { isObject } from '../lang';
+/**
+ * Verify type of key and return a valid object key used for get treatment for a
+ * specific split.
+ */
+
+export default (function (key) {
+  if (isObject(key)) {
+    return {
+      matchingKey: key.matchingKey,
+      bucketingKey: key.bucketingKey
+    };
+  } else {
+    return {
+      matchingKey: key,
+      bucketingKey: key
+    };
+  }
+});

package/es/utils/labels/index.js

@@ -0,0 +1,7 @@
+export var SPLIT_KILLED = 'killed';
+export var NO_CONDITION_MATCH = 'default rule';
+export var SPLIT_NOT_FOUND = 'definition not found';
+export var SDK_NOT_READY = 'not ready';
+export var EXCEPTION = 'exception';
+export var SPLIT_ARCHIVED = 'archived';
+export var NOT_IN_SPLIT = 'not in split';

package/es/utils/lang/Errors.js

@@ -0,0 +1,41 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
+export var SplitError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(SplitError, _Error);
+
+  function SplitError(msg) {
+    var _this;
+
+    if (msg === void 0) {
+      msg = 'Split Error';
+    }
+
+    _this = _Error.call(this, msg) || this;
+    _this.message = msg;
+    return _this;
+  }
+
+  return SplitError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var SplitTimeoutError = /*#__PURE__*/function (_SplitError) {
+  _inheritsLoose(SplitTimeoutError, _SplitError);
+
+  function SplitTimeoutError(msg) {
+    return _SplitError.call(this, msg || 'Split Timeout Error') || this;
+  }
+
+  return SplitTimeoutError;
+}(SplitError);
+export var SplitNetworkError = /*#__PURE__*/function (_SplitError2) {
+  _inheritsLoose(SplitNetworkError, _SplitError2);
+
+  function SplitNetworkError(msg, code) {
+    var _this2;
+
+    _this2 = _SplitError2.call(this, msg || 'Split Network Error') || this;
+    _this2.statusCode = code;
+    return _this2;
+  }
+
+  return SplitNetworkError;
+}(SplitError);