bankson-js/lib/client.js

Bankson.fi Node client

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _applications = require('./ext/applications');

var _applications2 = _interopRequireDefault(_applications);

var _webhooks = require('./ext/webhooks');

var _webhooks2 = _interopRequireDefault(_webhooks);

var _certificates = require('./ext/certificates');

var _certificates2 = _interopRequireDefault(_certificates);

var _calls = require('./ext/calls');

var _calls2 = _interopRequireDefault(_calls);

var _bankAccounts = require('./ext/bank-accounts');

var _bankAccounts2 = _interopRequireDefault(_bankAccounts);

var _bankAccountStatements = require('./ext/bank-account-statements');

var _bankAccountStatements2 = _interopRequireDefault(_bankAccountStatements);

var _payments = require('./ext/payments');

var _payments2 = _interopRequireDefault(_payments);

var _inboundPayments = require('./ext/inbound-payments');

var _inboundPayments2 = _interopRequireDefault(_inboundPayments);

var _apikeys = require('./ext/apikeys');

var _apikeys2 = _interopRequireDefault(_apikeys);

var _nodeRsa = require('node-rsa');

var _nodeRsa2 = _interopRequireDefault(_nodeRsa);

var _formData = require('form-data');

var _formData2 = _interopRequireDefault(_formData);

var _nodeFetch = require('node-fetch');

var _nodeFetch2 = _interopRequireDefault(_nodeFetch);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Headers = _nodeFetch2.default.Headers || window.Headers; // We are in a browser

var Client = function () {
  function Client() {
    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    _classCallCheck(this, Client);

    this.applications = new _applications2.default(this);
    this.webhooks = new _webhooks2.default(this);
    this.certificates = new _certificates2.default(this);
    this.calls = new _calls2.default(this);
    this.bankAccounts = new _bankAccounts2.default(this);
    this.bankAccountStatements = new _bankAccountStatements2.default(this);
    this.payments = new _payments2.default(this);
    this.apikeys = new _apikeys2.default(this);
    this.inboundPayments = new _inboundPayments2.default(this);
    this.beforeRequest = opts.beforeRequest || function () {
      return Promise.resolve();
    };
    this.bearerToken = opts.bearerToken || '-';
    this.baseUrl = opts.baseUrl || 'https://api.bankson.fi';
    this.testMode = typeof opts.test !== 'undefined' ? opts.test : false;
    if (opts.privateKey && opts.apiKey) {
      // ApiKey authentication
      this.bearerToken = false;
      this.privateKey = new _nodeRsa2.default();
      this.privateKey.importKey(opts.privateKey, 'private');
      if (!this.privateKey.isPrivate()) throw new Error('Invalid private key');
      this.apiKey = opts.apiKey;
    }
  }

  _createClass(Client, [{
    key: 'me',
    value: function me() {
      return this.get('/me');
    }
  }, {
    key: 'authorizationHeader',
    value: function authorizationHeader(bearerToken) {
      if (this.bearerToken) return 'Bearer ' + bearerToken;
      var timestamp = Date.now(),
          str = this.apiKey + timestamp,
          signature = this.privateKey.sign(str, 'base64');
      return 'BanksonRSA ' + ['ApiKey=' + this.apiKey, 'Timestamp=' + timestamp, 'Signature=' + signature].join(', ');
    }
  }, {
    key: 'headers',
    value: function headers() {
      var _this = this;

      var additionalHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.beforeRequest().then(function (result) {
        var bearerToken = result && result.bearerToken || _this.bearerToken,
            banksonTest = result && typeof result.test !== 'undefined' ? result.test : _this.testMode,
            headers = new Headers();
        headers.append('Accept', additionalHeaders.Accept || 'application/json');
        headers.append('Authorization', _this.authorizationHeader(bearerToken));
        if (banksonTest) headers.append('X-Bankson-Environment', 'Test');
        return headers;
      });
    }
  }, {
    key: 'get',
    value: function get(path) {
      var _this2 = this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      return this.headers(options.headers).then(function (headers) {
        return (0, _nodeFetch2.default)('' + _this2.baseUrl + path, { headers: headers }).then(function (resp) {
          return _this2.handleResponse(resp, options);
        });
      });
    }
  }, {
    key: 'post',
    value: function post(path, data) {
      return this.request('POST', path, data);
    }
  }, {
    key: 'put',
    value: function put(path, data) {
      return this.request('PUT', path, data);
    }
  }, {
    key: 'request',
    value: function request(method, path, data) {
      var _this3 = this;

      return this.headers().then(function (headers) {
        var isFormData = data instanceof _formData2.default;
        if (!isFormData) {
          headers.append('Content-Type', 'application/json');
        }
        return (0, _nodeFetch2.default)('' + _this3.baseUrl + path, {
          method: method,
          body: isFormData ? data : JSON.stringify(data),
          headers: headers
        }).then(_this3.handleResponse);
      });
    }
  }, {
    key: 'delete',
    value: function _delete(path) {
      var _this4 = this;

      return this.headers().then(function (headers) {
        return (0, _nodeFetch2.default)('' + _this4.baseUrl + path, {
          method: 'DELETE',
          headers: headers
        });
      }).then(this.handleResponse);
    }
  }, {
    key: 'handleResponse',
    value: function handleResponse(resp) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      if (!resp.ok) {
        if (resp.status >= 500 || resp.status < 400) throw new Error('Internal error');
        return getBody(resp).then(function (json) {
          var err = new Error('Request unsuccessfull');
          err.status = resp.status;
          err.body = json;
          throw err;
        });
      }
      return getBody(resp);

      function getBody(resp) {
        if (!/application\/json/.test(resp.headers.get('Content-Type'))) {
          if (options.responseType === 'arraybuffer') return resp.arrayBuffer();
          return resp.text();
        }
        return resp.json();
      }
    }
  }]);

  return Client;
}();

exports.default = Client;