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

package/src/evaluator/matchers/semver_inlist.ts

@@ -1,16 +0,0 @@
-import { Semver } from '../../utils/Semver';
-
-export function inListSemverMatcherContext(ruleAttr: string[]) {
-  // @TODO ruleAttr validation should be done at the `parser` or `matchersTransform` level to reuse for all matchers
-  if (!ruleAttr || ruleAttr.length === 0) throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
-
-  const listOfSemvers = new Set(ruleAttr.map((version) => new Semver(version).version));
-
-  return function inListSemverMatcher(runtimeAttr: string): boolean {
-    const runtimeSemver = new Semver(runtimeAttr).version;
-
-    const isInList = listOfSemvers.has(runtimeSemver);
-
-    return isInList;
-  };
-}

package/src/evaluator/matchers/semver_lte.ts

@@ -1,13 +0,0 @@
-import { Semver } from '../../utils/Semver';
-
-export function lessThanEqualToSemverMatcherContext(ruleAttr: string) {
-  const ruleSemver = new Semver(ruleAttr);
-
-  return function lessThanEqualToSemverMatcher(runtimeAttr: string): boolean {
-    const runtimeSemver = new Semver(runtimeAttr);
-
-    const isLessThanEqual = runtimeSemver.compare(ruleSemver) <= 0;
-
-    return isLessThanEqual;
-  };
-}

package/src/evaluator/matchers/string.ts

@@ -1,9 +0,0 @@
-export function stringMatcherContext(ruleAttr: string) {
-  const regex = new RegExp(ruleAttr);
-
-  return function stringMatcher(runtimeAttr: string): boolean {
-    const regexMatches = regex.test(runtimeAttr);
-
-    return regexMatches;
-  };
-}

package/src/evaluator/matchers/sw.ts

@@ -1,9 +0,0 @@
-import { startsWith } from '../../utils/lang';
-
-export function startsWithMatcherContext(ruleAttr: string[]) {
-  return function startsWithMatcher(runtimeAttr: string): boolean {
-    const matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
-
-    return matches;
-  };
-}

package/src/evaluator/matchers/whitelist.ts

@@ -1,9 +0,0 @@
-export function whitelistMatcherContext(ruleAttr: string[]) {
-  const whitelistSet = new Set(ruleAttr);
-
-  return function whitelistMatcher(runtimeAttr: string): boolean {
-    const isInWhitelist = whitelistSet.has(runtimeAttr);
-
-    return isInWhitelist;
-  };
-}

package/src/evaluator/matchersTransform/index.ts

