craft-ai/lib/interpreter_v1.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.decide = exports.reduceDecisionRules = exports.formatProperty = exports.formatDecisionRules = undefined;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _reducer = require('./reducer');

var _time = require('./time');

var _errors = require('./errors');

var _formatter = require('./formatter');

var _timezones = require('./timezones');

var _timezones2 = _interopRequireDefault(_timezones);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var DECISION_FORMAT_VERSION = '1.1.0';

var OPERATORS = {
  'is': function is(context, value) {
    return context === value;
  },
  '>=': function _(context, value) {
    return context * 1 >= value;
  },
  '<': function _(context, value) {
    return context * 1 < value;
  },
  '[in[': function _in(context, value) {
    var context_val = context * 1;
    var from = value[0];
    var to = value[1];
    //the interval is not looping
    if (from < to) {
      return context_val >= from && context_val < to;
    }
    //the interval IS looping
    else {
        return context_val >= from || context_val < to;
      }
  }
};

var VALUE_VALIDATOR = {
  continuous: function continuous(value) {
    return _lodash2.default.isFinite(value);
  },
  enum: function _enum(value) {
    return _lodash2.default.isString(value);
  },
  timezone: function timezone(value) {
    return (0, _timezones2.default)(value);
  },
  time_of_day: function time_of_day(value) {
    return _lodash2.default.isFinite(value) && value >= 0 && value < 24;
  },
  day_of_week: function day_of_week(value) {
    return _lodash2.default.isInteger(value) && value >= 0 && value <= 6;
  },
  day_of_month: function day_of_month(value) {
    return _lodash2.default.isInteger(value) && value >= 1 && value <= 31;
  },
  month_of_year: function month_of_year(value) {
    return _lodash2.default.isInteger(value) && value >= 1 && value <= 12;
  }
};

function decideRecursion(node, context) {
  // Leaf
  if (!(node.children && node.children.length)) {
    if (node.predicted_value == null) {
      return {
        predicted_value: undefined,
        confidence: undefined,
        decision_rules: [],
        error: {
          name: 'CraftAiNullDecisionError',
          message: 'Unable to take decision: the decision tree has no valid predicted value for the given context.'
        }
      };
    }

    var leafNode = {
      predicted_value: node.predicted_value,
      confidence: node.confidence || 0,
      decision_rules: []
    };

    if (!_lodash2.default.isUndefined(node.standard_deviation)) {
      leafNode.standard_deviation = node.standard_deviation;
    }

    return leafNode;
  }

  // Regular node
  var matchingChild = _lodash2.default.find(node.children, function (child) {
    var decision_rule = child.decision_rule;
    var property = decision_rule.property;
    if (_lodash2.default.isUndefined(context[property])) {
      // Should not happen
      return {
        predicted_value: undefined,
        confidence: undefined,
        error: {
          name: 'CraftAiUnknownError',
          message: 'Unable to take decision: property \'' + property + '\' is missing from the given context.'
        }
      };
    }

    return OPERATORS[decision_rule.operator](context[property], decision_rule.operand);
  });

  // matching child property error
  if (matchingChild && matchingChild.error) {
    return matchingChild;
  }

  if (_lodash2.default.isUndefined(matchingChild)) {
    // Should only happens when an unexpected value for an enum is encountered
    var operandList = _lodash2.default.uniq(_lodash2.default.map(_lodash2.default.values(node.children), function (child) {
      return child.decision_rule.operand;
    }));
    var property = _lodash2.default.head(node.children).decision_rule.property;
    return {
      predicted_value: undefined,
      confidence: undefined,
      decision_rules: [],
      error: {
        name: 'CraftAiNullDecisionError',
        message: 'Unable to take decision: value \'' + context[property] + '\' for property \'' + property + '\' doesn\'t validate any of the decision rules.',
        metadata: {
          property: property,
          value: context[property],
          expected_values: operandList
        }
      }
    };
  }

  // matching child found: recurse !
  var result = decideRecursion(matchingChild, context);

  var finalResult = _lodash2.default.extend(result, {
    decision_rules: [matchingChild.decision_rule].concat(result.decision_rules)
  });

  return finalResult;
}

function checkContext(configuration) {
  // Extract the required properties (i.e. those that are not the output)
  var expectedProperties = _lodash2.default.difference(_lodash2.default.keys(configuration.context), configuration.output);

  // Build a context validator
  var validators = _lodash2.default.map(expectedProperties, function (property) {
    var otherValidator = function otherValidator() {
      console.warn('WARNING: "' + configuration.context[property].type + '" is not a supported type. Please refer to the documention to see what type you can use');
      return true;
    };
    return {
      property: property,
      type: configuration.context[property].type,
      validator: VALUE_VALIDATOR[configuration.context[property].type] || otherValidator
    };
  });

  return function (context) {
    var _$reduce = _lodash2.default.reduce(validators, function (_ref, _ref2) {
      var badProperties = _ref.badProperties,
          missingProperties = _ref.missingProperties;
      var property = _ref2.property,
          type = _ref2.type,
          validator = _ref2.validator;

      var value = context[property];
      if (value === undefined) {
        missingProperties.push(property);
      } else if (!validator(value)) {
        badProperties.push({ property: property, type: type, value: value });
      }
      return { badProperties: badProperties, missingProperties: missingProperties };
    }, { badProperties: [], missingProperties: [] }),
        badProperties = _$reduce.badProperties,
        missingProperties = _$reduce.missingProperties;

    if (missingProperties.length || badProperties.length) {
      var messages = _lodash2.default.concat(_lodash2.default.map(missingProperties, function (property) {
        return 'expected property \'' + property + '\' is not defined';
      }), _lodash2.default.map(badProperties, function (_ref3) {
        var property = _ref3.property,
            type = _ref3.type,
            value = _ref3.value;
        return '\'' + value + '\' is not a valid value for property \'' + property + '\' of type \'' + type + '\'';
      }));
      throw new _errors.CraftAiDecisionError({
        message: 'Unable to take decision, the given context is not valid: ' + messages.join(', ') + '.',
        metadata: _lodash2.default.assign({}, missingProperties.length && { missingProperties: missingProperties }, badProperties.length && { badProperties: badProperties })
      });
    }
  };
}

function decide(configuration, trees, context) {
  checkContext(configuration)(context);
  // Convert timezones as integers to the standard +/-hh:mm format
  // This should only happen when no Time() object is passed to the interpreter
  var timezoneProperty = (0, _timezones.getTimezoneKey)(configuration.context);
  if (!_lodash2.default.isUndefined(timezoneProperty)) {
    context[timezoneProperty] = (0, _time.tzFromOffset)(context[timezoneProperty]);
  }
  return {
    _version: DECISION_FORMAT_VERSION,
    context: context,
    output: _lodash2.default.assign.apply(_lodash2.default, _toConsumableArray(_lodash2.default.map(configuration.output, function (output) {
      var decision = decideRecursion(trees[output], context);
      if (decision.error) {
        switch (decision.error.name) {
          case 'CraftAiNullDecisionError':
            throw new _errors.CraftAiNullDecisionError({
              message: decision.error.message,
              metadata: _lodash2.default.extend(decision.error.metadata, {
                decision_rules: decision.decision_rules
              })
            });
          default:
            throw new _errors.CraftAiUnknownError({
              message: decision.error.message
            });
        }
      }
      return _defineProperty({}, output, decision);
    })))
  };
}

exports.formatDecisionRules = _formatter.formatDecisionRules;
exports.formatProperty = _formatter.formatProperty;
exports.reduceDecisionRules = _reducer.reduceDecisionRules;
exports.decide = decide;