sharyn/redux/thunks.js

"use strict";

var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fetchPageThunk = exports.graphqlThunk = exports.configureFetchPageThunk = exports.configureGraphqlThunk = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/objectSpread"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));

var _graphqlCall = _interopRequireDefault(require("@sharyn/shared/graphql-call"));

var _spread = _interopRequireDefault(require("@sharyn/util/spread"));

// flow-disable-next-line
// flow-disable-next-line
var configuredUrlBase;
var configuredUrlPath;
var configuredGraphqlRequest;
var configuredGraphqlSuccess;
var configuredGraphqlFailure;
var configuredOptionsFn;
var configuredFetchPageRequest;
var configuredFetchPageSuccess;
var configuredFetchPageFailure;
var configuredOnDataErrors;
var configuredOnCallError;

var configureGraphqlThunk = function configureGraphqlThunk(_ref) {
  var request = _ref.request,
      success = _ref.success,
      failure = _ref.failure,
      urlBase = _ref.urlBase,
      urlPath = _ref.urlPath,
      _ref$options = _ref.options,
      options = _ref$options === void 0 ? function () {
    return {};
  } : _ref$options,
      onDataErrors = _ref.onDataErrors,
      onCallError = _ref.onCallError;
  configuredGraphqlRequest = request;
  configuredGraphqlSuccess = success;
  configuredGraphqlFailure = failure;
  configuredUrlBase = urlBase;
  configuredUrlPath = urlPath;
  configuredOptionsFn = options;
  configuredOnDataErrors = onDataErrors;
  configuredOnCallError = onCallError;
};

exports.configureGraphqlThunk = configureGraphqlThunk;

var configureFetchPageThunk = function configureFetchPageThunk(_ref2) {
  var request = _ref2.request,
      success = _ref2.success,
      failure = _ref2.failure;
  configuredFetchPageRequest = request;
  configuredFetchPageSuccess = success;
  configuredFetchPageFailure = failure;
};

exports.configureFetchPageThunk = configureFetchPageThunk;

var graphqlThunk = function graphqlThunk(_ref3) {
  var _ref3$urlBase = _ref3.urlBase,
      urlBase = _ref3$urlBase === void 0 ? configuredUrlBase : _ref3$urlBase,
      _ref3$urlPath = _ref3.urlPath,
      urlPath = _ref3$urlPath === void 0 ? configuredUrlPath : _ref3$urlPath,
      authorizationBearer = _ref3.authorizationBearer,
      urlParams = _ref3.urlParams,
      mapUrlParams = _ref3.mapUrlParams,
      fields = _ref3.fields,
      mapFields = _ref3.mapFields,
      query = _ref3.query,
      mapResp = _ref3.mapResp,
      successRedirect = _ref3.successRedirect,
      onSuccess = _ref3.onSuccess,
      onInvalidFields = _ref3.onInvalidFields,
      _ref3$onDataErrors = _ref3.onDataErrors,
      onDataErrors = _ref3$onDataErrors === void 0 ? configuredOnDataErrors : _ref3$onDataErrors,
      _ref3$onCallError = _ref3.onCallError,
      onCallError = _ref3$onCallError === void 0 ? configuredOnCallError : _ref3$onCallError,
      routerHistory = _ref3.routerHistory,
      asyncKey = _ref3.asyncKey,
      _ref3$request = _ref3.request,
      request = _ref3$request === void 0 ? configuredGraphqlRequest : _ref3$request,
      _ref3$success = _ref3.success,
      success = _ref3$success === void 0 ? configuredGraphqlSuccess : _ref3$success,
      _ref3$failure = _ref3.failure,
      failure = _ref3$failure === void 0 ? configuredGraphqlFailure : _ref3$failure,
      _ref3$options = _ref3.options,
      optionsFn = _ref3$options === void 0 ? configuredOptionsFn : _ref3$options,
      _ref3$throwErr = _ref3.throwErr,
      throwErr = _ref3$throwErr === void 0 ? true : _ref3$throwErr;
  return (
    /*#__PURE__*/
    function () {
      var _ref4 = (0, _asyncToGenerator2.default)(
      /*#__PURE__*/
      _regenerator.default.mark(function _callee(dispatch) {
        var data;
        return _regenerator.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (request && success && failure) {
                  _context.next = 2;
                  break;
                }

                throw Error('You need to configure a request, success, and failure action creator before using graphqlThunk');

              case 2:
                dispatch(request(asyncKey));
                _context.prev = 3;
                _context.next = 6;
                return (0, _graphqlCall.default)((0, _objectSpread2.default)({
                  urlBase: urlBase,
                  urlPath: urlPath,
                  authorizationBearer: authorizationBearer,
                  urlParams: urlParams,
                  mapUrlParams: mapUrlParams,
                  fields: fields,
                  mapFields: mapFields,
                  query: query,
                  mapResp: mapResp
                }, optionsFn()));

              case 6:
                data = _context.sent;
                dispatch(success((0, _objectSpread2.default)({
                  data: data
                }, (0, _spread.default)({
                  asyncKey: asyncKey
                }))));

                if (data.errors) {
                  onDataErrors && onDataErrors(data);
                }

                if (data.invalidFields) {
                  onInvalidFields && onInvalidFields(data);
                }

                if (!(!data.errors && !data.invalidFields)) {
                  _context.next = 16;
                  break;
                }

                if (!successRedirect) {
                  _context.next = 15;
                  break;
                }

                if (routerHistory) {
                  _context.next = 14;
                  break;
                }

                throw Error('In order to use successRedirect, you need to provide a routerHistory to graphqlThunk');

              case 14:
                routerHistory.push(successRedirect instanceof Function ? successRedirect(data, fields) : successRedirect);

              case 15:
                onSuccess && onSuccess(data);

              case 16:
                return _context.abrupt("return", data);

              case 19:
                _context.prev = 19;
                _context.t0 = _context["catch"](3);
                dispatch(failure((0, _objectSpread2.default)({
                  error: _context.t0
                }, (0, _spread.default)({
                  asyncKey: asyncKey
                }))));
                onCallError && onCallError(_context.t0);

                if (!throwErr) {
                  _context.next = 25;
                  break;
                }

                throw _context.t0;

              case 25:
                return _context.abrupt("return", _context.t0);

              case 26:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[3, 19]]);
      }));

      return function (_x) {
        return _ref4.apply(this, arguments);
      };
    }()
  );
};

exports.graphqlThunk = graphqlThunk;

var fetchPageThunk = function fetchPageThunk(options) {
  return graphqlThunk((0, _objectSpread2.default)({}, options, {
    asyncKey: 'page',
    request: configuredFetchPageRequest,
    success: configuredFetchPageSuccess,
    failure: configuredFetchPageFailure
  }));
};

exports.fetchPageThunk = fetchPageThunk;