@@ -1,118 +0,0 @@
-import { findIndex } from '../../utils/lang';
-import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
-import { segmentTransform } from './segment';
-import { whitelistTransform } from './whitelist';
-import { numericTransform } from './unaryNumeric';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
-import { IMatcherDto } from '../types';
-
-/**
- * Flat the complex matcherGroup structure into something handy.
- */
-export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
-
-  let parsedMatchers = matchers.map(matcher => {
-    let {
-      matcherType,
-      negate,
-      keySelector,
-      userDefinedSegmentMatcherData,
-      userDefinedLargeSegmentMatcherData,
-      whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */
-      unaryNumericMatcherData,
-      betweenMatcherData,
-      dependencyMatcherData,
-      booleanMatcherData,
-      stringMatcherData,
-      betweenStringMatcherData
-    } = matcher;
-
-    let attribute = keySelector && keySelector.attribute;
-    let type = matcherTypesMapper(matcherType);
-    // As default input data type we use string (even for ALL_KEYS)
-    let dataType = matcherDataTypes.STRING;
-    let value = undefined;
-
-    if (type === matcherTypes.IN_SEGMENT) {
-      value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
-    } else if (type === matcherTypes.IN_LARGE_SEGMENT) {
-      value = segmentTransform(userDefinedLargeSegmentMatcherData as IInLargeSegmentMatcherData);
-    } else if (type === matcherTypes.EQUAL_TO) {
-      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
-      dataType = matcherDataTypes.NUMBER;
-
-      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).dataType === 'DATETIME') {
-        value = zeroSinceHH(value);
-        dataType = matcherDataTypes.DATETIME;
-      }
-    } else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
-      type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
-      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
-      dataType = matcherDataTypes.NUMBER;
-
-      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).dataType === 'DATETIME') {
-        value = zeroSinceSS(value);
-        dataType = matcherDataTypes.DATETIME;
-      }
-    } else if (type === matcherTypes.BETWEEN) {
-      value = betweenMatcherData as IBetweenMatcherData;
-      dataType = matcherDataTypes.NUMBER;
-
-      if (value.dataType === 'DATETIME') {
-        value.start = zeroSinceSS(value.start);
-        value.end = zeroSinceSS(value.end);
-        dataType = matcherDataTypes.DATETIME;
-      }
-    } else if (type === matcherTypes.BETWEEN_SEMVER) {
-      value = betweenStringMatcherData;
-    } else if (
-      type === matcherTypes.EQUAL_TO_SET ||
-      type === matcherTypes.CONTAINS_ANY_OF_SET ||
-      type === matcherTypes.CONTAINS_ALL_OF_SET ||
-      type === matcherTypes.PART_OF_SET
-    ) {
-      value = whitelistTransform(whitelistMatcherData);
-      dataType = matcherDataTypes.SET;
-    } else if (
-      type === matcherTypes.WHITELIST ||
-      type === matcherTypes.IN_LIST_SEMVER ||
-      type === matcherTypes.STARTS_WITH ||
-      type === matcherTypes.ENDS_WITH ||
-      type === matcherTypes.CONTAINS_STRING
-    ) {
-      value = whitelistTransform(whitelistMatcherData);
-    } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
-      value = dependencyMatcherData;
-      dataType = matcherDataTypes.NOT_SPECIFIED;
-    } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
-      dataType = matcherDataTypes.BOOLEAN;
-      value = booleanMatcherData;
-    } else if (
-      type === matcherTypes.MATCHES_STRING ||
-      type === matcherTypes.EQUAL_TO_SEMVER ||
-      type === matcherTypes.GREATER_THAN_OR_EQUAL_TO_SEMVER ||
-      type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER
-    ) {
-      value = stringMatcherData;
-    } else if (type === matcherTypes.IN_RULE_BASED_SEGMENT) {
-      value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
-      dataType = matcherDataTypes.NOT_SPECIFIED;
-    }
-
-    return {
-      attribute,        // attribute over we should do the matching, undefined means 'use the key'
-      negate,           // should we negate the result?
-      type,             // which kind of matcher we should evaluate
-      name: matcherType,// name of the matcher for logging purposes
-      value,            // metadata used for the matching
-      dataType          // runtime input data type
-    };
-  });
-
-  if (findIndex(parsedMatchers, m => m.type === matcherTypes.UNDEFINED) === -1) {
-    return parsedMatchers;
-  } else {
-    return [];
-  }
-}

package/src/evaluator/matchersTransform/segment.ts

@@ -1,10 +0,0 @@
-import { IInSegmentMatcherData, IInLargeSegmentMatcherData } from '../../dtos/types';
-
-/**
- * Extract segment name as a plain string.
- */
-export function segmentTransform(segment?: IInSegmentMatcherData | IInLargeSegmentMatcherData) {
-  return segment ?
-    (segment as IInSegmentMatcherData).segmentName || (segment as IInLargeSegmentMatcherData).largeSegmentName :
-    undefined;
-}

package/src/evaluator/matchersTransform/unaryNumeric.ts

@@ -1,8 +0,0 @@
-import { IUnaryNumericMatcherData } from '../../dtos/types';
-
-/**
- * Extract value from unary matcher data.
- */
-export function numericTransform(unaryNumericObject: IUnaryNumericMatcherData) {
-  return unaryNumericObject.value;
-}

package/src/evaluator/matchersTransform/whitelist.ts

@@ -1,8 +0,0 @@
-import { ISplitMatcher } from '../../dtos/types';
-
-/**
- * Extract whitelist array.
- */
-export function whitelistTransform(whitelistObject: ISplitMatcher['whitelistMatcherData']) {
-  return whitelistObject && whitelistObject.whitelist;
-}

package/src/evaluator/parser/index.ts

