sharyn/client/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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/objectSpread"));

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

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

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

// flow-disable-next-line
var configuredGraphqlRequest;
var configuredGraphqlSuccess;
var configuredGraphqlFailure;
var configuredFetchPageRequest;
var configuredFetchPageSuccess;
var configuredFetchPageFailure;

var configureGraphqlThunk = function configureGraphqlThunk(_ref) {
  var request = _ref.request,
      success = _ref.success,
      failure = _ref.failure;
  configuredGraphqlRequest = request;
  configuredGraphqlSuccess = success;
  configuredGraphqlFailure = failure;
};

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 urlBase = _ref3.urlBase,
      urlPath = _ref3.urlPath,
      authorizationBearer = _ref3.authorizationBearer,
      urlParams = _ref3.urlParams,
      mapUrlParams = _ref3.mapUrlParams,
      fields = _ref3.fields,
      mapFields = _ref3.mapFields,
      query = _ref3.query,
      mapResp = _ref3.mapResp,
      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$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)({
                  urlBase: urlBase,
                  urlPath: urlPath,
                  authorizationBearer: authorizationBearer,
                  urlParams: urlParams,
                  mapUrlParams: mapUrlParams,
                  fields: fields,
                  mapFields: mapFields,
                  query: query,
                  mapResp: mapResp
                });

              case 6:
                data = _context.sent;
                dispatch(success({
                  data: data,
                  asyncKey: asyncKey
                }));
                _context.next = 15;
                break;

              case 10:
                _context.prev = 10;
                _context.t0 = _context["catch"](3);
                dispatch(failure({
                  error: _context.t0,
                  asyncKey: asyncKey
                }));

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

                throw _context.t0;

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

      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;