redux-boost/lib/components/Query/Query.js

Redux-Boost

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _extends3 = _interopRequireDefault(_extends2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _react = require('react');

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

var RestQueryComponent = exports.RestQueryComponent = function (_Component) {
  (0, _inherits3.default)(RestQueryComponent, _Component);

  function RestQueryComponent() {
    var _ref,
        _this2 = this;

    var _temp, _this, _ret;

    (0, _classCallCheck3.default)(this, RestQueryComponent);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3.default)(this, (_ref = RestQueryComponent.__proto__ || Object.getPrototypeOf(RestQueryComponent)).call.apply(_ref, [this].concat(args))), _this), _this.hasMounted = false, _this.state = {
      entities: undefined
    }, _this.getQueryResult = function () {
      return (0, _extends3.default)({
        fetchData: _this.fetchData
      }, _this.state, _this.props.requestState);
    }, _this.updateState = function (data) {
      if (_this.hasMounted) {
        _this.setState(data);
      }
    }, _this.fetchData = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
      var _this$props, query, fetchStart, _this$props$action, action, result;

      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (!_this.props.shouldSkip) {
                _context.next = 2;
                break;
              }

              return _context.abrupt('return', null);

            case 2:
              _this$props = _this.props, query = _this$props.query, fetchStart = _this$props.fetchStart, _this$props$action = _this$props.action, action = _this$props$action === undefined ? fetchStart : _this$props$action;
              _context.prev = 3;
              _context.next = 6;
              return new Promise(function (resolve, reject) {
                var requestAction = action(query, {
                  resolve: resolve,
                  reject: reject
                });

                // Handy to use with thunks
                if (requestAction.then) {
                  requestAction.then(function (resp) {
                    return resolve(resp);
                  }).catch(function (err) {
                    return reject(err);
                  });
                }
              });

            case 6:
              result = _context.sent;


              _this.updateState({
                entities: result.entities
              });

              return _context.abrupt('return', result);

            case 11:
              _context.prev = 11;
              _context.t0 = _context['catch'](3);
              throw _context.t0;

            case 14:
            case 'end':
              return _context.stop();
          }
        }
      }, _callee, _this2, [[3, 11]]);
    })), _temp), (0, _possibleConstructorReturn3.default)(_this, _ret);
  }

  (0, _createClass3.default)(RestQueryComponent, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      this.fetchData();
      this.hasMounted = true;
    }
  }, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate(_ref3) {
      var _this3 = this;

      var query = _ref3.query;

      var queryUpdated = Object.keys(query).some(function (key) {
        return query[key] !== _this3.props.query[key];
      });

      if (queryUpdated) {
        this.fetchData();
      }
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.hasMounted = false;
    }
  }, {
    key: 'render',
    value: function render() {
      var children = this.props.children;

      var queryResult = this.getQueryResult();

      return children(queryResult);
    }
  }], [{
    key: 'getDerivedStateFromProps',
    value: function getDerivedStateFromProps(_ref4, _ref5) {
      var requestState = _ref4.requestState;
      var entities = _ref5.entities;

      if (requestState && requestState.result) {
        return {
          entities: entities
        };
      }

      return {
        entities: undefined
      };
    }

    // eslint-disable-next-line react/sort-comp

  }]);
  return RestQueryComponent;
}(_react.Component);

RestQueryComponent.defaultProps = {
  query: {},
  options: {}
};