@e-group/utils/makeBasicFetchEpic/makeBasicFetchEpic.js

eGroup team utils that share across projects.

"use strict";

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

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

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));

var _reduxObservable = require("redux-observable");

var _rxjs = require("rxjs");

var _operators = require("rxjs/operators");

var _findDeepValue = _interopRequireDefault(require("../findDeepValue"));

var _createObservableApi = _interopRequireDefault(require("../createObservableApi"));

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function makeBasicFetchEpic({
  actionType,
  apiName,
  fetchRequest,
  handleSuccess,
  handleFailure,
  debounceTime: time,
  observableMap: customized$Map,
  handleTakeUntil,
  handleBeforeFetch,
  handleAfterFetch
}) {
  const observableMap = customized$Map || _operators.switchMap;

  const basicFetchEpic = (action$, state$, dependencies = {}) => action$.pipe((0, _reduxObservable.ofType)(actionType), (0, _operators.debounceTime)(time !== null && time !== void 0 ? time : 0), observableMap(action => {
    const beforeFetch = handleBeforeFetch ? handleBeforeFetch(action, dependencies) : (0, _rxjs.of)();
    const afterFetch = handleAfterFetch ? handleAfterFetch(action, dependencies) : (0, _rxjs.of)();
    const cancelRequest = handleTakeUntil ? handleTakeUntil(action$) : (0, _operators.tap)(() => {}); // we can concat observable actions
    // see this comment https://github.com/redux-observable/redux-observable/issues/62#issuecomment-266337873

    const apis = dependencies.apis;

    if (!apis) {
      return (0, _rxjs.throwError)(new Error('makeBasicFetchEpic need setup apis dependency.'));
    }

    const api = (0, _findDeepValue.default)(apis, apiName);

    if (!api) {
      return (0, _rxjs.throwError)(new Error("".concat(apiName, " is missing in apis dependency.")));
    }

    let apiPayload = action.payload;

    if (action.payload && typeof action.payload === 'object' && !Array.isArray(action.payload)) {
      // Destructuring `callback` automatically it's used to execute method after api finish.
      const _action$payload = action.payload,
            callback = _action$payload.callback,
            payload = (0, _objectWithoutProperties2.default)(_action$payload, ["callback"]);
      apiPayload = payload;
    }

    return (0, _rxjs.concat)(beforeFetch, (0, _rxjs.of)(fetchRequest()), (0, _createObservableApi.default)(api(apiPayload)).pipe((0, _operators.switchMap)(response => handleSuccess(response, _objectSpread({
      action$,
      state$,
      action
    }, dependencies))), cancelRequest, (0, _operators.catchError)(error => handleFailure(error, _objectSpread({
      action$,
      state$,
      action
    }, dependencies)))), afterFetch);
  }));

  return basicFetchEpic;
}