devour-client/lib/middleware/json-api/res-errors.js

A lightweight, framework agnostic, flexible JSON API client

"use strict";

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var Logger = require('../../logger');

function defaultErrorBuilder(error) {
  var title = error.title,
      detail = error.detail;
  return {
    title: title,
    detail: detail
  };
}

function getBuildErrors(options) {
  return function buildErrors(serverErrors) {
    if (!serverErrors) {
      Logger.error('Unidentified error');
      return;
    }

    var errorBuilder = options && options.errorBuilder || defaultErrorBuilder;
    var errors = {};

    if (serverErrors.errors) {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = serverErrors.errors.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var _step$value = _slicedToArray(_step.value, 2),
              index = _step$value[0],
              error = _step$value[1];

          errors[errorKey(index, error.source)] = errorBuilder(error);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
            _iterator["return"]();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }

    if (serverErrors.error) {
      errors.data = {
        title: serverErrors.error
      };
    }

    return errors;
  };
}

function errorKey(index, source) {
  if (!source || source.pointer == null) {
    return index;
  }

  return source.pointer.split('/').pop();
}

exports.getMiddleware = function (options) {
  var buildErrors = getBuildErrors(options);
  return {
    name: 'errors',
    error: function error(payload) {
      if (payload.response) {
        var response = payload.response;

        if (response.data) {
          if (typeof response.data === 'string') {
            var error = response.statusText ? "".concat(response.statusText, ": ").concat(response.data) : response.data;
            return buildErrors({
              error: error
            });
          }

          return buildErrors(response.data);
        }

        return buildErrors({
          error: response.statusText
        });
      }

      if (payload instanceof Error) {
        return payload;
      }

      return null;
    }
  };
};