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

package/src/utils/inputValidation/isOperational.js

@@ -0,0 +1,16 @@
+import logFactory from '../logger';
+const 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/src/utils/inputValidation/key.js

@@ -0,0 +1,53 @@
+import {
+  isObject, isString, numberIsFinite,
+  toString
+} from '../lang';
+import logFactory from '../logger';
+const log = logFactory('');
+
+const 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
+    const matchingKey = validateKeyValue(maybeKey.matchingKey, method, 'matchingKey');
+    const bucketingKey = validateKeyValue(maybeKey.bucketingKey, method, 'bucketingKey');
+
+    if (matchingKey && bucketingKey) return {
+      matchingKey, 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/src/utils/inputValidation/split.js

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

@@ -0,0 +1,108 @@
+import { STANDALONE_MODE, FILTERS_METADATA } from '../constants';
+import { validateSplits } from './splits';
+import logFactory from '../logger';
+const log = logFactory('splitio-settings');
+
+function validateFilterType(filterType) {
+  return FILTERS_METADATA.some(filterMetadata => 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
+  let 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) {
+  const queryParams = [];
+  FILTERS_METADATA.forEach(({ type, queryParam }) => {
+    const filter = groupedFilters[type];
+    if (filter.length > 0) queryParams.push(queryParam + filter.map(value => 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
+  const 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((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(({ type, 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/src/utils/inputValidation/splits.js

@@ -0,0 +1,21 @@
+import { uniq } from '../lang';
+import logFactory from '../logger';
+import { validateSplit } from './split';
+const log = logFactory('');
+
+export function validateSplits(maybeSplits, method, listName = 'split_names', item = 'split name') {
+  if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
+    let validatedArray = [];
+    // Remove invalid values
+    maybeSplits.forEach(maybeSplit => {
+      const 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/src/utils/inputValidation/trafficType.js

@@ -0,0 +1,58 @@
+import { isString } from '../lang';
+import thenable from '../promise/thenable';
+import { LOCALHOST_MODE } from '../constants';
+import logFactory from '../logger';
+const log = logFactory('');
+
+const 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) {
+  const isReady = context.get(context.constants.READY, true);
+  const settings = context.get(context.constants.SETTINGS);
+  const 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;
+
+  const 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/src/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/src/utils/jwt/index.js

@@ -0,0 +1,15 @@
+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/src/utils/key/factory.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 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 = false) {
+  return function getKeyProperty(key) {
+    if (isObject(key)) {
+      return key[keyProperty];
+    }
+
+    return undefinedIfNotObj ? undefined : key;
+  };
+}
+
+export const matching = KeyGetterFactory('matchingKey');
+export const bucketing = KeyGetterFactory('bucketingKey', true);

package/src/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 key => {
+  if (isObject(key)) {
+    return {
+      matchingKey: key.matchingKey,
+      bucketingKey: key.bucketingKey
+    };
+  } else {
+    return {
+      matchingKey: key,
+      bucketingKey: key
+    };
+  }
+};

package/src/utils/labels/index.js

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

package/src/utils/lang/Errors.js

@@ -0,0 +1,19 @@
+export class SplitError extends Error {
+  constructor(msg = 'Split Error') {
+    super(msg);
+    this.message = msg;
+  }
+}
+
+export class SplitTimeoutError extends SplitError {
+  constructor(msg) {
+    super(msg || 'Split Timeout Error');
+  }
+}
+
+export class SplitNetworkError extends SplitError {
+  constructor(msg, code) {
+    super(msg || 'Split Network Error');
+    this.statusCode = code;
+  }
+}

package/src/utils/lang/Sets.js

@@ -0,0 +1,94 @@
+/**
+ * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),
+ * with the minimal features used by the SDK.
+
+Copyright (C) 2013 Mariusz Nowak (www.medikoo.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+**/
+
+export class SetPoly {
+
+  // unlike ES6 `Set`, it only accepts an array as first argument iterable
+  constructor(/*arrayIterable*/) {
+    this.__setData__ = [];
+    const arrayIterable = arguments[0];
+    if (Array.isArray(arrayIterable)) arrayIterable.forEach(value => { this.add(value); });
+  }
+
+  clear() {
+    if (!this.__setData__.length) return;
+    this.__setData__.length = 0;
+  }
+
+  add(value) {
+    if (this.has(value)) return this;
+    this.__setData__.push(value);
+    return this;
+  }
+
+  delete(value) {
+    var index = this.__setData__.indexOf(value);
+    if (index === -1) return false;
+    this.__setData__.splice(index, 1);
+    return true;
+  }
+
+  has(value) {
+    return this.__setData__.indexOf(value) !== -1;
+  }
+
+  forEach(cb/*, thisArg*/) {
+    var thisArg = arguments[1];
+    if (typeof cb !== 'function') throw new TypeError(cb + ' is not a function');
+
+    for (let i = 0; i < this.__setData__.length; i++) {
+      const value = this.__setData__[i];
+      cb.call(thisArg, value, value, this);
+    }
+  }
+
+  get size() {
+    return this.__setData__.length;
+  }
+
+}
+
+export function setToArray(set) {
+  if (set instanceof SetPoly) {
+    return set.__setData__.slice();
+  }
+  // if not using SetPoly as set, it means Array.from is supported
+  // eslint-disable-next-line compat/compat
+  return Array.from(set);
+}
+
+/**
+ * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,
+ * a ponyfill with minimal features is returned instead.
+ */
+function getSetConstructor() {
+  // eslint-disable-next-line compat/compat
+  if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {
+    return Set;
+  }
+  return SetPoly;
+}
+
+export const _Set = getSetConstructor();