craft-ai/lib/request.js

'use strict';

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

var _slicedToArray = function () { function sliceIterator(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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.default = createRequest;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _constants = require('./constants');

var _package = require('../package.json');

var _errors = require('./errors');

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

var fetch = !_constants.IN_BROWSER && typeof fetch === 'undefined' ? require('node-fetch') : window.fetch;

var debug = (0, _debug2.default)('craft-ai:client');

var USER_AGENT = 'craft-ai-client-js/' + _package.version + ' [' + (_constants.IN_BROWSER ? navigator.userAgent : 'Node.js ' + process.version) + ']';

debug('Client user agent set to \'' + USER_AGENT + '\'');

function parseBody(req, resBody) {
  var resBodyUtf8 = void 0;
  try {
    resBodyUtf8 = resBody.toString('utf-8');
  } catch (err) {
    debug('Invalid response format from ' + req.method + ' ' + req.path + ': ' + resBody, err);
    throw new _errors.CraftAiInternalError('Internal Error, the craft ai server responded in an invalid format.', {
      request: req
    });
  }
  var resBodyJson = void 0;
  try {
    if (resBodyUtf8.length > 0) {
      resBodyJson = JSON.parse(resBodyUtf8);
    } else {
      resBodyJson = {};
    }
  } catch (err) {
    debug('Invalid json response from ' + req.method + ' ' + req.path + ': ' + resBody, err);
    throw new _errors.CraftAiInternalError('Internal Error, the craft ai server responded an invalid json document.', {
      more: resBodyUtf8,
      request: req
    });
  }
  return resBodyJson;
}

function parseBulk(req, res, resBody) {
  if (_lodash2.default.isArray(JSON.parse(resBody))) {
    return { body: parseBody(req, resBody) };
  } else {
    throw new _errors.CraftAiBadRequestError({
      message: parseBody(req, resBody).message,
      request: req
    });
  }
}

function parseResponse(req, res, resBody) {
  switch (res.status) {
    case 200:
    case 201:
    case 204:
      return {
        body: parseBody(req, resBody),
        nextPageUrl: res.headers.get('x-craft-ai-next-page-url')
      };
    case 202:
      throw new _errors.CraftAiLongRequestTimeOutError({
        message: parseBody(req, resBody).message,
        request: req
      });
    case 207:
      return parseBulk(req, res, resBody);
    case 401:
    case 403:
      throw new _errors.CraftAiCredentialsError({
        message: parseBody(req, resBody).message,
        request: req
      });
    case 400:
    case 404:
      return parseBulk(req, res, resBody);
    case 413:
      throw new _errors.CraftAiBadRequestError({
        message: 'Given payload is too large',
        request: req
      });
    case 500:
      throw new _errors.CraftAiInternalError(parseBody(req, resBody).message, {
        request: req
      });
    case 504:
      throw new _errors.CraftAiInternalError({
        message: 'Response has timed out',
        request: req,
        status: res.status
      });
    default:
      throw new _errors.CraftAiUnknownError({
        more: parseBody(req, resBody).message,
        request: req,
        status: res.status
      });
  }
}

function createHttpAgent() {
  var proxy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;

  if (_constants.IN_BROWSER) {
    return undefined;
  } else if (proxy) {
    var HttpProxyAgent = require('http-proxy-agent');

    return new HttpProxyAgent(proxy);
  } else {
    var http = require('http');

    return new http.Agent({
      keepAlive: true
    });
  }
}

function createHttpsAgent() {
  var proxy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;

  if (_constants.IN_BROWSER) {
    return undefined;
  } else if (proxy) {
    var HttpsProxyAgent = require('https-proxy-agent');

    return new HttpsProxyAgent(proxy);
  } else {
    var https = require('https');

    return new https.Agent({
      keepAlive: true
    });
  }
}

function createRequest(cfg) {
  var defaultHeaders = {
    'Authorization': 'Bearer ' + cfg.token,
    'Content-Type': 'application/json; charset=utf-8',
    'Accept': 'application/json'
  };

  if (!_constants.IN_BROWSER) {
    // Don't set the user agent in browsers it can cause CORS issues
    // e.g. Safari v10.1.2 (12603.3.8)
    defaultHeaders['User-Agent'] = USER_AGENT;
  }

  var baseUrl = cfg.url + '/api/v1/' + cfg.owner + '/' + cfg.project;

  var agent = baseUrl.slice(0, 5) === 'https' ? createHttpsAgent(cfg.proxy) : createHttpAgent(cfg.proxy);

  return function (req) {
    req = _lodash2.default.defaults(req || {}, {
      agent: agent,
      method: 'GET',
      path: '',
      body: undefined,
      query: {},
      headers: {}
    });

    req.url = req.url || '' + baseUrl + req.path;

    var queryStr = (0, _lodash2.default)(req.query).map(function (value, key) {
      return [key, value];
    }).filter(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];

      return !_lodash2.default.isUndefined(value);
    }).map(function (keyVal) {
      return keyVal.join('=');
    }).join('&');

    if (queryStr.length > 0) {
      req.url += '?' + queryStr;
    }
    req.headers = _lodash2.default.defaults(req.headers, defaultHeaders);

    req.body = req.body && JSON.stringify(req.body);

    return fetch(req.url, req).catch(function (err) {
      debug('Network error while executing ' + req.method + ' ' + req.path, err);
      return Promise.reject(new _errors.CraftAiNetworkError({
        more: err.message
      }));
    }).then(function (res) {
      return res.text().catch(function (err) {
        debug('Invalid response from ' + req.method + ' ' + req.path, err);

        throw new _errors.CraftAiInternalError('Internal Error, the craft ai server responded an invalid response, see err.more for details.', {
          request: req,
          more: err.message
        });
      }).then(function (resBody) {
        return parseResponse(req, res, resBody);
      });
    });
  };
}