@@ -1,82 +0,0 @@
-import { matchersTransform } from '../matchersTransform';
-import { Treatments } from '../treatments';
-import { matcherFactory } from '../matchers';
-import { sanitizeValue } from '../value';
-import { conditionContext } from '../condition';
-import { ifElseIfCombinerContext } from '../combiners/ifelseif';
-import { andCombinerContext } from '../combiners/and';
-import { thenable } from '../../utils/promise/thenable';
-import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
-import { ISplitCondition, MaybeThenable } from '../../dtos/types';
-import { IStorageAsync, IStorageSync } from '../../storages/types';
-import SplitIO from '../../../types/splitio';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_ERROR, ENGINE_MATCHER_RESULT } from '../../logger/constants';
-
-export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
-  let predicates = [];
-
-  for (let i = 0; i < conditions.length; i++) {
-    let {
-      matcherGroup,
-      partitions,
-      label,
-      conditionType
-    } = conditions[i];
-
-    // transform data structure
-    const matchers = matchersTransform(matcherGroup.matchers);
-
-    // create a set of pure functions from the matcher's dto
-    const expressions = matchers.map((matcherDto: IMatcherDto) => {
-      let matcher: ReturnType<typeof matcherFactory>;
-      try {
-        matcher = matcherFactory(log, matcherDto, storage);
-      } catch (error) {
-        log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
-      }
-
-      // Evaluator function.
-      return (key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => {
-        const value = sanitizeValue(log, key, matcherDto, attributes);
-        let result: MaybeThenable<boolean> = false;
-
-        if (value !== undefined && matcher) {
-          try {
-            result = matcher(value, splitEvaluator);
-          } catch (error) {
-            log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
-          }
-        }
-
-        function handleResult(result: boolean) {
-          log.debug(ENGINE_MATCHER_RESULT, [matcherDto.name, result, matcherDto.value, value]); // @ts-ignore
-          return Boolean(result ^ matcherDto.negate);
-        }
-
-        return thenable(result) ?
-          result.then(handleResult) :
-          handleResult(result);
-      };
-    });
-
-    // if matcher's factory can't instantiate the matchers, the expressions array will be empty
-    if (expressions.length === 0) {
-      // reset any data collected during parsing
-      predicates = [];
-      // and break the loop
-      break;
-    }
-
-    predicates.push(conditionContext(
-      log,
-      andCombinerContext(log, expressions),
-      partitions && Treatments.parse(partitions),
-      label,
-      conditionType
-    ));
-  }
-
-  // Instantiate evaluator given the set of conditions using if else if logic
-  return ifElseIfCombinerContext(log, predicates);
-}

package/src/evaluator/treatments/index.ts

@@ -1,53 +0,0 @@
-import { ISplitPartition } from '../../dtos/types';
-import { findIndex } from '../../utils/lang';
-
-export class Treatments {
-
-  private _ranges: number[];
-  private _treatments: string[];
-
-  constructor(ranges: number[], treatments: string[]) {
-    if (ranges[ranges.length - 1] !== 100) {
-      throw new RangeError('Provided invalid dataset as input');
-    }
-
-    this._ranges = ranges;
-    this._treatments = treatments;
-  }
-
-  static parse(data: ISplitPartition[]) {
-    let { ranges, treatments } = data.reduce((accum, value) => {
-      let { size, treatment } = value;
-
-      accum.ranges.push(accum.inc += size);
-      accum.treatments.push(treatment);
-
-      return accum;
-    }, {
-      inc: 0,
-      ranges: [],
-      treatments: []
-    } as { inc: number, ranges: number[], treatments: string[] });
-
-    return new Treatments(ranges, treatments);
-  }
-
-  getTreatmentFor(x: number): string {
-    if (x < 0 || x > 100) {
-      throw new RangeError('Please provide a value between 0 and 100');
-    }
-
-    // Readme [1]
-    // We need to manually add any dependency which escape of dummy resolution
-    // I'll deal with this in a future release
-    // for (let [k, r] of this._ranges.entries()) {
-    //   if (x <= r) return this._treatments[k];
-    // }
-
-    const index = findIndex(this._ranges, range => x <= range);
-    const treatment = this._treatments[index];
-
-    return treatment;
-  }
-
-}

