ruddy/es/middleware/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 _default13 from 'ramda/src/pipe';
import _default12 from 'ramda/src/has';
import _default11 from 'ramda/src/filter';
import _default10 from 'ramda/src/pathOr';
import _default9 from 'ramda/src/map';
import _default8 from 'ramda/src/isEmpty';
import _default7 from 'ramda/src/isNil';
import _default6 from 'ramda/src/either';
import _default5 from 'ramda/src/reject';
import _default4 from 'ramda/src/values';
import _default3 from 'ramda/src/unnest';
import _default2 from 'ramda/src/compose';
import _default from 'ramda/src/curry';

import createEffectMiddleware from './effects';
import createEnhancerMiddleware from './enhancers';
import createLimiterMiddleware from './limiters';
import createMultiplierMiddleware from './multipliers';
import createValidatorMiddleware from './validators';
import { getRowValidationErrors } from '../duck/validate';
import { createDuckLookup } from '../duck/create';
import { isAction } from '../util/is';
import createLogger from '../util/log';

var flattenList = _default(function (duckPropName, row) {
  return _default2(_default5(_default6(_default7, _default8)), _default3, _default4, _default9(_default10([], [duckPropName])), _default11(_default12(duckPropName)))(row);
});

export default (function (row) {
  var loggingEnabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

  var validationErrors = getRowValidationErrors(row);
  var logger = createLogger(loggingEnabled);

  if (validationErrors) {
    logger.error('Error validating your row of ducks', validationErrors);
    throw new Error(validationErrors);
  }

  var getDuckMatchingAction = createDuckLookup(row);

  var effects = flattenList('effects', row);
  var debouncing = flattenList('debouncing', row);
  var throttling = flattenList('throttling', row);
  var multipliers = _default2(_default4, _default5(_default6(_default7, _default8)), _default9(_default10({}, ['multipliers'])))(row);

  var curriedEnhancers = createEnhancerMiddleware(logger);
  var curriedEffects = createEffectMiddleware(logger, effects);
  var limitAction = createLimiterMiddleware(throttling, debouncing);
  var curriedMultipliers = createMultiplierMiddleware(logger, multipliers);
  var curriedValidators = createValidatorMiddleware(logger, getDuckMatchingAction);

  return function (_ref) {
    var dispatch = _ref.dispatch,
        getState = _ref.getState;

    var enhanceAction = curriedEnhancers(dispatch);
    var validateAction = curriedValidators(getState);
    var multiplyAction = curriedMultipliers(dispatch);
    var handleAnyActionEffects = curriedEffects(dispatch);
    return function (next) {
      return function (action) {
        if (isAction(action)) {
          limitAction(action).catch(function (err) {
            return logger.error('There was a problem throttling or debouncing: "' + action.type + '"', err);
          }).then(function (limitedAction) {
            var validatedAction = validateAction(limitedAction);
            return isAction(validatedAction) ? validatedAction : false;
          }).catch(function (err) {
            logger.error('There was a problem validating: "' + action.type + '"', err);
            next(action);
          }).then(function (validatedAction) {
            if (validatedAction) {
              var _getDuckMatchingActio = getDuckMatchingAction(validatedAction),
                  enhancers = _getDuckMatchingActio.enhancers;

              return _default13(multiplyAction, enhanceAction(enhancers))(validatedAction);
            }
            return false;
          }).catch(function (err) {
            logger.error('A multiplier and/or enhancer failed for: "' + action.type + '"', err);
            next(action);
          }).then(function (enhancedAction) {
            if (isAction(enhancedAction)) {
              next(enhancedAction);
              handleAnyActionEffects(enhancedAction);
            }
          }).catch(function (err) {
            return logger.error('There was a problem executing the effect for: "' + action.type + '"', err);
          });
        } else {
          logger.error('Looks like something was dispatched that is not a valid action:', action);
        }
      };
    };
  };
});