gambit/dist/lib/GambitApi.js

A hyper-thin library to help building API driven redux apps

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _extends3 = _interopRequireDefault(_extends2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _forEach = require('lodash/forEach');

var _forEach2 = _interopRequireDefault(_forEach);

var _mapValues = require('lodash/mapValues');

var _mapValues2 = _interopRequireDefault(_mapValues);

var _HttpError = require('./HttpError');

var _HttpError2 = _interopRequireDefault(_HttpError);

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _isPlainObject = require('lodash/isPlainObject');

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _dict = require('./dict');

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

var GambitApi = function GambitApi(endpoints, baseUrl) {
  var _this = this;

  (0, _classCallCheck3.default)(this, GambitApi);

  this._request = function (type) {
    return function () {
      var ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(_ref) {
        var apiUrl = _ref.url;
        var rest = (0, _objectWithoutProperties3.default)(_ref, ['url']);
        var response;
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (apiUrl) {
                  _context.next = 2;
                  break;
                }

                throw new Error('No URL given in API Call');

              case 2:
                rest.method = type;
                rest.headers = (0, _extends3.default)({}, rest.headers, _this.extraHeaders);
                apiUrl = _this.baseUrl.slice(-1) === '/' ? '' + _this.baseUrl + apiUrl : apiUrl.slice(0) === '/' ? '' + _this.baseUrl + apiUrl : _this.baseUrl + '/' + apiUrl;

                _context.next = 7;
                return _this.fetch(apiUrl, rest);

              case 7:
                response = _context.sent;
                return _context.abrupt('return', { body: response });

              case 9:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, _this);
      }));
      return function (_x) {
        return ref.apply(this, arguments);
      };
    }();
  };

  this.post = this._request('POST');
  this.get = this._request('GET');
  this.put = this._request('PUT');
  this.del = this._request('DELETE');

  this.setHeaders = function (headers) {
    _this.extraHeaders = headers;
  };

  this.setFetchLib = function (lib) {
    _this.fetch = lib;
  };

  this.endpoints = endpoints;
  this.baseUrl = baseUrl;
  this.fetch = function () {
    var ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(apiUrl, rest) {
      var fetchVal, response;
      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              _context2.next = 2;
              return fetch(apiUrl, rest);

            case 2:
              fetchVal = _context2.sent;

              if (fetchVal.ok) {
                _context2.next = 5;
                break;
              }

              throw new _HttpError2.default('Invalid HTTP response, status ' + fetchVal.status, { body: fetchVal });

            case 5:
              _context2.next = 7;
              return fetchVal.json();

            case 7:
              response = _context2.sent;
              return _context2.abrupt('return', response);

            case 9:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee2, _this);
    }));
    return function (_x2, _x3) {
      return ref.apply(this, arguments);
    };
  }();

  this.extraHeaders = {};
  (0, _forEach2.default)(endpoints, function (methodBag, moduleName) {
    _this[moduleName] = (0, _mapValues2.default)(methodBag, function (method) {
      return function (args) {
        (0, _invariant2.default)((0, _isPlainObject2.default)(args), (0, _dict.badApiArgs)(method));
        return method.call(_this, args);
      };
    });
  });
};

exports.default = GambitApi;