@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/utils/inputValidation/isOperational.ts

@@ -1,17 +0,0 @@
-import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { IReadinessManager } from '../../readiness/types';
-
-export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadinessManager, method: string): boolean {
-  if (!readinessManager.isDestroyed()) return true;
-
-  log.error(ERROR_CLIENT_DESTROYED, [method]);
-  return false;
-}
-
-export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
-  if (readinessManager.isReady() || readinessManager.isReadyFromCache()) return true;
-
-  log.warn(CLIENT_NOT_READY, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
-  return false;
-}

package/src/utils/inputValidation/key.ts

@@ -1,51 +0,0 @@
-import { isObject, isString, isFiniteNumber, toString } from '../lang';
-import SplitIO from '../../../types/splitio';
-import { ILogger } from '../../logger/types';
-import { ERROR_NULL, WARN_CONVERTING, ERROR_EMPTY, ERROR_TOO_LONG, ERROR_INVALID, ERROR_INVALID_KEY_OBJECT } from '../../logger/constants';
-
-const KEY_MAX_LENGTH = 250;
-
-function validateKeyValue(log: ILogger, maybeKey: any, method: string, type: string): string | false {
-  if (maybeKey == undefined) { // eslint-disable-line eqeqeq
-    log.error(ERROR_NULL, [method, type]);
-    return false;
-  }
-  if (isFiniteNumber(maybeKey)) {
-    log.warn(WARN_CONVERTING, [method, type, maybeKey]);
-    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(ERROR_EMPTY, [method, type]);
-    } else if (maybeKey.length > KEY_MAX_LENGTH) {
-      log.error(ERROR_TOO_LONG, [method, type]);
-    }
-  } else {
-    log.error(ERROR_INVALID, [method, type]);
-  }
-
-  return false;
-}
-
-export function validateKey(log: ILogger, maybeKey: any, method: string): SplitIO.SplitKey | false {
-  if (isObject(maybeKey)) {
-    // Validate key object
-    const matchingKey = validateKeyValue(log, maybeKey.matchingKey, method, 'matchingKey');
-    const bucketingKey = validateKeyValue(log, maybeKey.bucketingKey, method, 'bucketingKey');
-
-    if (matchingKey && bucketingKey) return {
-      matchingKey, bucketingKey
-    };
-
-    log.error(ERROR_INVALID_KEY_OBJECT, [method]);
-    return false;
-  } else {
-    return validateKeyValue(log, maybeKey, method, 'key');
-  }
-}

package/src/utils/inputValidation/preloadedData.ts

@@ -1,57 +0,0 @@
-import { isObject, isString, isFiniteNumber } from '../lang';
-import { validateSplit } from './split';
-import { ILogger } from '../../logger/types';
-
-function validateTimestampData(log: ILogger, maybeTimestamp: any, method: string, item: string) {
-  if (isFiniteNumber(maybeTimestamp) && maybeTimestamp > -1) return true;
-  log.error(`${method}: preloadedData.${item} must be a positive number.`);
-  return false;
-}
-
-function validateSplitsData(log: ILogger, maybeSplitsData: any, method: string) {
-  if (isObject(maybeSplitsData)) {
-    const splitNames = Object.keys(maybeSplitsData);
-    if (splitNames.length === 0) log.warn(`${method}: preloadedData.splitsData doesn't contain feature flag definitions.`);
-    // @TODO in the future, consider handling the possibility of having parsed definitions of splits
-    if (splitNames.every(splitName => validateSplit(log, splitName, method) && isString(maybeSplitsData[splitName]))) return true;
-  }
-  log.error(`${method}: preloadedData.splitsData must be a map of feature flag names to their stringified definitions.`);
-  return false;
-}
-
-function validateMySegmentsData(log: ILogger, maybeMySegmentsData: any, method: string) {
-  if (isObject(maybeMySegmentsData)) {
-    const userKeys = Object.keys(maybeMySegmentsData);
-    if (userKeys.every(userKey => {
-      const segmentNames = maybeMySegmentsData[userKey];
-      // an empty list is valid
-      return Array.isArray(segmentNames) && segmentNames.every(segmentName => isString(segmentName));
-    })) return true;
-  }
-  log.error(`${method}: preloadedData.mySegmentsData must be a map of user keys to their list of segment names.`);
-  return false;
-}
-
-function validateSegmentsData(log: ILogger, maybeSegmentsData: any, method: string) {
-  if (isObject(maybeSegmentsData)) {
-    const segmentNames = Object.keys(maybeSegmentsData);
-    if (segmentNames.every(segmentName => isString(maybeSegmentsData[segmentName]))) return true;
-  }
-  log.error(`${method}: preloadedData.segmentsData must be a map of segment names to their stringified definitions.`);
-  return false;
-}
-
-export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string) {
-  if (!isObject(maybePreloadedData)) {
-    log.error(`${method}: preloadedData must be an object.`);
-  } else if (
-    validateTimestampData(log, maybePreloadedData.lastUpdated, method, 'lastUpdated') &&
-    validateTimestampData(log, maybePreloadedData.since, method, 'since') &&
-    validateSplitsData(log, maybePreloadedData.splitsData, method) &&
-    (!maybePreloadedData.mySegmentsData || validateMySegmentsData(log, maybePreloadedData.mySegmentsData, method)) &&
-    (!maybePreloadedData.segmentsData || validateSegmentsData(log, maybePreloadedData.segmentsData, method))
-  ) {
-    return true;
-  }
-  return false;
-}

