ruddy/es/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

import _default25 from 'ramda/src/not';
import _default24 from 'ramda/src/both';
import _default23 from 'ramda/src/either';
import _default22 from 'ramda/src/any';
import _default21 from 'ramda/src/valuesIn';
import _default20 from 'ramda/src/applyTo';
import _default19 from 'ramda/src/when';
import _default18 from 'ramda/src/prop';
import _default17 from 'ramda/src/T';
import _default16 from 'ramda/src/defaultTo';
import _default15 from 'ramda/src/nth';
import _default14 from 'ramda/src/is';
import _default13 from 'ramda/src/reject';
import _default12 from 'ramda/src/isEmpty';
import _default11 from 'ramda/src/reduce';
import _default10 from 'ramda/src/toPairsIn';
import _default9 from 'ramda/src/curry';
import _default8 from 'ramda/src/always';
import _default7 from 'ramda/src/unless';
import _default6 from 'ramda/src/trim';
import _default5 from 'ramda/src/toUpper';
import _default4 from 'ramda/src/compose';
import _default3 from 'ramda/src/keys';
import _default2 from 'ramda/src/__';
import _default from 'ramda/src/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; };

import { isPlainObj, coerceToString } from '../util';
import VALIDATION_LEVELS from './levels';

/**
 * 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
 */
export var isValidationLevel = _default(_default2, _default3(VALIDATION_LEVELS));

/**
 * 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]
 */
export var makeValidationLevel = _default4(_default7(isValidationLevel, _default8('CANCEL')), _default5, _default6, 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
 */
export var pruneInvalidFields = _default9(function (original, validations) {
  return _default4(_default11(function (prunedObj, _ref) {
    var _extends2;

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

    var value = isPlainObj(val) ? pruneInvalidFields(original[key], val) : val;
    if (isPlainObj(value) && _default12(value)) {
      return prunedObj;
    }
    return _extends({}, prunedObj, (_extends2 = {}, _extends2[key] = value === true ? original[key] : value, _extends2));
  }, {}), _default13(_default4(_default14(Array), _default15(1))), _default10)(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
 */
export var pruneValidatedFields = _default4(_default11(function (prunedObj, _ref2) {
  var _extends3;

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

  var value = isPlainObj(val) ? pruneValidatedFields(val) : val;
  if (isPlainObj(value) && _default12(value)) {
    return prunedObj;
  }
  return _extends({}, prunedObj, (_extends3 = {}, _extends3[key] = value, _extends3));
}, {}), _default13(function (pairs) {
  return pairs[1] === true;
}), _default10);

/**
 * 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)
 */
export var getValidatorForAction = function getValidatorForAction(validators) {
  return _default4(_default16(_default17), _default18(_default2, validators), _default18('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
 */
export var 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 _default4(_default19(_default12, _default8(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
 */
export var 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 _default4(_default19(_default12, _default8(null)), pruneValidatedFields, _default20(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}
 */
export var anyValidationFailures = function anyValidationFailures() {
  var validations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _default4(_default22(_default23(_default24(isPlainObj, anyValidationFailures), _default14(Array))), _default21)(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
 */
export var 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 _default4(_default25, anyValidationFailures, _default20(action), getValidatorForAction(validators))(action);
  };
};