redux-declarative-request/lib/index.js

Making Promised requests following declarative programming paradigm leveraging redux actions structure

'use strict';

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

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; };

exports.isLiteralObject = isLiteralObject;
exports.isFunction = isFunction;
exports.isRequest = isRequest;
exports.getUrl = getUrl;
exports.getResponseHandlersKeys = getResponseHandlersKeys;
exports.getAggregatedAction = getAggregatedAction;
exports.handleResponse = handleResponse;
exports.request = request;
exports.omitCallbacks = omitCallbacks;
exports.declarativeRequest = declarativeRequest;

var _url = require('url');

var _url2 = _interopRequireDefault(_url);

var _errors = require('./errors');

var Errors = _interopRequireWildcard(_errors);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

var defaultRequest = {
  method: 'get',
  query: {},
  body: {},
  options: {}
};

var middlewareDefaultSettings = {
  initialThen: function initialThen(response, action) {
    return response;
  },
  buildRequestPromise: function buildRequestPromise(_ref, action) {
    var url = _ref.url,
        method = _ref.method;
    return Promise.reject(Errors.MISSING_REQUEST_BUILDER);
  },
  parseResponseCode: function parseResponseCode(error, response, action) {
    return error ? error.response.status : response.status;
  }
};

function isLiteralObject(x) {
  return x && x.constructor === Object;
}

function isFunction(x) {
  return typeof x === 'function';
}

function isRequest(action, settings) {
  if (typeof action.uri === 'string' && !('baseUrl' in settings)) throw new Error(Errors.MISSING_BASE_URL);
  return typeof action.uri === 'string' || typeof action.url === 'string';
}

function getUrl(action, baseUrl) {
  if (action.url) return action.url;
  var base = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
  var uri = action.uri.startsWith('/') ? action.uri.slice(1) : action.uri;
  return base + '/' + uri;
}
function getResponseHandlersKeys(action, responseCode) {
  return Object.keys(action).filter(function (handlerKey) {
    return handlerKey.indexOf(String(responseCode)) >= 0 && (isLiteralObject(action[String(responseCode)]) || isFunction(action[String(responseCode)]));
  });
}

function getAggregatedAction(action, response, responseCode) {
  return getResponseHandlersKeys(action, responseCode).reduce(function (all, handlerKey) {
    var subAction = action[handlerKey];
    if (isFunction(subAction)) {
      subAction = subAction(action, response);
    }
    return isLiteralObject(subAction) ? _extends({}, all, subAction) : all;
  }, {});
}

function handleResponse(action, response, responseCode, hasError) {
  return function (settings) {
    return function (dispatch) {
      if (isFunction(settings.onReceiveResponse)) {
        settings.onReceiveResponse(dispatch, action);
      }
      var aggregatedActions = getAggregatedAction(action, response, responseCode);

      var responseAction = _extends({}, omitCallbacks(action), aggregatedActions, {
        type: action.type,
        hasError: hasError,
        responseCode: responseCode
      });
      delete responseAction.url;
      delete responseAction.uri;

      dispatch(responseAction);

      if (isFunction(settings.onCompleteHandleResponse)) {
        settings.onCompleteHandleResponse(dispatch, action);
      }
    };
  };
}

function request(action, settings) {
  var type = action.type,
      request = _objectWithoutProperties(action, ['type']);

  request = _extends({}, defaultRequest, request);
  return function (dispatch) {
    if (isFunction(settings.onBeforeRequest)) {
      settings.onBeforeRequest(dispatch, action);
    }
    var responseCode = void 0;

    settings.buildRequestPromise({
      url: getUrl(action, settings.baseUrl),
      method: request.method
    }, action).then(function (response) {
      responseCode = settings.parseResponseCode(false, response, action);
      return settings.initialThen(response, action);
    }).then(function (response) {
      return handleResponse(action, response, responseCode, false)(settings)(dispatch);
    }).catch(function (error) {
      responseCode = settings.parseResponseCode(error, null, action);
      return handleResponse(action, error, responseCode, true)(settings)(dispatch);
    });
  };
}

function omitCallbacks(action) {
  return Object.keys(action).filter(function (k) {
    return typeof action[k] !== 'function';
  }).reduce(function (newAction, k) {
    return _extends({}, newAction, _defineProperty({}, k, action[k]));
  }, {});
}

function declarativeRequest(configuration) {
  var settings = _extends({}, middlewareDefaultSettings, configuration);
  return function (store) {
    return function (next) {
      return function (action) {
        if (isRequest(action, settings)) {
          return request(action, settings)(store.dispatch);
        }
        next(action);
      };
    };
  };
}