ruddy/cjs/validators/index.js

Modularized state-management tools for modern front-end applications. Manage dispatched messages in a clean and predictable way for either small or large scale projects

'use strict';

exports.__esModule = true;
exports.createPayloadValidator = exports.anyValidationFailures = exports.createPayloadValidationsLogger = exports.createPayloadPruner = exports.getValidatorForAction = exports.pruneValidatedFields = exports.pruneInvalidFields = exports.makeValidationLevel = exports.isValidationLevel = undefined;

var _not = require('ramda/src/not');

var _not2 = _interopRequireDefault(_not);

var _both = require('ramda/src/both');

var _both2 = _interopRequireDefault(_both);

var _either = require('ramda/src/either');

var _either2 = _interopRequireDefault(_either);

var _any = require('ramda/src/any');

var _any2 = _interopRequireDefault(_any);

var _valuesIn = require('ramda/src/valuesIn');

var _valuesIn2 = _interopRequireDefault(_valuesIn);

var _applyTo = require('ramda/src/applyTo');

var _applyTo2 = _interopRequireDefault(_applyTo);

var _when = require('ramda/src/when');

var _when2 = _interopRequireDefault(_when);

var _prop = require('ramda/src/prop');

var _prop2 = _interopRequireDefault(_prop);

var _T = require('ramda/src/T');

var _T2 = _interopRequireDefault(_T);

var _defaultTo = require('ramda/src/defaultTo');

var _defaultTo2 = _interopRequireDefault(_defaultTo);

var _nth = require('ramda/src/nth');

var _nth2 = _interopRequireDefault(_nth);

var _is = require('ramda/src/is');

var _is2 = _interopRequireDefault(_is);

var _reject = require('ramda/src/reject');

var _reject2 = _interopRequireDefault(_reject);

var _isEmpty = require('ramda/src/isEmpty');

var _isEmpty2 = _interopRequireDefault(_isEmpty);

var _reduce = require('ramda/src/reduce');

var _reduce2 = _interopRequireDefault(_reduce);

var _toPairsIn = require('ramda/src/toPairsIn');

var _toPairsIn2 = _interopRequireDefault(_toPairsIn);

var _curry = require('ramda/src/curry');

var _curry2 = _interopRequireDefault(_curry);

var _always = require('ramda/src/always');

var _always2 = _interopRequireDefault(_always);

var _unless = require('ramda/src/unless');

var _unless2 = _interopRequireDefault(_unless);

var _trim = require('ramda/src/trim');

var _trim2 = _interopRequireDefault(_trim);

var _toUpper = require('ramda/src/toUpper');

var _toUpper2 = _interopRequireDefault(_toUpper);

var _compose = require('ramda/src/compose');

var _compose2 = _interopRequireDefault(_compose);

var _keys = require('ramda/src/keys');

var _keys2 = _interopRequireDefault(_keys);

var _ = require('ramda/src/__');

var _2 = _interopRequireDefault(_);

var _contains = require('ramda/src/contains');

var _contains2 = _interopRequireDefault(_contains);

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _util = require('../util');

var _levels = require('./levels');

var _levels2 = _interopRequireDefault(_levels);

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

/**
 * Checks to see if a given value is one of the valid options for
 * Validation Level, which are: STRICT, CANCEL, PRUNE, LOG
 *
 * @func
 * @sig String -> Boolean
 * @param {String} level One of the four valid options: STRICT, CANCEL, PRUNE, LOG
 * @returns {Boolean} Whether or not a level is valid for middleware validations
 */
var isValidationLevel = exports.isValidationLevel = (0, _contains2.default)(_2.default, (0, _keys2.default)(_levels2.default));

/**
 * Sets a validation level, one of: STRICT, CANCEL, PRUNE, LOG.
 * The default - if no valid level is passed in - is CANCEL.
 *
 * @func
 * @sig String -> String
 * @param {String|*} level A validation level for the middleware
 * @returns {String} One of [STRICT, CANCEL, PRUNE, LOG]
 */
var makeValidationLevel = exports.makeValidationLevel = (0, _compose2.default)((0, _unless2.default)(isValidationLevel, (0, _always2.default)('CANCEL')), _toUpper2.default, _trim2.default, _util.coerceToString);

/**
 * A curried function that examines the result of a [spected](https://github.com/25th-floor/spected) validator on a given
 * input object and replaces the validation failures with the original value
 * from the input object.
 *
 * @func
 * @sig {k: v} -> {k: v} -> {k: v}
 * @param {Object} original The input object which when pushed through a validator yielded the associated validations
 * @param {Object} validations An object of validation results (true for pass, String[] for fails)
 * @returns {Object} The validations result pruned of all invalid fields
 */
var pruneInvalidFields = exports.pruneInvalidFields = (0, _curry2.default)(function (original, validations) {
  return (0, _compose2.default)((0, _reduce2.default)(function (prunedObj, _ref) {
    var _extends2;

    var key = _ref[0],
        val = _ref[1];

    var value = (0, _util.isPlainObj)(val) ? pruneInvalidFields(original[key], val) : val;
    if ((0, _util.isPlainObj)(value) && (0, _isEmpty2.default)(value)) {
      return prunedObj;
    }
    return _extends({}, prunedObj, (_extends2 = {}, _extends2[key] = value === true ? original[key] : value, _extends2));
  }, {}), (0, _reject2.default)((0, _compose2.default)((0, _is2.default)(Array), (0, _nth2.default)(1))), _toPairsIn2.default)(validations);
});

