@splitsoftware/splitio 10.17.2 → 10.17.3-rc.0

package/src/engine/parser/index.js

@@ -1,79 +0,0 @@
-/**
-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 matchersTransform from '../transforms/matchers';
-import treatmentsParser from '../treatments';
-import matcherFactory from '../matchers';
-import sanitizeValue from '../value';
-import conditionFactory from '../condition';
-import ifElseIfCombiner from '../combiners/ifelseif';
-import andCombiner from '../combiners/and';
-import thenable from '../../utils/promise/thenable';
-
-function parse(conditions, storage) {
-  let predicates = [];
-
-  for (let i = 0; i < conditions.length; i++) {
-    let {
-      matcherGroup: {
-        matchers
-      },
-      partitions,
-      label,
-      conditionType
-    } = conditions[i];
-
-    // transform data structure
-    matchers = matchersTransform(matchers);
-
-    // create a set of pure functions from the matcher's dto
-    const expressions = matchers.map(matcherDto => {
-      const matcher = matcherFactory(matcherDto, storage);
-
-      // Evaluator function.
-      return (key, attributes, splitEvaluator) => {
-        const value = sanitizeValue(key, matcherDto, attributes);
-        const result = value !== undefined ? matcher(value, splitEvaluator) : false;
-
-        if (thenable(result)) {
-          return result.then(res => Boolean(res ^ matcherDto.negate));
-        }
-        return Boolean(result ^ matcherDto.negate);
-      };
-    });
-
-    // if matcher's factory can't instanciate 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(conditionFactory(
-      andCombiner(expressions),
-      treatmentsParser.parse(partitions),
-      label,
-      conditionType
-    ));
-  }
-
-  // Instanciate evaluator given the set of conditions using if else if logic
-  return ifElseIfCombiner(predicates);
-}
-
-export default parse;

package/src/engine/parser/segments.js

@@ -1,31 +0,0 @@
-import { _Set } from '../../utils/lang/Sets';
-
-/**
- * Collect segments from a raw split definition.
- */
-const parseSegments = (conditions) => {
-  let segments = new _Set();
-
-  conditions.forEach(condition => {
-    let {
-      matcherGroup: {
-        matchers
-      }
-    } = condition;
-
-    matchers.forEach(matcher => {
-      const {
-        matcherType,
-        userDefinedSegmentMatcherData
-      } = matcher;
-
-      if (matcherType === 'IN_SEGMENT') {
-        segments.add(userDefinedSegmentMatcherData.segmentName);
-      }
-    });
-  });
-
-  return segments;
-};
-
-export default parseSegments;

package/src/engine/transforms/matcherGroup.js

@@ -1,45 +0,0 @@
-/**
-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 { matcherTypes, matcherTypesMapper } from '../matchers/types';
-import segmentTransform from './segment';
-import whitelistTransform from './whitelist';
-
-/**
- * Flat the complex matcherGroup structure into something handy.
- */
-function transform(matcherGroup) {
-  let {
-    matcherType,
-    userDefinedSegmentMatcherData: segmentObject,
-    whitelistMatcherData: whitelistObject
-  } = matcherGroup.matchers[0];
-
-  let type = matcherTypesMapper(matcherType);
-  let value = undefined;
-
-  if (type === matcherTypes.IN_SEGMENT) {
-    value = segmentTransform(segmentObject);
-  } else if (type === matcherTypes.WHITELIST) {
-    value = whitelistTransform(whitelistObject);
-  }
-
-  return {
-    type,
-    value
-  };
-}
-
-export default transform;

package/src/engine/transforms/matchers.js