package/src/utils/inputValidation/split.ts

@@ -1,27 +0,0 @@
-import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { isString } from '../lang';
-
-// include BOM and nbsp
-const TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-
-export function validateSplit(log: ILogger, maybeSplit: any, method: string, item = 'feature flag name'): string | false {
-  if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
-    log.error(ERROR_NULL, [method, item]);
-  } else if (!isString(maybeSplit)) {
-    log.error(ERROR_INVALID, [method, item]);
-  } else {
-    if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
-      log.warn(WARN_TRIMMING, [method, item, maybeSplit]);
-      maybeSplit = maybeSplit.trim();
-    }
-
-    if (maybeSplit.length > 0) {
-      return maybeSplit;
-    } else {
-      log.error(ERROR_EMPTY, [method, item]);
-    }
-  }
-
-  return false;
-}

package/src/utils/inputValidation/splitExistence.ts

@@ -1,19 +0,0 @@
-import { SPLIT_NOT_FOUND } from '../labels';
-import { IReadinessManager } from '../../readiness/types';
-import { ILogger } from '../../logger/types';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
-
-/**
- * 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 validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
-  if (readinessManager.isReady()) { // 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(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/utils/inputValidation/splits.ts

@@ -1,21 +0,0 @@
-import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { uniq } from '../lang';
-import { validateSplit } from './split';
-
-export function validateSplits(log: ILogger, maybeSplits: any, method: string, listName = 'feature flag names', item = 'feature flag name'): string[] | false {
-  if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-    let validatedArray: string[] = [];
-    // Remove invalid values
-    maybeSplits.forEach(maybeSplit => {
-      const splitName = validateSplit(log, 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(ERROR_EMPTY_ARRAY, [method, listName]);
-  return false;
-}

package/src/utils/inputValidation/trafficType.ts

@@ -1,27 +0,0 @@
-import { ERROR_NULL, ERROR_INVALID, ERROR_EMPTY, WARN_LOWERCASE_TRAFFIC_TYPE } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { isString } from '../lang';
-
-const CAPITAL_LETTERS_REGEX = /[A-Z]/;
-const item = 'traffic_type';
-
-export function validateTrafficType(log: ILogger, maybeTT: any, method: string): string | false {
-  if (maybeTT == undefined) { // eslint-disable-line eqeqeq
-    log.error(ERROR_NULL, [method, item]);
-  } else if (!isString(maybeTT)) {
-    log.error(ERROR_INVALID, [method, item]);
-  } else {
-    if (maybeTT.length === 0) {
-      log.error(ERROR_EMPTY, [method, item]);
-    } else {
-      if (CAPITAL_LETTERS_REGEX.test(maybeTT)) {
-        log.warn(WARN_LOWERCASE_TRAFFIC_TYPE, [method]);
-        maybeTT = maybeTT.toLowerCase();
-      }
-
-      return maybeTT;
-    }
-  }
-
-  return false;
-}

package/src/utils/inputValidation/trafficTypeExistence.ts

@@ -1,33 +0,0 @@
-import { thenable } from '../promise/thenable';
-import { LOCALHOST_MODE } from '../constants';
-import { ISplitsCacheBase } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
-import SplitIO from '../../../types/splitio';
-import { MaybeThenable } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
-import { WARN_NOT_EXISTENT_TT } from '../../logger/constants';
-
-function logTTExistenceWarning(log: ILogger, maybeTT: string, method: string) {
-  log.warn(WARN_NOT_EXISTENT_TT, [method, maybeTT]);
-}
-
-/**
- * Separated from the previous method since on some cases it'll be async.
- */
-export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
-
-  // If not ready or in localhost mode, we won't run the validation
-  if (!readinessManager.isReady() || mode === LOCALHOST_MODE) return true;
-
-  const res = splitsCache.trafficTypeExists(maybeTT); // never rejects or throws error
-
-  if (thenable(res)) {
-    return res.then(function (isValid) {
-      if (!isValid) logTTExistenceWarning(log, maybeTT, method);
-      return isValid; // propagate result
-    });
-  } else {
-    if (!res) logTTExistenceWarning(log, maybeTT, method);
-    return res;
-  }
-}

