wreckage/lib/request.js

A convenient, modern request library built around Wreck. A fork of Wrecked.

'use strict';

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

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _boom = require('boom');

var _boom2 = _interopRequireDefault(_boom);

var _wreck = require('wreck');

var _wreck2 = _interopRequireDefault(_wreck);

var _read = require('./read');

var _read2 = _interopRequireDefault(_read);

var _defaults = require('./defaults');

var _defaults2 = _interopRequireDefault(_defaults);

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

const wrapError = (err, data) => {
  if (!err.data) {
    (0, _assign2.default)(err, { data });
  }

  if (_boom2.default.isBoom(err)) {
    return err;
  }

  const statusCode = data.statusCode >= 400 ? data.statusCode : 500;

  return _boom2.default.boomify(err, { statusCode, message: data.statusMessage });
};

const request = (() => {
  var _ref = (0, _asyncToGenerator3.default)(function* (method, uri, options = {}) {
    const requestOptions = options.request || {};
    const readOptions = options.read || {};
    const validateStatus = options.validateStatus || _defaults2.default.validateStatus;
    const errorHandling = options.errorHandling || 'throw';

    let output = {
      config: (0, _extends3.default)({
        method,
        uri
      }, options)
    };

    try {
      const response = yield _wreck2.default.request(method, uri, requestOptions);

      const { statusCode, statusMessage, headers } = response;

      output = (0, _extends3.default)({}, output, {
        headers,
        statusCode,
        statusMessage
      });

      const payload = yield (0, _read2.default)(response, readOptions);

      output = (0, _extends3.default)({}, output, {
        payload: payload.data,
        hash: payload.hash
      });

      if (validateStatus(output.statusCode) === false) {
        if (readOptions.json && Buffer.isBuffer(output.payload)) {
          // Get some info on the error, even if it disobeys our expect response type
          output.payload = output.payload.toString();
        }

        throw new _boom2.default(output.statusMessage, {
          statusCode: output.statusCode,
          data: output
        });
      }

      return output;
    } catch (err) {
      const error = wrapError(err, output);

      if (errorHandling === 'return') {
        return { error };
      }

      throw error;
    }
  });

  return function request(_x, _x2) {
    return _ref.apply(this, arguments);
  };
})();

exports.default = request;