gambit/dist/lib/createAction.js

A hyper-thin library to help building API driven redux apps

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.bindCreators = undefined;

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

exports.createStagedAction = createStagedAction;
exports.createSimpleAction = createSimpleAction;

var _isPlainObject = require('lodash/isPlainObject');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _GeneralConstants = require('./GeneralConstants');

var _GeneralConstants2 = _interopRequireDefault(_GeneralConstants);

var _dict = require('./dict');

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

function argumentsCheck(constant, namedArguments, actionBlocker) {
  var methodToCall = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];

  (0, _invariant2.default)(constant, (0, _dict.badConstantName)(constant));
  (0, _invariant2.default)((0, _isPlainObject2.default)(namedArguments), (0, _dict.nonNamedArguments)(namedArguments));
  (0, _invariant2.default)(typeof actionBlocker === 'function' || !actionBlocker, (0, _dict.badActionBlocker)(actionBlocker));
  (0, _invariant2.default)(typeof methodToCall === 'function' || methodToCall === false, (0, _dict.badMethodFinder)(methodToCall));
}

function createStagedAction(constant, methodFinder) {
  var _ref = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

  var postDone = _ref.postDone;
  var postStart = _ref.postStart;
  var postFail = _ref.postFail;
  var _ref$id = _ref.id;
  var id = _ref$id === undefined ? constant : _ref$id;
  var _ref$cycleId = _ref.cycleId;
  var cycleId = _ref$cycleId === undefined ? false : _ref$cycleId;

  if (this && this.constants) constant = this.constants[constant];

  return function () {
    var namedArguments = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
    var actionBlocker = arguments[1];
    return function (api, dispatch, state) {
      var methodToCall = methodFinder(api);
      argumentsCheck(constant, namedArguments, actionBlocker, methodToCall);

      var madeId = typeof id === 'function' ? id(constant, namedArguments) : id;

      var madeCycleId = typeof cycleId === 'function' ? cycleId(constant, namedArguments) : cycleId;

      (0, _invariant2.default)(madeId.indexOf('undefined') === -1, (0, _dict.undefinedArgumentGiven)(constant, madeId));

      (0, _invariant2.default)(typeof madeId === 'string', (0, _dict.badMadeId)(madeId));

      var calls = state().gambit;
      if (calls) {
        var shouldGoAhead = actionBlocker ? actionBlocker(calls.getIn(['lastCalled', madeId]), calls.getIn(['lastSucceeded', madeId]), calls) : true;

        if (!shouldGoAhead) {
          return false;
        }
      }

      dispatch({
        type: _GeneralConstants2.default.ACTION_CALLED,
        action: madeId,
        namedArguments: namedArguments,
        cycleId: madeCycleId
      });
      dispatch((0, _extends3.default)({}, namedArguments, {
        type: constant + '_STARTING'
      }));

      var start = _bluebird2.default.resolve();
      if (postStart) {
        start = postStart(dispatch, namedArguments);
      }

      return start.then(function () {
        return methodToCall(namedArguments);
      }).then(function (_ref2) {
        var body = _ref2.body;

        return _bluebird2.default.all([dispatch({
          type: _GeneralConstants2.default.ACTION_SUCCEEDED,
          action: madeId,
          cycleId: madeCycleId
        }), dispatch((0, _extends3.default)({}, namedArguments, {
          type: constant + '_DONE',
          body: body
        }))]);
      }).then(function (_ref3) {
        var _ref4 = (0, _slicedToArray3.default)(_ref3, 2);

        var actionCalled = _ref4[0];
        var doneVal = _ref4[1];

        if (postDone) {
          return postDone(dispatch, doneVal, namedArguments, api).then(function () {
            return doneVal;
          });
        }
        return doneVal;
      }).catch(function (error) {
        dispatch({
          type: _GeneralConstants2.default.ACTION_FAILED,
          action: madeId,
          cycleId: madeCycleId,
          response: error.response ? error.response.body : error
        });
        dispatch((0, _extends3.default)({}, namedArguments, {
          type: constant + '_FAILED',
          response: error.response ? error.response.body : error
        }));
        if (postFail) {
          postFail(dispatch, error, namedArguments, api);
        }
        throw new Error(error);
      });
    };
  };
}

function createSimpleAction(constant) {
  if (this && this.constants) constant = this.constants[constant];
  return function () {
    var namedArguments = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
    return function (api, dispatch) {
      argumentsCheck(constant, namedArguments);
      return dispatch((0, _extends3.default)({}, namedArguments, {
        type: constant + '_DONE'
      }));
    };
  };
}

var bindCreators = exports.bindCreators = function bindCreators(constants) {
  return {
    createSimpleAction: createSimpleAction.bind({ constants: constants }),
    createStagedAction: createStagedAction.bind({ constants: constants })
  };
};