package/src/evaluator/types.ts

@@ -1,34 +0,0 @@
-import { IBetweenMatcherData, IBetweenStringMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import SplitIO from '../../types/splitio';
-import { ILogger } from '../logger/types';
-
-export interface IDependencyMatcherValue {
-  key: SplitIO.SplitKey,
-  attributes?: SplitIO.Attributes
-}
-
-export interface IMatcherDto {
-  type: number
-  name: string
-  value?: string | number | boolean | string[] | IDependencyMatcherData | IBetweenMatcherData | IBetweenStringMatcherData | null
-
-  attribute: string | null
-  negate: boolean
-  dataType: string
-}
-
-export interface IEvaluation {
-  treatment?: string,
-  label: string,
-  changeNumber?: number,
-  config?: string | null
-}
-
-export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
-
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
-
-export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
-
-export type IMatcher = (value: string | number | boolean | string[] | IDependencyMatcherValue, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -1,37 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { IMatcherDto } from '../types';
-import { ILogger } from '../../logger/types';
-import { sanitize } from './sanitize';
-import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
-
-function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName: string | null, attributes?: SplitIO.Attributes) {
-  let value = undefined;
-  if (attributeName) {
-    if (attributes) {
-      value = attributes[attributeName];
-      log.debug(ENGINE_VALUE, [attributeName, value]);
-    } else {
-      log.warn(ENGINE_VALUE_NO_ATTRIBUTES, [attributeName]);
-    }
-  } else {
-    value = key;
-  }
-
-  return value;
-}
-
-/**
- * Defines value to be matched (key / attribute).
- */
-export function sanitizeValue(log: ILogger, key: SplitIO.SplitKey, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
-  const attributeName = matcherDto.attribute;
-  const valueToMatch = parseValue(log, key, attributeName, attributes);
-  const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
-
-  if (sanitizedValue !== undefined) {
-    return sanitizedValue;
-  } else {
-    log.warn(ENGINE_VALUE_INVALID, [valueToMatch + (attributeName ? ' for attribute ' + attributeName : '')]);
-    return;
-  }
-}

package/src/evaluator/value/sanitize.ts

@@ -1,106 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { IDependencyMatcherValue } from '../types';
-import { ILogger } from '../../logger/types';
-import { isObject, uniq, toString, toNumber } from '../../utils/lang';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';
-import { ENGINE_SANITIZE } from '../../logger/constants';
-
-function sanitizeNumber(val: any): number | undefined {
-  const num = toNumber(val);
-  return isNaN(num) ? undefined : num;
-}
-
-function sanitizeString(val: any): string | undefined {
-  let valueToSanitize = val;
-
-  if (isObject(val)) {
-    // If the value is an object and is not a key, discard it.
-    valueToSanitize = val.matchingKey ? val.matchingKey : undefined;
-  }
-
-  const str = toString(valueToSanitize);
-  return str ? str : undefined;
-}
-
-function sanitizeArray(val: any): string[] | undefined {
-  const arr = Array.isArray(val) ? uniq(val.map(e => e + '')) : [];
-  return arr.length ? arr : undefined;
-}
-
-function sanitizeBoolean(val: any): boolean | undefined {
-  if (val === true || val === false) return val;
-
-  if (typeof val === 'string') {
-    const lowerCaseValue = val.toLocaleLowerCase();
-
-    if (lowerCaseValue === 'true') return true;
-    if (lowerCaseValue === 'false') return false;
-  }
-
-  return undefined;
-}
-
-function dependencyProcessor(sanitizedValue: SplitIO.SplitKey, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
-  return {
-    key: sanitizedValue,
-    attributes
-  };
-}
-
-/**
- * We can define a pre-processing for the value, to be executed prior to matcher evaluation.
- */
-function getProcessingFunction(matcherTypeID: number, dataType: string) {
-  switch (matcherTypeID) {
-    case matcherTypes.EQUAL_TO:
-      return dataType === 'DATETIME' ? zeroSinceHH : undefined;
-    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
-    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
-    case matcherTypes.BETWEEN:
-      return dataType === 'DATETIME' ? zeroSinceSS : undefined;
-    case matcherTypes.IN_SPLIT_TREATMENT:
-    case matcherTypes.IN_RULE_BASED_SEGMENT:
-      return dependencyProcessor;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Sanitize matcher value
- */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | SplitIO.SplitKey | undefined, dataType: string, attributes?: SplitIO.Attributes) {
-  const processor = getProcessingFunction(matcherTypeID, dataType);
-  let sanitizedValue: string | number | boolean | Array<string> | IDependencyMatcherValue | undefined;
-
-  switch (dataType) {
-    case matcherDataTypes.NUMBER:
-    case matcherDataTypes.DATETIME:
-      sanitizedValue = sanitizeNumber(value);
-      break;
-    case matcherDataTypes.STRING:
-      sanitizedValue = sanitizeString(value);
-      break;
-    case matcherDataTypes.SET:
-      sanitizedValue = sanitizeArray(value);
-      break;
-    case matcherDataTypes.BOOLEAN:
-      sanitizedValue = sanitizeBoolean(value);
-      break;
-    case matcherDataTypes.NOT_SPECIFIED:
-      sanitizedValue = value as any;
-      break;
-    default:
-      sanitizedValue = undefined;
-  }
-
-  if (processor) {
-    // @ts-ignore
-    sanitizedValue = processor(sanitizedValue, attributes);
-  }
-
-  log.debug(ENGINE_SANITIZE, [value, dataType, sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue]);
-
-  return sanitizedValue;
-}

package/src/index.ts

@@ -1,14 +0,0 @@
-// InMemory storage factory for standalone server-side SplitFactory
-export { InMemoryStorageFactory } from './storages/inMemory/InMemoryStorage';
-
-// InMemory storage factory for standalone client-side SplitFactory
-export { InMemoryStorageCSFactory } from './storages/inMemory/InMemoryStorageCS';
-
-// InLocalStorage factory for standalone client-side SplitFactory in Web browsers
-export { InLocalStorage } from './storages/inLocalStorage';
-
-// Pluggable storage factory for consumer/producer mode
-export { PluggableStorage } from './storages/pluggable';
-
-// Pluggable storage factory for consumer/producer mode
-export { InRedisStorage } from './storages/inRedis';

package/src/integrations/pluggable.ts

@@ -1,39 +0,0 @@
-import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';
-import SplitIO from '../../types/splitio';
-import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './types';
-
-/**
- * Factory function for IntegrationsManager with pluggable integrations.
- * The integrations manager instantiates integration, and bypass tracked events and impressions to them.
- *
- * @param integrations - validated list of integration factories
- * @param params - information of the Sdk factory instance that integrations can access to
- *
- * @returns integration manager or undefined if `integrations` are not present in settings.
- */
-export function pluggableIntegrationsManagerFactory(
-  integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>,
-  params: IIntegrationFactoryParams
-): IIntegrationManager | undefined {
-
-  const listeners: IIntegration[] = [];
-
-  // No need to check if `settings.integrations` is an array of functions. It was already validated
-  integrations.forEach(integrationFactory => {
-    let integration = integrationFactory(params);
-    if (integration && integration.queue) listeners.push(integration);
-  });
-
-  // If `listeners` is empty, not return a integration manager
-  if (listeners.length === 0) return;
-
-  // Exception safe methods: each integration module is responsable for handling errors
-  return {
-    handleImpression(impressionData: SplitIO.ImpressionData) {
-      listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
-    },
-    handleEvent(eventData: SplitIO.EventData) {
-      listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
-    }
-  };
-}

package/src/integrations/types.ts

@@ -1,21 +0,0 @@
-import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-
-export interface IIntegration {
-  queue(data: SplitIO.IntegrationData): void
-}
-
-export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
-
-export interface IIntegrationFactoryParams {
-  storage: { events: IEventsCacheBase }
-  settings: ISettings
-  telemetryTracker: ITelemetryTracker
-}
-
-export type IntegrationFactory = SplitIO.IntegrationFactory & {
-  readonly type: string
-  (params: IIntegrationFactoryParams): IIntegration | void
-}