@shoutem/redux-io/middleware.js

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _errorActionsMap, _actionHandlers;

exports.makeIndexAction = makeIndexAction;
exports.makeObjectAction = makeObjectAction;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _reduxBatchedActions = require('redux-batched-actions');

var _rio = require('./rio');

var _rio2 = _interopRequireDefault(_rio);

var _status = require('./status');

var _outdated = require('./outdated');

var _outdated2 = _interopRequireDefault(_outdated);

var _jsonApiStandardizer = require('./standardizers/json-api-standardizer');

var _consts = require('./consts');

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /* eslint-disable no-unused-expressions */
/* eslint no-console: ["error", {allow: ["warn", "error"] }] */


var actionsWithoutPayload = new Set([_consts.REMOVE_SUCCESS, _consts.LOAD_REQUEST, _consts.CREATE_REQUEST, _consts.LOAD_ERROR, _consts.CREATE_ERROR, _consts.UPDATE_ERROR, _consts.REMOVE_ERROR]);

var actionsWithTags = new Set([_consts.LOAD_REQUEST, _consts.LOAD_SUCCESS, _consts.LOAD_ERROR]);

/**
 * Map used to resolve actions in case action.error = true to appropriate ERROR actions
 * for RIO to be able to dispatch actions for reducers.
 * @type {{}}
 */
var errorActionsMap = (_errorActionsMap = {}, _defineProperty(_errorActionsMap, _consts.LOAD_REQUEST, _consts.LOAD_ERROR), _defineProperty(_errorActionsMap, _consts.LOAD_ERROR, _consts.LOAD_ERROR), _defineProperty(_errorActionsMap, _consts.CREATE_REQUEST, _consts.CREATE_ERROR), _defineProperty(_errorActionsMap, _consts.CREATE_ERROR, _consts.CREATE_ERROR), _defineProperty(_errorActionsMap, _consts.UPDATE_REQUEST, _consts.UPDATE_ERROR), _defineProperty(_errorActionsMap, _consts.UPDATE_ERROR, _consts.UPDATE_ERROR), _defineProperty(_errorActionsMap, _consts.REMOVE_REQUEST, _consts.REMOVE_ERROR), _defineProperty(_errorActionsMap, _consts.REMOVE_ERROR, _consts.REMOVE_ERROR), _errorActionsMap);

var outdated = new _outdated2.default();

function makeErrorAction(actionType, errorPayload) {
  return {
    type: actionType,
    payload: errorPayload,
    error: true
  };
}

function makeIndexAction(sourceAction, actionType, data, schema) {
  var tag = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '*';

  if (!actionType) {
    console.error('Action type is not valid.');
    return makeErrorAction(_consts.COLLECTION_ERROR, 'Action type is not valid.');
  }
  if (!data) {
    console.error('Data is not valid.');
    return makeErrorAction(_consts.COLLECTION_ERROR, 'Data is not valid.');
  }
  if (!schema) {
    console.error('Schema is not valid.');
    return makeErrorAction(_consts.COLLECTION_ERROR, 'Schema is not valid.');
  }
  if (tag === undefined || tag === null) {
    console.error('Tag is not valid.');
    return makeErrorAction(_consts.COLLECTION_ERROR, 'Tag is not valid.');
  }

  return {
    type: actionType,
    payload: data,
    meta: _extends({}, sourceAction.meta, {
      schema: schema,
      tag: tag
    })
  };
}

function makeObjectAction(sourceAction, actionType, item) {
  if (!actionType) {
    console.error('Action type is not valid.');
    return makeErrorAction(_consts.OBJECT_ERROR, 'Action type is not valid.');
  }
  if (!item) {
    console.error('Data is not valid.');
    return makeErrorAction(_consts.OBJECT_ERROR, 'Data is not valid.');
  }
  if (!_lodash2.default.get(item, 'type')) {
    console.error('Schema is not valid.');
    return makeErrorAction(_consts.OBJECT_ERROR, 'Schema is not valid.');
  }
  if (!_lodash2.default.get(item, 'id')) {
    console.error('Id is not valid.');
    return makeErrorAction(_consts.OBJECT_ERROR, 'Id is not valid.');
  }

  // finds appropriate standardizer for transformation
  var transform = _rio2.default.getStandardizer(sourceAction.meta.source);
  // transforms item into standard model
  var transformation = transform(item);

  return {
    type: actionType,
    payload: transformation.transformedObject,
    meta: _extends({}, sourceAction.meta, {
      schema: _lodash2.default.get(item, 'type'),
      transformation: transformation.transformationDescription
    })
  };
}

