belvo
Version:
The node.js module for the Belvo API
567 lines (460 loc) • 22 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _axios = _interopRequireDefault(require("axios"));
var _package = require("../package.json");
require("core-js/stable");
require("regenerator-runtime/runtime");
var _exceptions = _interopRequireDefault(require("./exceptions"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; }
function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen["return"] !== "function") { this["return"] = undefined; } }
_AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; };
_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
_AsyncGenerator.prototype["throw"] = function (arg) { return this._invoke("throw", arg); };
_AsyncGenerator.prototype["return"] = function (arg) { return this._invoke("return", arg); };
function _awaitAsyncGenerator(value) { return new _AwaitValue(value); }
function _AwaitValue(value) { this.wrapped = value; }
function _asyncIterator(iterable) { var method; if (typeof Symbol !== "undefined") { if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator]; if (method == null && Symbol.iterator) method = iterable[Symbol.iterator]; } if (method == null) method = iterable["@@asyncIterator"]; if (method == null) method = iterable["@@iterator"]; if (method == null) throw new TypeError("Object is not async iterable"); return method.call(iterable); }
function _asyncGeneratorDelegate(inner, awaitWrap) { var iter = {}, waiting = false; function pump(key, value) { waiting = true; value = new Promise(function (resolve) { resolve(inner[key](value)); }); return { done: false, value: awaitWrap(value) }; } ; iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () { return this; }; iter.next = function (value) { if (waiting) { waiting = false; return value; } return pump("next", value); }; if (typeof inner["throw"] === "function") { iter["throw"] = function (value) { if (waiting) { waiting = false; throw value; } return pump("throw", value); }; } if (typeof inner["return"] === "function") { iter["return"] = function (value) { if (waiting) { waiting = false; return value; } return pump("return", value); }; } return iter; }
/**
* Perform a request and raise error when status is not 2XX
* @async
* @param {function} fn - Function that will perform a request
* @returns {object} Response
* @throws {RequestError|Error}
*/
function raiseForStatus(_x) {
return _raiseForStatus.apply(this, arguments);
}
/** Class representing an active Belvo API session */
function _raiseForStatus() {
_raiseForStatus = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9(fn) {
var _yield$fn, data;
return regeneratorRuntime.wrap(function _callee9$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
_context9.prev = 0;
_context9.next = 3;
return fn;
case 3:
_yield$fn = _context9.sent;
data = _yield$fn.data;
return _context9.abrupt("return", data);
case 8:
_context9.prev = 8;
_context9.t0 = _context9["catch"](0);
if (!_context9.t0.response) {
_context9.next = 14;
break;
}
throw new _exceptions["default"](_context9.t0.response.status, _context9.t0.response.data);
case 14:
throw _context9.t0;
case 15:
case "end":
return _context9.stop();
}
}
}, _callee9, null, [[0, 8]]);
}));
return _raiseForStatus.apply(this, arguments);
}
var APISession = /*#__PURE__*/function () {
/**
* Create a session.
* @param {string} url - Belvo API host URL.
*/
function APISession(url) {
_classCallCheck(this, APISession);
this.session = _axios["default"].create({
baseURL: url,
headers: {
'Content-Type': 'application/json',
'User-Agent': "belvo-js (".concat(_package.version, ")")
}
});
}
/**
* Login to Belvo API using secret key credentials.
* @async
* @param {string} secretKeyId - The Id of the key.
* @param {string} secretKeyPassword - The password of the key.
* @returns {boolean} true when login is sucessful else false.
*/
_createClass(APISession, [{
key: "login",
value: function () {
var _login = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(secretKeyId, secretKeyPassword) {
var auth;
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
auth = {
username: secretKeyId,
password: secretKeyPassword
};
_context.prev = 1;
_context.next = 4;
return raiseForStatus(this.session.get('/api/', {
auth: auth
}));
case 4:
_context.next = 10;
break;
case 6:
_context.prev = 6;
_context.t0 = _context["catch"](1);
console.log(_context.t0);
return _context.abrupt("return", false);
case 10:
this.session.defaults.auth = auth;
this.keyId = secretKeyId;
this.keyPassword = secretKeyPassword;
return _context.abrupt("return", true);
case 14:
case "end":
return _context.stop();
}
}
}, _callee, this, [[1, 6]]);
}));
function login(_x2, _x3) {
return _login.apply(this, arguments);
}
return login;
}()
/**
* Get all results from a paginated response
* @async
* @param {string} url - API endpoint
* @param {object} params - Params to filter results in get.
* @yields {object} The next result in the response.
*/
}, {
key: "getAll",
value: function getAll(url) {
var _this = this;
var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return _wrapAsyncGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
var _yield$_awaitAsyncGen, _yield$_awaitAsyncGen2, results, next, _iterator, _step, item;
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.next = 2;
return _awaitAsyncGenerator(_this.session.get(url, {
params: params
}));
case 2:
_yield$_awaitAsyncGen = _context2.sent;
_yield$_awaitAsyncGen2 = _yield$_awaitAsyncGen.data;
results = _yield$_awaitAsyncGen2.results;
next = _yield$_awaitAsyncGen2.next;
// eslint-disable-next-line no-restricted-syntax
_iterator = _createForOfIteratorHelper(results);
_context2.prev = 7;
_iterator.s();
case 9:
if ((_step = _iterator.n()).done) {
_context2.next = 15;
break;
}
item = _step.value;
_context2.next = 13;
return item;
case 13:
_context2.next = 9;
break;
case 15:
_context2.next = 20;
break;
case 17:
_context2.prev = 17;
_context2.t0 = _context2["catch"](7);
_iterator.e(_context2.t0);
case 20:
_context2.prev = 20;
_iterator.f();
return _context2.finish(20);
case 23:
if (!next) {
_context2.next = 25;
break;
}
return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(_this.getAll(next)), _awaitAsyncGenerator), "t1", 25);
case 25:
case "end":
return _context2.stop();
}
}
}, _callee2, null, [[7, 17, 20, 23]]);
}))();
}
/**
* Get a list of resources.
* @async
* @param {string} url - API endpoint
* @param {number} limit - Maximum number of results to get.
* @param {object} params - Params to filter results in get.
* @returns {array} List of resources.
*/
}, {
key: "list",
value: function () {
var _list = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(url) {
var limit,
params,
results,
pageSizeFilter,
generator,
index,
next,
_args3 = arguments;
return regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
limit = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : 100;
params = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
results = [];
pageSizeFilter = limit !== 100 ? {
page_size: Math.max(limit, 'page_size' in params ? params.page_size : 0)
} : {};
_context3.next = 6;
return this.getAll(url, _objectSpread(_objectSpread({}, params), pageSizeFilter));
case 6:
generator = _context3.sent;
index = 0;
case 8:
if (!(index < limit)) {
_context3.next = 18;
break;
}
_context3.next = 11;
return generator.next();
case 11:
next = _context3.sent;
if (!next.done) {
_context3.next = 14;
break;
}
return _context3.abrupt("break", 18);
case 14:
results.push(next.value);
case 15:
index += 1;
_context3.next = 8;
break;
case 18:
return _context3.abrupt("return", results);
case 19:
case "end":
return _context3.stop();
}
}
}, _callee3, this);
}));
function list(_x4) {
return _list.apply(this, arguments);
}
return list;
}()
/**
* Get details of a specific resource.
* @async
* @param {str} url - API endpoint
* @param {string} id - UUID4 representing the resource id.
* @returns {object}
*/
}, {
key: "get",
value: function () {
var _get = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(url, id) {
var response;
return regeneratorRuntime.wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
_context4.next = 2;
return raiseForStatus(this.session.get("".concat(url).concat(id, "/")));
case 2:
response = _context4.sent;
return _context4.abrupt("return", response);
case 4:
case "end":
return _context4.stop();
}
}
}, _callee4, this);
}));
function get(_x5, _x6) {
return _get.apply(this, arguments);
}
return get;
}()
/**
* Do a POST request to the API.
* @async
* @param {string} url - API endpoint.
* @param {object} payload - JSON request payload.
* @returns {object} Response
* @throws {RequestError}
*/
}, {
key: "post",
value: function () {
var _post = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(url, payload) {
var response;
return regeneratorRuntime.wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
_context5.next = 2;
return raiseForStatus(this.session.post(url, payload));
case 2:
response = _context5.sent;
return _context5.abrupt("return", response);
case 4:
case "end":
return _context5.stop();
}
}
}, _callee5, this);
}));
function post(_x7, _x8) {
return _post.apply(this, arguments);
}
return post;
}()
/**
* Do a PATCH request to the API.
* @async
* @param {string} url - API endpoint.
* @param {object} payload - Response
* @returns {object} Response
* @throws {RequestError}
*/
}, {
key: "patch",
value: function () {
var _patch = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(url, payload) {
var response;
return regeneratorRuntime.wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
_context6.next = 2;
return raiseForStatus(this.session.patch(url, payload));
case 2:
response = _context6.sent;
return _context6.abrupt("return", response);
case 4:
case "end":
return _context6.stop();
}
}
}, _callee6, this);
}));
function patch(_x9, _x10) {
return _patch.apply(this, arguments);
}
return patch;
}()
/**
* Do a PUT request to the API.
* @async
* @param {string} url - API endpoint.
* @param {string} id - UUID4 representing the resource Id.
* @param {object} payload - JSON request payload.
* @throws {RequestError}
*/
}, {
key: "put",
value: function () {
var _put = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(url, id, payload) {
var composedUrl, response;
return regeneratorRuntime.wrap(function _callee7$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
composedUrl = "".concat(url).concat(id, "/");
_context7.next = 3;
return raiseForStatus(this.session.put(composedUrl, payload));
case 3:
response = _context7.sent;
return _context7.abrupt("return", response);
case 5:
case "end":
return _context7.stop();
}
}
}, _callee7, this);
}));
function put(_x11, _x12, _x13) {
return _put.apply(this, arguments);
}
return put;
}()
/**
* Do a DELETE request to the API.
* @async
* @param {stroing} url - API endpoint.
* @param {string} id - UUID4 representing the resource Id.
* @returns {boolean}
* @throws {RequestError}
*/
}, {
key: "delete",
value: function () {
var _delete2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8(url, id) {
var composedUrl;
return regeneratorRuntime.wrap(function _callee8$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
composedUrl = "".concat(url).concat(id, "/");
_context8.prev = 1;
_context8.next = 4;
return raiseForStatus(this.session["delete"](composedUrl));
case 4:
_context8.next = 9;
break;
case 6:
_context8.prev = 6;
_context8.t0 = _context8["catch"](1);
return _context8.abrupt("return", false);
case 9:
return _context8.abrupt("return", true);
case 10:
case "end":
return _context8.stop();
}
}
}, _callee8, this, [[1, 6]]);
}));
function _delete(_x14, _x15) {
return _delete2.apply(this, arguments);
}
return _delete;
}()
}]);
return APISession;
}();
var _default = APISession;
exports["default"] = _default;