react-redux-fetch/lib/container.js

A declarative and customizable way to fetch data for React components and manage that data in the Redux state

'use strict';

exports.__esModule = true;

var _Definition = require('./dependencyInjection/Definition');

var _Definition2 = _interopRequireDefault(_Definition);

var _ContainerBuilder = require('./dependencyInjection/ContainerBuilder');

var _ContainerBuilder2 = _interopRequireDefault(_ContainerBuilder);

var _fetchRequest = require('./middleware/fetchRequest');

var _fetchRequest2 = _interopRequireDefault(_fetchRequest);

var _getReducer = require('./reducers/getReducer');

var _getReducer2 = _interopRequireDefault(_getReducer);

var _deleteReducer = require('./reducers/deleteReducer');

var _deleteReducer2 = _interopRequireDefault(_deleteReducer);

var _postReducer = require('./reducers/postReducer');

var _postReducer2 = _interopRequireDefault(_postReducer);

var _putReducer = require('./reducers/putReducer');

var _putReducer2 = _interopRequireDefault(_putReducer);

var _defaultHeaders = require('./utils/defaultHeaders');

var _defaultHeaders2 = _interopRequireDefault(_defaultHeaders);

var _requestBuilder = require('./utils/requestBuilder');

var _requestBuilder2 = _interopRequireDefault(_requestBuilder);

var _equals = require('./utils/equals');

var _equals2 = _interopRequireDefault(_equals);

var _assert = require('./utils/assert');

var _assert2 = _interopRequireDefault(_assert);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /*
                                                                                                                                                           * // 
                                                                                                                                                           * react-redux-fetch knows how to handle the following services:
                                                                                                                                                           *     - requestMethods
                                                                                                                                                           *     - requestHeaders
                                                                                                                                                           *     - reducers
                                                                                                                                                           *     - responseHandler (TODO)
                                                                                                                                                           *     - requestBuilder
                                                                                                                                                           */


var ContainerFacade = function () {
  function ContainerFacade() {
    _classCallCheck(this, ContainerFacade);

    this.container = new _ContainerBuilder2.default();
    this.init();
  }

  ContainerFacade.prototype.init = function init() {
    this.container.register('requestMethods', {
      get: {
        method: 'get',
        middleware: _fetchRequest2.default,
        reducer: _getReducer2.default
      },
      post: {
        method: 'post',
        middleware: _fetchRequest2.default,
        reducer: _postReducer2.default
      },
      put: {
        method: 'put',
        middleware: _fetchRequest2.default,
        reducer: _putReducer2.default
      },
      delete: {
        method: 'delete',
        middleware: _fetchRequest2.default,
        reducer: _deleteReducer2.default
      }
    });

    this.container.register('requestHeaders', _defaultHeaders2.default);
    this.container.register('reducers', {});
    this.container.register('requestBuilder', { build: _requestBuilder2.default });
    this.container.register('utils', { equals: _equals2.default });
    // container.getDefinition('requestMethods').addArgument('patch', '...');
    // container.getDefinition('requestMethods').addArgument('token', '...');
  };

  ContainerFacade.prototype.getDefinition = function getDefinition() {
    var _container;

    return (_container = this.container).getDefinition.apply(_container, arguments);
  };

  ContainerFacade.prototype.hasDefinition = function hasDefinition() {
    var _container2;

    return (_container2 = this.container).hasDefinition.apply(_container2, arguments);
  };

  ContainerFacade.prototype.getUtil = function getUtil(name) {
    return this.container.getDefinition('utils').getArgument(name);
  };

  /**
   * Facade method to register a reducer at the container
   * @param {String} stateName The name of the state part you want a reducer for
   * @param {Function} reducer The reducer for the state part
   * @return {Definition} A Definition instance
   */


  ContainerFacade.prototype.registerReducer = function registerReducer(stateName, reducer) {
    return this.container.getDefinition('reducers').addArgument(stateName, reducer);
  };

  /**
   * Facade method to register a request header at the container
   * @param {String} name Header field name (e.g. 'Accept-Encoding')
   * @param {String} value Header field value (e.g. 'application/json')
   * @return {Definition} A Definition instance
   */


  ContainerFacade.prototype.registerRequestHeader = function registerRequestHeader(name, value) {
    return this.container.getDefinition('requestHeaders').addArgument(name, value);
  };

  /**
   * Replace existing request headers
   * @param {Object} newRequestHeaders The new request headers (e.g. {'Accept': 'application/json'})
   * @return {Definition} A Definition instance
   */


  ContainerFacade.prototype.replaceRequestHeaders = function replaceRequestHeaders(newRequestHeaders) {
    return this.container.register('requestHeaders', newRequestHeaders);
  };

  /**
   * Facade method to register a request method at the container
   * @param {String} method The request method to add the config for (e.g. 'post')
   * @param {Object} config The config object ({middleware, reducer})
   * @return {Definition} A Definition instance
   */


  ContainerFacade.prototype.registerRequestMethod = function registerRequestMethod(method, config) {
    _assert2.default.contains(config, 'middleware', 'Property \'middleware\' is missing from the ' + method + ' request method config.\n        You can use fetchRequestMiddleware: import {fetchRequestMiddleware} from \'react-redux-fetch.');
    _assert2.default.contains(config, 'reducer', 'Property \'reducer\' is missing from the ' + method + ' request method config.\n        You should pass a reducer function which handles actions for your ' + method + ' request method.\n        See https://github.com/hirviid/react-redux-fetch/blob/master/src/reducers/getReducer.js for an example.');

    return this.container.getDefinition('requestMethods').addArgument(method, Object.assign({ method: method }, config));
  };

  /**
   * Facade method to change a specific property of a request method configuration
   * @param {String} method The request method to change the config for (e.g 'post')
   * @param {String} key The config key (e.g. 'reducer')
   * @param {any} value The value to set
   * @return {Definition} A Definition instance
   */


  ContainerFacade.prototype.changeRequestMethodConfig = function changeRequestMethodConfig(method, key, value) {
    _assert2.default.exists(this.container.getDefinition('requestMethods').getArguments()[method], 'Nothing to replace, no request method \'' + method + '\' registered, use container.registerRequestMethod() to register ' + method + ' requests.');

    return this.container.getDefinition('requestMethods').replaceArgument(method + '.' + key, value);
  };

  return ContainerFacade;
}();

exports.default = new ContainerFacade();