var getData = function getData(payload) {
  var data = payload && payload.data || [];
  return [].concat(data);
};

var getIncluded = function getIncluded(payload) {
  return _lodash2.default.get(payload, 'included', []);
};

var getLinks = function getLinks(payload) {
  var links = _lodash2.default.get(payload, 'links');
  if (!links) {
    return null;
  }

  return {
    prev: links.prev || null,
    next: links.next || null,
    self: links.self || null,
    last: links.last || null
  };
};

function saveLinks(action, dispatch) {
  var _action$meta = action.meta,
      schema = _action$meta.schema,
      tag = _action$meta.tag;

  var links = getLinks(action.payload);

  if (links) {
    dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { links: links }, schema, tag));
  }
}

var getMeta = function getMeta(payload) {
  return _lodash2.default.get(payload, 'meta');
};

function saveMeta(action, dispatch) {
  var _action$meta2 = action.meta,
      schema = _action$meta2.schema,
      tag = _action$meta2.tag;

  var meta = getMeta(action.payload);

  if (meta) {
    dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { meta: meta }, schema, tag));
  }
}

var actionHandlers = (_actionHandlers = {}, _defineProperty(_actionHandlers, _consts.LOAD_REQUEST, function (action, data, dispatch) {
  // Make collection busy to prevent multiple requests
  var _action$meta3 = action.meta,
      schema = _action$meta3.schema,
      tag = _action$meta3.tag;

  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { busyStatus: _status.busyStatus.BUSY }, schema, tag));
}), _defineProperty(_actionHandlers, _consts.LOAD_SUCCESS, function (action, data, dispatch) {
  // Dispatch objects to storages and collection with specific tag
  var _action$meta4 = action.meta,
      schema = _action$meta4.schema,
      tag = _action$meta4.tag;


  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_FETCHED, item));
  });
  // TODO: once when we support findOne action and single reducer, REFERENCE_FETCHED
  // should trigger only for collections
  dispatch(makeIndexAction(action, _consts.REFERENCE_FETCHED, data, schema, tag));

  saveMeta(action, dispatch);
  saveLinks(action, dispatch);
}), _defineProperty(_actionHandlers, _consts.LOAD_ERROR, function (action, data, dispatch) {
  // Invalidate and idle collection on error
  var _action$meta5 = action.meta,
      schema = _action$meta5.schema,
      tag = _action$meta5.tag;

  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, {
    busyStatus: _status.busyStatus.IDLE,
    validationStatus: _status.validationStatus.INVALID,
    error: true
  }, schema, tag));
}), _defineProperty(_actionHandlers, _consts.CREATE_REQUEST, function (action, data, dispatch) {
  // Change collection status to busy and invalid to prevent fetching.
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.BUSY }, schema));
}), _defineProperty(_actionHandlers, _consts.CREATE_SUCCESS, function (action, data, dispatch) {
  // Dispatch created objects to storage and change collection status to invalid, idle
  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_CREATED, item));
  });
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.IDLE }, schema));
}), _defineProperty(_actionHandlers, _consts.CREATE_ERROR, function (action, data, dispatch) {
  // Change collection status to idle and invalid to fetch again.
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, {
    validationStatus: _status.validationStatus.INVALID,
    busyStatus: _status.busyStatus.IDLE
  }, schema));
}), _defineProperty(_actionHandlers, _consts.UPDATE_REQUEST, function (action, data, dispatch) {
  // Change collection status to busy and invalid to prevent fetching and because of
  // local changes in storage state with updated item.
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.BUSY }, schema));
  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_UPDATING, item));
  });
}), _defineProperty(_actionHandlers, _consts.UPDATE_SUCCESS, function (action, data, dispatch) {
  // Dispatch updated objects from and change collections status to idle & invalid
  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_UPDATED, item));
  });
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.IDLE }, schema));
}), _defineProperty(_actionHandlers, _consts.UPDATE_ERROR, function (action, data, dispatch) {
  // Change collection status to idle and invalid
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, {
    validationStatus: _status.validationStatus.INVALID,
    busyStatus: _status.busyStatus.IDLE
  }, schema));
}), _defineProperty(_actionHandlers, _consts.REMOVE_REQUEST, function (action, data, dispatch) {
  // Change collections status to busy and invalid because of removing item in
  // local storage state
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.BUSY }, schema));
  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_REMOVING, item));
  });
}), _defineProperty(_actionHandlers, _consts.REMOVE_SUCCESS, function (action, data, dispatch) {
  // Remove object if already not removed during request
  data.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_REMOVED, item));
  });
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, { validationStatus: _status.validationStatus.INVALID, busyStatus: _status.busyStatus.IDLE }, schema));
}), _defineProperty(_actionHandlers, _consts.REMOVE_ERROR, function (action, data, dispatch) {
  // Change collections status to idle and invalid
  var schema = action.meta.schema;
  dispatch(makeIndexAction(action, _consts.REFERENCE_STATUS, {
    validationStatus: _status.validationStatus.INVALID,
    busyStatus: _status.busyStatus.IDLE
  }, schema));
}), _actionHandlers);

