attadux/cjs/duck/schema.js

Implementation of the redux-modular-ducks, forked from the extensible-duck implementation and extended to include spected validators, state machines, helpers, web workers, effect handling, action multipliers, action enhancers, action throttling/debouncing

'use strict';

exports.__esModule = true;
exports.noDucks = exports.isDux = exports.duckMiddlewareRules = exports.duxRules = exports.duxDefaults = exports.metadataEvolvers = undefined;

var _none = require('ramda/src/none');

var _none2 = _interopRequireDefault(_none);

var _complement = require('ramda/src/complement');

var _complement2 = _interopRequireDefault(_complement);

var _difference = require('ramda/src/difference');

var _difference2 = _interopRequireDefault(_difference);

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

var _keys2 = _interopRequireDefault(_keys);

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

var _isEmpty2 = _interopRequireDefault(_isEmpty);

var _allPass = require('ramda/src/allPass');

var _allPass2 = _interopRequireDefault(_allPass);

var _values = require('ramda/src/values');

var _values2 = _interopRequireDefault(_values);

var _filter = require('ramda/src/filter');

var _filter2 = _interopRequireDefault(_filter);

var _split = require('ramda/src/split');

var _split2 = _interopRequireDefault(_split);

var _last = require('ramda/src/last');

var _last2 = _interopRequireDefault(_last);

var _map = require('ramda/src/map');

var _map2 = _interopRequireDefault(_map);

var _equals = require('ramda/src/equals');

var _equals2 = _interopRequireDefault(_equals);

var _uniq = require('ramda/src/uniq');

var _uniq2 = _interopRequireDefault(_uniq);

var _length = require('ramda/src/length');

var _length2 = _interopRequireDefault(_length);

var _toPairs = require('ramda/src/toPairs');

var _toPairs2 = _interopRequireDefault(_toPairs);

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

var _compose2 = _interopRequireDefault(_compose);

var _anyPass = require('ramda/src/anyPass');

var _anyPass2 = _interopRequireDefault(_anyPass);

var _all = require('ramda/src/all');

var _all2 = _interopRequireDefault(_all);

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

var _is2 = _interopRequireDefault(_is);

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

var _both2 = _interopRequireDefault(_both);

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

var _either2 = _interopRequireDefault(_either);

var _identity = require('ramda/src/identity');

var _identity2 = _interopRequireDefault(_identity);

var _machines = require('../machines');

var _types = require('../types');

var _is3 = require('../util/is');

var _validators = require('../validators');

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

/**
 * This object of functions is meant to be applied to an object which has
 * some or all of its keys sharing the same name as these evolver functions.
 *
 * Using [evolve()](http://ramdajs.docs/#evolve) on an object with this set of evolver functions
 * will create a clone of the original object with the result of each evolver in place of the original value.
 */