@@ -1,118 +0,0 @@
-/**
-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 { findIndex } from '../../utils/lang';
-import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
-import segmentTransform from './segment';
-import whitelistTransform from './whitelist';
-import setTransform from './set';
-import numericTransform from './unaryNumeric';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
-
-// Flat the complex matcherGroup structure into something handy.
-function transform(matchers) {
-
-  let parsedMatchers = matchers.map(matcher => {
-    let {
-      matcherType                                   /* string */,
-      negate                                        /* boolean */,
-      keySelector                                   /* keySelectorObject */,
-      userDefinedSegmentMatcherData: segmentObject  /* segmentObject */,
-      whitelistMatcherData: whitelistObject         /* whiteListObject */,
-      unaryNumericMatcherData: unaryNumericObject   /* unaryNumericObject */,
-      betweenMatcherData: betweenObject             /* betweenObject */,
-      dependencyMatcherData: dependencyObject       /* dependencyObject */,
-      booleanMatcherData,
-      stringMatcherData
-    } = 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(segmentObject);
-    } else if (type === matcherTypes.WHITELIST) {
-      value = whitelistTransform(whitelistObject);
-    } else if (type === matcherTypes.EQUAL_TO) {
-      value = numericTransform(unaryNumericObject);
-      dataType = matcherDataTypes.NUMBER;
-
-      if (unaryNumericObject.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(unaryNumericObject);
-      dataType = matcherDataTypes.NUMBER;
-
-      if (unaryNumericObject.dataType === 'DATETIME') {
-        value = zeroSinceSS(value);
-        dataType = matcherDataTypes.DATETIME;
-      }
-    } else if (type === matcherTypes.BETWEEN) {
-      value = betweenObject;
-      dataType = matcherDataTypes.NUMBER;
-
-      if (betweenObject.dataType === 'DATETIME') {
-        value.start = zeroSinceSS(value.start);
-        value.end = zeroSinceSS(value.end);
-        dataType = matcherDataTypes.DATETIME;
-      }
-    } 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 = setTransform(whitelistObject);
-      dataType = matcherDataTypes.SET;
-    } else if (
-      type === matcherTypes.STARTS_WITH ||
-      type === matcherTypes.ENDS_WITH ||
-      type === matcherTypes.CONTAINS_STRING
-    ) {
-      value = setTransform(whitelistObject);
-    } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
-      value = dependencyObject;
-      dataType = matcherDataTypes.NOT_SPECIFIED;
-    } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
-      dataType = matcherDataTypes.BOOLEAN;
-      value = booleanMatcherData;
-    } else if (type === matcherTypes.MATCHES_STRING) {
-      value = stringMatcherData;
-    }
-
-    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
-      value,            // metadata used for the matching
-      dataType          // runtime input data type
-    };
-  });
-
-  if (findIndex(parsedMatchers, m => m.type === matcherTypes.UNDEFINED) === -1) {
-    return parsedMatchers;
-  } else {
-    return [];
-  }
-}
-
-export default transform;

package/src/engine/transforms/segment.js

@@ -1,23 +0,0 @@
-/**
-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.
-**/
-/**
- * Extract segment name as a plain string.
- */
-function transform(segment = {}) {
-  return segment.segmentName;
-}
-
-export default transform;

package/src/engine/transforms/set.js

@@ -1,20 +0,0 @@
-/**
-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.
-**/
-function transform(whitelistObject) {
-  return whitelistObject.whitelist;
-}
-
-export default transform;

package/src/engine/transforms/unaryNumeric.js

@@ -1,20 +0,0 @@
-/**
-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.
-**/
-function transform(unaryNumericObject) {
-  return unaryNumericObject.value;
-}
-
-export default transform;

package/src/engine/transforms/whitelist.js

