koiki/lib/proxy.js

'use strict';

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

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

var _assign2 = _interopRequireDefault(_assign);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

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

var _extends3 = _interopRequireDefault(_extends2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

exports.default = proxy;

var _pathToRegexp = require('path-to-regexp');

var _pathToRegexp2 = _interopRequireDefault(_pathToRegexp);

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

require('isomorphic-fetch');

var _urlPattern = require('url-pattern');

var _urlPattern2 = _interopRequireDefault(_urlPattern);

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

var fetcher = function fetcher(options, res, after, logger) {
  logger.apply(undefined, ['# Proxing'].concat((0, _toConsumableArray3.default)(options)));
  fetch.apply(undefined, (0, _toConsumableArray3.default)(options)).then(function (apiRes) {
    if (apiRes.ok) {
      apiRes.json().then(function (json) {
        return after(json, function (converted) {
          return res.json(converted);
        });
      }, function () {
        return res.json({});
      });
    } else {
      apiRes.json().then(function (json) {
        return res.status(apiRes.status).json(json);
      }, function () {
        return res.status(apiRes.status).json({});
      });
    }
  }, function (err) {
    return logger('# Fetch Error ', options, err) || res.json(err);
  }).catch(function (err) {
    return logger('# Unexpected Error ', {}, err) || res.json(err);
  });
};

function proxy(_ref) {
  var app = _ref.app,
      protocol = _ref.protocol,
      host = _ref.host,
      prefix = _ref.prefix,
      customizer = _ref.customizer,
      _ref$before = _ref.before,
      before = _ref$before === undefined ? function (url, options, cb) {
    return cb([url, options]);
  } : _ref$before,
      _ref$after = _ref.after,
      after = _ref$after === undefined ? function (json, cb) {
    return cb(json);
  } : _ref$after,
      _ref$logger = _ref.logger,
      logger = _ref$logger === undefined ? function (title, data, err) {
    return console.log(title, _util2.default.inspect(data), _util2.default.inspect(err));
  } : _ref$logger;

  app.use(prefix + '/*', function (req, res) {
    var apiUri = req.originalUrl.replace(new RegExp(prefix), '');
    var url = protocol + '://' + host + apiUri;
    var options = [url, {
      method: req.method,
      headers: (0, _extends3.default)({}, req.headers, {
        host: host
      })
    }];
    var originalUrl = req.originalUrl.split('?')[0];
    if (req.body) {
      options[1].body = (0, _stringify2.default)(req.body);
    }
    var customizerBefore = void 0;
    var customizerAfter = void 0;
    var customizerOverride = void 0;
    if (customizer) {
      var keys = (0, _keys2.default)((0, _assign2.default)({}, req.params)).map(function (key) {
        return {
          name: key,
          prefix: '/',
          delimiter: '/'
        };
      });
      (0, _keys2.default)(customizer).some(function (uri) {
        if ((0, _pathToRegexp2.default)(uri, keys).exec(originalUrl) && customizer[uri] && customizer[uri][req.method]) {
          customizerBefore = customizer[uri][req.method].before;
          customizerAfter = customizer[uri][req.method].after;
          customizerOverride = customizer[uri][req.method].override;
          var pattern = new _urlPattern2.default(uri);
          req.params = pattern.match(originalUrl);
        }
      });
    }

    if (customizerOverride) {
      logger('# Proxing with override', url);
      customizerOverride(req, res);
    } else {
      (customizerBefore || before).apply(undefined, options.concat([function (fetchOptions) {
        return fetcher(fetchOptions, res, customizerAfter || after, logger);
      }]));
    }
  });
}
module.exports = exports['default'];