package/src/utils/jwt/index.ts

@@ -1,16 +0,0 @@
-import { decodeFromBase64 } from '../base64';
-import { IDecodedJWTToken } from './types';
-
-/**
- * Decode a JWT token.
- */
-export function decodeJWTtoken(token: string): IDecodedJWTToken {
-  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/jwt/types.ts

@@ -1,10 +0,0 @@
-export interface IDecodedJWTToken {
-  ['x-ably-capability']: string
-  exp: number
-  iat: number
-
-  /** Unused fields: */
-  // orgId?: string,
-  // envId?: string,
-  // ['x-ably-clientId']?: string,
-}

package/src/utils/key/index.ts

@@ -1,34 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { isObject } from '../lang';
-
-// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
-//   return key !== undefined && key !== null && typeof key.matchingKey === 'string';
-// }
-
-// returns the matchingKey if the Key is defined as an object or the key itself if it is a string
-export function getMatching(key: SplitIO.SplitKey): string {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).matchingKey : key as string;
-}
-
-// if the key is a string, there's no bucketingKey (undefined)
-export function getBucketing(key: SplitIO.SplitKey): string | undefined {
-  return isObject(key) ? (key as SplitIO.SplitKeyObject).bucketingKey : undefined;
-}
-
-/**
- * Verify type of key and return a valid object key used for get treatment for a
- * specific split.
- */
-export function keyParser(key: SplitIO.SplitKey): SplitIO.SplitKeyObject {
-  if (isObject(key)) {
-    return {
-      matchingKey: (key as SplitIO.SplitKeyObject).matchingKey,
-      bucketingKey: (key as SplitIO.SplitKeyObject).bucketingKey
-    };
-  } else {
-    return {
-      matchingKey: key as string,
-      bucketingKey: key as string
-    };
-  }
-}

package/src/utils/labels/index.ts

@@ -1,9 +0,0 @@
-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';
-export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
-export const PREREQUISITES_NOT_MET = 'prerequisites not met';

package/src/utils/lang/binarySearch.ts

@@ -1,41 +0,0 @@
-/**
- * Searches the index of the specified `value` inside an ordered array of `items` using the binary search algorithm.
- *
- * @param items - the array to be searched
- * @param value - the value to be searched for
- * @returns integer number between 0 and `items.length`. This value is the index of the search value,
- * if it is contained in the array, or the index at which the value should be inserted to keep the array ordered.
- */
-export function binarySearch(items: number[], value: number): number {
-  let startIndex = 0;
-  let stopIndex = items.length - 1;
-  let middle = Math.floor((stopIndex + startIndex) / 2);
-  let minIndex = startIndex;
-  let maxIndex = stopIndex;
-
-  while (items[middle] !== value && startIndex < stopIndex) {
-    // adjust search area
-    if (value < items[middle]) {
-      stopIndex = middle - 1;
-    } else if (value > items[middle]) {
-      startIndex = middle + 1;
-    }
-
-    // recalculate middle
-    middle = Math.floor((stopIndex + startIndex) / 2);
-  }
-
-  // correct if middle is out of range
-  if (middle < minIndex) {
-    middle = minIndex;
-  } else if (middle > maxIndex) {
-    middle = maxIndex;
-  }
-
-  // we want to always return based on strict minor comparation
-  if (value < items[middle] && middle > minIndex) {
-    return middle - 1;
-  }
-
-  return middle;
-}

package/src/utils/lang/getFnName.ts

@@ -1,8 +0,0 @@
-/**
- * Returns the name of a given function.
- */
-export function getFnName(fn: any): string {
-  if (fn.name) return fn.name;
-
-  return (fn.toString().match(/function (.+?)\(/) || ['', ''])[1];
-}

package/src/utils/lang/getGlobal.ts

@@ -1,17 +0,0 @@
-/* eslint-disable no-undef */
-
-// Reference to the global object if it exists: https://github.com/tc39/proposal-global
-// The only reliable means to get the global object is `Function('return this')()`. However, this causes CSP violations in Chrome apps.
-const globalRef =
-  typeof global !== 'undefined' ? global : // reference to global object in Node runtime environment
-    typeof window !== 'undefined' ? window : // reference to global object in browsers
-      typeof self !== 'undefined' ? self : // reference to global object in browsers, web workers and others
-        typeof globalThis !== 'undefined' ? globalThis : undefined; // ECMAScript proposal for global reference
-
-/**
- * Get a global object passing its key
- */
-export function getGlobal(key: string): object | undefined {
-  // @ts-ignore
-  return globalRef && globalRef[key];
-}