regard/lib/connectors/http.js

Sugar-interface to access multiple data sources.

var _ = require('lodash'),
    Connector = require('../connector'),
    Rest = require('unirest');

exports = module.exports = HttpConnector;

var Methods = exports.Methods = Rest.enum.methods;

var KEY = exports.KEY = Connector.generateKey(__filename);
var SETTINGS = exports.SETTINGS = {
  headers: {
    'Accept': 'application/json',
    'User-Agent': 'regard'
  },
  method: 'get'
};

function HttpConnector() {
  if (!(this instanceof HttpConnector)) {
    return new HttpConnector();
  }

  Connector.call(this, KEY, SETTINGS);

  bindHandlers(this);
}

HttpConnector.prototype = _.create(Connector.prototype);
HttpConnector.prototype.checkPath = canAcceptPath;
HttpConnector.prototype.checkMethod = canAcceptMethod;

function bindHandlers($this) {
  $this.handler(Connector.DEFAULT_HANDLER, handleRequest, beforeRequest);
  _.forEach(Methods, function bindHandler(method) {
    method = method.toLowerCase();
    $this.handler(method, handleRequest, function beforeHandler(request) {
      return _.partial(beforeRequest, request, method).apply($this, _.slice(arguments, 1));
    });
  });
}

function canAcceptPath(path) {
  return _.startsWith(path, 'http://');
}

function canAcceptMethod(method) {
  return _.isString(method) && _.includes(Methods, method.toUpperCase());
}

function beforeRequest(request, method, path, headers, body) {
  if (_.isString(method) && !canAcceptMethod(method)) {
    body = headers;
    headers = path;
    path = method;
    method = undefined;
  }

  if (_.isObject(method)) {
    body = path;
    headers = method;
    path = undefined;
    method = undefined;
  }

  if (_.isObject(path)) {
    body = headers;
    headers = path;
    path = undefined;
  }

  if (_.isString(path) && !_.isEmpty(path)) {
    request.path = [request.path, path].join('/');
  }

  if (!_.isUndefined(method)) {
    request.context.method = method;
  }

  if (_.isObject(headers)) {
    _.merge(request.context.headers, headers);
  }

  if (!_.isUndefined(body)) {
    request.context.body = body;
  }

  return request;
}

function handleRequest(request, resolve, reject) {
  var path = request.path,
      context = request.context;

  var method = context.method,
      headers = context.headers,
      body = context.body,
      options = _.omit(context, ['method', 'headers', 'body']);

  var processing = Rest(method, path, headers, body);

  _.forEach(options, function (value, key) {
    var setter = _.get(processing, key);
    if (_.isFunction(setter)) {
      setter.call(processing, value);
    }
  });

  processing.end(function (response) {
    if (response.code === 200) {
      resolve(response);
    } else {
      reject(response);
    }
  });
}