@@ -1,22 +0,0 @@
-/**
-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 { _Set } from '../../utils/lang/Sets';
-
-function transform(whitelistObject) {
-  return new _Set(whitelistObject.whitelist);
-}
-
-export default transform;

package/src/engine/treatments/index.js

@@ -1,67 +0,0 @@
-/**
-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 { findIndex } from '../../utils/lang';
-
-function Treatments(ranges, treatments) {
-  if (!(this instanceof Treatments)) {
-    return new Treatments(ranges, treatments);
-  }
-
-  if (ranges[ranges.length - 1] !== 100) {
-    throw new RangeError('Provided invalid dataset as input');
-  }
-
-  this._ranges = ranges;
-  this._treatments = treatments;
-}
-
-Treatments.parse = function parse(data) {
-  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: []
-  });
-
-  return new Treatments(ranges, treatments);
-};
-
-Treatments.prototype.getTreatmentFor = function getTreatmentFor(x) {
-  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;
-};
-
-export default Treatments;

package/src/engine/value/index.js

@@ -1,53 +0,0 @@
-/**
-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 logFactory from '../../utils/logger';
-const log = logFactory('splitio-engine:value');
-import sanitizeValue from './sanitize';
-
-function parseValue(key, attributeName, attributes) {
-  let value = undefined;
-  if (attributeName) {
-    if (attributes) {
-      value = attributes[attributeName];
-      log.debug(`Extracted attribute [${attributeName}], [${value}] will be used for matching.`);
-    } else {
-      log.warn(`Defined attribute [${attributeName}], no attributes received.`);
-    }
-  } else {
-    value = key;
-  }
-
-  return value;
-}
-
-/**
- * Defines value to be matched (key / attribute).
- */
-function value(key, matcherDto, attributes) {
-  const attributeName = matcherDto.attribute;
-  const valueToMatch = parseValue(key, attributeName, attributes);
-  const sanitizedValue = sanitizeValue(matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
-
-  if (sanitizedValue !== undefined) {
-    return sanitizedValue;
-  } else {
-    log.warn(`Value ${valueToMatch} ${attributeName ? `for attribute ${attributeName} ` : + ''}doesn't match with expected type.`);
-    return;
-  }
-}
-
-export default value;

package/src/engine/value/sanitize.js

@@ -1,117 +0,0 @@
-/**
-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 logFactory from '../../utils/logger';
-const log = logFactory('splitio-engine:sanitize');
-import { isObject, uniq, toString, toNumber } from '../../utils/lang';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { matcherTypes, matcherDataTypes } from '../matchers/types';
-
-function sanitizeNumber(val) {
-  const num = toNumber(val);
-  return isNaN(num) ? undefined : num;
-}
-
-function sanitizeString(val) {
-  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) {
-  const arr = Array.isArray(val) ? uniq(val.map(e => e + '')) : [];
-  return arr.length ? arr : undefined;
-}
-
-function sanitizeBoolean(val) {
-  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, attributes) {
-  return {
-    key: sanitizedValue,
-    attributes
-  };
-}
-
-/**
- * We can define a pre-processing for the value, to be executed prior to matcher evaluation.
- */
-function getProcessingFunction(matcherTypeID, dataType) {
-  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:
-      return dependencyProcessor;
-    default:
-      return undefined;
-  }
-}
-
-function sanitizeValue(matcherTypeID, value, dataType, attributes) {
-  const processor = getProcessingFunction(matcherTypeID, dataType);
-  let sanitizedValue;
-
-  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;
-      break;
-    default:
-      sanitizedValue = undefined;
-  }
-
-  if (processor) {
-    sanitizedValue = processor(sanitizedValue, attributes);
-  }
-
-  log.debug(`Attempted to sanitize [${value}] which should be of type [${dataType}]. \n Sanitized and processed value => [${sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue}]`);
-
-  return sanitizedValue;
-}
-
-export default sanitizeValue;

package/src/events/index.js

@@ -1,62 +0,0 @@
-import logFactory from '../utils/logger';
-const log = logFactory('splitio-events');
-import tracker from '../utils/timeTracker';
-import repeat from '../utils/fn/repeat';
-import eventsService from '../services/events';
-import eventsBulkRequest from '../services/events/bulk';
-
-const EventsFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const storage = context.get(context.constants.STORAGE);
-
-  const pushEvents = () => {
-    if (storage.events.isEmpty()) return Promise.resolve();
-
-    log.info(`Pushing ${storage.events.state().length} queued events.`);
-    const latencyTrackerStop = tracker.start(tracker.TaskNames.EVENTS_PUSH);
-    const json = JSON.stringify(storage.events.toJSON());
-    const wrapUpCb = () => latencyTrackerStop();
-    storage.events.clear(); // we always clear the queue.
-
-    return eventsService(eventsBulkRequest(settings, {
-      body: json
-    })).then(wrapUpCb).catch(wrapUpCb);
-  };
-
-  let stopEventPublisherTimeout = false;
-  let stopEventsPublisher = false;
-  const startEventsPublisher = () =>
-    stopEventsPublisher = repeat(
-      schedulePublisher => pushEvents().then(() => schedulePublisher()),
-      settings.scheduler.eventsPushRate
-    );
-
-  return {
-    start() {
-      // On the browser there may be a wish to wait an specific amount of seconds before the first push.
-      if (settings.startup.eventsFirstPushWindow > 0) {
-        stopEventPublisherTimeout = setTimeout(startEventsPublisher, settings.startup.eventsFirstPushWindow);
-      } else {
-        startEventsPublisher();
-      }
-    },
-
-    flush() {
-      return pushEvents();
-    },
-
-    stop() {
-      stopEventPublisherTimeout && clearTimeout(stopEventPublisherTimeout);
-      stopEventsPublisher && stopEventsPublisher();
-    },
-
-    flushAndResetTimer() {
-      // Reset the timer and push the events.
-      log.info('Flushing events and reseting timer.');
-      stopEventsPublisher && stopEventsPublisher.reset();
-      return pushEvents();
-    }
-  };
-};
-
-export default EventsFactory;