var metadataEvolvers = exports.metadataEvolvers = {
    namespace: _identity2['default'],
    store: _identity2['default'],
    validationLevel: _validators.makeValidationLevel,
    stateMachinesPropName: _machines.getStateMachinesPropPath,
    consts: _types.createConstants

    /**
     * These are values which will always be set for a new duck,
     * even though the user may not explicitly supply a value for any of them.
     */
};var duxDefaults = exports.duxDefaults = {
    consts: {},
    creators: {},
    machines: {},
    queries: {},
    workers: {},
    selectors: {},
    stateMachinesPropName: 'states',
    types: [],
    validationLevel: 'CANCEL',
    validators: {}

    /**
     * This set of rules is expected to be supplied to the (curried) [spected](https://github.com/25th-floor/spected)
     * function, and is then invoked against the set of values supplied when creating a new duck.
     *
     * The spected validator function will then apply this collection of validator functions against
     * any matching keys on the input values passed in, and set either a value of 'true' if validation succeeded
     * or an array of error messages for any value(s) that failed validation.
     */
};var duxRules = exports.duxRules = {
    validationLevel: [[_validators.isValidationLevel, 'must be: STRICT, CANCEL, PRUNE, or LOG. CANCEL is the default.']],
    store: [[_is3.isStringieThingie, 'must be a (non-blank) string']],
    namespace: [[_is3.isStringieThingie, 'must be a (non-blank) string']],
    stateMachinesPropName: [[(0, _either2['default'])(_is3.isStringieThingie, (0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])(_is3.isStringieThingie))), 'must be a string (or array of strings)']],
    consts: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    creators: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    machines: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    selectors: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    types: [[(0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])((0, _is2['default'])(String))), 'must be an object (or a function returning an object)']],
    validators: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    enhancers: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    multipliers: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    queries: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    workers: [[(0, _either2['default'])(_is3.isPlainObj, (0, _is2['default'])(Function)), 'must be an object (or a function returning an object)']],
    reducer: [[(0, _is2['default'])(Function), 'must be a function']],
    effects: [[(0, _either2['default'])((0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])((0, _is2['default'])(Array))), (0, _is2['default'])(Function)), 'must be an array of key/value pairs (or a function returning an one)']],
    throttling: [[(0, _either2['default'])((0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])((0, _is2['default'])(Array))), (0, _is2['default'])(Function)), 'must be an array of key/value pairs (or a function returning an one)']],
    debouncing: [[(0, _either2['default'])((0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])((0, _is2['default'])(Array))), (0, _is2['default'])(Function)), 'must be an array of key/value pairs (or a function returning an one)']],
    initialState: [[(0, _anyPass2['default'])([_is3.isPrimitiveish, _is3.isPlainObj, (0, _is2['default'])(Function)]), 'must be an object, a function returning an object, or a primitive value']]

    /**
     * This set of rules is expected to be supplied to the (curried) [spected](https://github.com/25th-floor/spected)
     * function, and is then invoked against one or more ducks supplied to the validator middleware.
     *
     * The spected validator function will then apply this collection of validator functions against
     * any matching keys on the input values passed in, and set either a value of 'true' if validation succeeded
     * or an array of error messages for any value(s) that failed validation.
     *
     * The validator middleware makes use of a small portion of a given duck, so the schema rules
     * for validating a usable duck in the middleware function is less strict than those used to create a duck.
     */
};var duckMiddlewareRules = exports.duckMiddlewareRules = {
    store: [[_is3.isStringieThingie, 'must be a (non-blank) string']],
    namespace: [[_is3.isStringieThingie, 'must be a (non-blank) string']],
    types: [[_is3.isPlainObj, 'must be an object'], [(0, _compose2['default'])((0, _all2['default'])((0, _compose2['default'])((0, _equals2['default'])(1), _length2['default'], _uniq2['default'])), (0, _map2['default'])(function (_ref) {
        var key = _ref[0];
        var val = _ref[1];
        return [key, (0, _compose2['default'])(_last2['default'], (0, _split2['default'])('/'))(val)];
    }), (0, _filter2['default'])((0, _all2['default'])((0, _is2['default'])(String))), _toPairs2['default']), 'each key and value are identical']],
    machines: [[(0, _compose2['default'])((0, _all2['default'])(_is3.isPlainObj), _values2['default']), 'must be an object'], [(0, _compose2['default'])((0, _all2['default'])(_is3.isNotEmpty), _values2['default']), 'must not be empty'], [(0, _compose2['default'])((0, _all2['default'])((0, _allPass2['default'])([_machines.areStateNamesStrings, _machines.areInputsAndTransitionsStrings])), _values2['default']), 'each machine contains nested objects (states) whose inputs and transitions are strings'], [(0, _compose2['default'])((0, _all2['default'])(_machines.isEachTransitionAmongMachineStates), _values2['default']), 'each transition value must also be a state']],
    stateMachinesPropName: [[(0, _both2['default'])((0, _is2['default'])(Array), (0, _all2['default'])(_is3.isStringieThingie)), 'must be an array of strings (representing the path to the "current state" prop)']]

    /**
     * Checks to see if a given value is a Duck for middleware,
     * which means it is a namespaced unit that contains types and validators for one or more of those types.
     *
     * @func
     * @sig * -> Boolean
     * @param {*} val A value which may or may not be a Duck instance
     * @returns {Boolean} whether or not the object is an instance of a Duck
     */
};var isDux = exports.isDux = (0, _compose2['default'])(_isEmpty2['default'], (0, _difference2['default'])(['store', 'namespace', 'validators', 'types']), _keys2['default']);

/**
 * Checks whether or not a given Object contains ducks
 *
 * @func
 * @sig {k: v} -> Boolean
 * @param {Object} row An Object which may contain ducks among its props
 * @returns {Boolean} whether or not there are any ducks inside of a given Object
 */
var noDucks = exports.noDucks = (0, _anyPass2['default'])([(0, _complement2['default'])(_is3.isPlainObj), (0, _compose2['default'])(_isEmpty2['default'], _keys2['default']), (0, _compose2['default'])((0, _none2['default'])(isDux), _values2['default'])]);