/**
 * A function that inspects a validations object (validated fields are Bools of `true` and
 * invalid fields are arrays of error messages) and removes everything but the errors
 *
 * @func
 * @sig {k: v} -> {k: v}
 * @param {Object} validations An object of validation results (true for pass, String[] for fails)
 * @returns {Object} The validations result pruned of all valid fields
 */
var pruneValidatedFields = exports.pruneValidatedFields = (0, _compose2.default)((0, _reduce2.default)(function (prunedObj, _ref2) {
  var _extends3;

  var key = _ref2[0],
      val = _ref2[1];

  var value = (0, _util.isPlainObj)(val) ? pruneValidatedFields(val) : val;
  if ((0, _util.isPlainObj)(value) && (0, _isEmpty2.default)(value)) {
    return prunedObj;
  }
  return _extends({}, prunedObj, (_extends3 = {}, _extends3[key] = value, _extends3));
}, {}), (0, _reject2.default)(function (pairs) {
  return pairs[1] === true;
}), _toPairsIn2.default);

/**
 * Simple retrieval function that looks for an action payload validator matching
 * a given action.
 *
 * @func
 * @sig {k: v} -> {k: v} -> ({k: v} -> Boolean)
 * @returns {Function} A validator matching a dispatched action (or a Function
 * always returning True if none exists)
 */
var getValidatorForAction = exports.getValidatorForAction = function getValidatorForAction(validators) {
  return (0, _compose2.default)((0, _defaultTo2.default)(_T2.default), (0, _prop2.default)(_2.default, validators), (0, _prop2.default)('type'));
};

/**
 * Creates a function that will receive a dispatched action and apply a validator function that
 * matches its action type (if one exists) and prune away any fields that failed validation.
 * The set of validator functions from which to match the action type is the only dependency.
 *
 * @func
 * @sig {k: v} -> {k: v} -> {k: v}
 * @param {Object} validators An object of curried [spected](https://github.com/25th-floor/spected) validator functions
 * @returns {Object} The original action paylod, minus any invalid fields
 */
var createPayloadPruner = exports.createPayloadPruner = function createPayloadPruner() {
  var validators = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return function () {
    var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return (0, _compose2.default)((0, _when2.default)(_isEmpty2.default, (0, _always2.default)(null)), pruneInvalidFields(action), function (validate) {
      return validate(action);
    }, getValidatorForAction(validators))(action);
  };
};

/**
 * Creates a function that will receive a dispatched action and apply a validator function that
 * matches its action type (if one exists).
 * The set of validator functions from which to match the action type is the only dependency.
 *
 * @func
 * @sig {k: v} -> {k: v} -> {k: v}
 * @param {Object} validators An object of curried [spected](https://github.com/25th-floor/spected) validator functions
 * @returns {Object|null} An Object of validation errors, if any, otherwise returns null
 */
var createPayloadValidationsLogger = exports.createPayloadValidationsLogger = function createPayloadValidationsLogger() {
  var validators = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return function () {
    var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return (0, _compose2.default)((0, _when2.default)(_isEmpty2.default, (0, _always2.default)(null)), pruneValidatedFields, (0, _applyTo2.default)(action), getValidatorForAction(validators))(action);
  };
};

/**
 * Inspects an Object (can even be nested) of validation results, for props which failed validation.
 * Because the [spected](https://github.com/25th-floor/spected) tool follows a common validations format
 * where failed validations are Arrays of validation errors (strings) and validated props are simply marked `true`,
 * this function is only doing a quick, simple check for any props that are arrays.
 *
 * @func
 * @sig {k: v} -> Boolean
 * @param {Object} validations
 * @returns {Boolean}
 */
var anyValidationFailures = exports.anyValidationFailures = function anyValidationFailures() {
  var validations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return (0, _compose2.default)((0, _any2.default)((0, _either2.default)((0, _both2.default)(_util.isPlainObj, anyValidationFailures), (0, _is2.default)(Array))), _valuesIn2.default)(validations);
};

/**
 * Creates a function that will receive a dispatched action and apply a validator function that
 * matches its action type (if one exists) and do a basic pass/fail check.
 * The set of validator functions from which to match the action type is the only dependency.
 *
 * @func
 * @sig {k: v} -> {k: v} -> Boolean
 * @param {Object} validators An object of curried [spected](https://github.com/25th-floor/spected) validator functions
 * @returns {Function} A validator function to be applied against a dispatched action
 */
var createPayloadValidator = exports.createPayloadValidator = function createPayloadValidator() {
  var validators = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return function () {
    var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return (0, _compose2.default)(_not2.default, anyValidationFailures, (0, _applyTo2.default)(action), getValidatorForAction(validators))(action);
  };
};