function shouldContainPayload(action) {
  return !(actionsWithoutPayload.has(action.type) || _lodash2.default.get(action, 'meta.response.status') === 204);
}

function isValidAction(action) {
  if (!actionHandlers[action.type]) {
    // we are not responsible for handling action
    return false;
  }
  // Check for meta object in action
  if (action.meta === undefined) {
    console.error('Meta is undefined.');
    return false;
  }
  var meta = action.meta;
  // Check if source exists
  if (meta.source === undefined) {
    console.error('Source is undefined.');
    return false;
  }
  // Source value exists but check if rio support standardization of such source type
  if (!_rio2.default.getStandardizer(meta.source)) {
    return false;
  }
  // Check that schema is defined
  if (!meta.schema) {
    console.error('Action.meta.schema is undefined.');
    return false;
  }
  // Validate payload for payload-specific action, ignore others
  if (shouldContainPayload(action)) {
    // TODO: move this into standardizer specific area once json standardization is supported
    if (!_lodash2.default.has(action, 'payload')) {
      console.error('Response should contain payload.');
      return false;
    }
    if (meta.source === _jsonApiStandardizer.JSON_API_SOURCE && !_lodash2.default.has(action, 'payload.data')) {
      console.error(_jsonApiStandardizer.JSON_API_SOURCE + ' response should contain payload.data.');
      return false;
    }
  }
  // Validate tag for tag-specific action, ignore others
  if (actionsWithTags.has(action.type) && !_lodash2.default.isString(_lodash2.default.get(action, 'meta.tag'))) {
    console.error('Tag is invalid, expecting meta.tag');
    return false;
  }

  return true;
}

/**
 * Handled failed redux-api-middleware request.
 *
 * @param action
 * @param dispatch
 * @returns {*}
 */
function handleFailedRequest(action, dispatch) {
  var errorAction = errorActionsMap[action.type];

  if (!errorAction) {
    console.warn('Can not handle failed request for action type ' + action.type + '.');
    return;
  }

  // Update reference status for corresponding error action
  actionHandlers[errorAction](action, undefined, dispatch);
}

/**
 * Handle any request related action and dispatch corresponding state updating actions.
 * Add batched actions to update state data and/or status.
 * @param action
 * @param dispatch
 */
function handleNetworkAction(action, dispatch) {
  // First dispatch included objects
  var included = getIncluded(action.payload);
  included.map(function (item) {
    return dispatch(makeObjectAction(action, _consts.OBJECT_FETCHED, item));
  });

  var data = getData(action.payload);
  // Find handler for supported action type to make appropriate logic
  actionHandlers[action.type](action, data, dispatch);
}

exports.default = function (store) {
  return function (next) {
    return function (action) {
      // Validate action, if not valid pass
      if (!isValidAction(action)) {
        return next(action);
      }

      if (outdated.isOutdated(action)) {
        return next(action);
      }
      outdated.reportChange(action);

      // TODO: add standardization of whole payload once we support json standardization

      var actions = [];
      var dispatch = function dispatch(dispatchAction) {
        return actions.push(dispatchAction);
      };

      if (action.error) {
        // Request which thrown an error
        handleFailedRequest(action, dispatch);
      } else {
        handleNetworkAction(action, dispatch);
      }

      if (!_lodash2.default.isEmpty(actions)) {
        store.dispatch((0, _reduxBatchedActions.batchActions)(actions));
      }

      // After middleware handled action pass input action to next
      return next(action);
    };
  };
};