@artaio/node-api 1.9.0 → 1.9.1

package/dist/lib/endpoint/uploads.js

@@ -1,27 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UploadsEndpoint = void 0;
-var endpoint_1 = require("./endpoint");
-var UploadsEndpoint = /** @class */ (function () {
-    function UploadsEndpoint(artaClient) {
+const endpoint_1 = require("./endpoint");
+class UploadsEndpoint {
+    constructor(artaClient) {
         this.artaClient = artaClient;
         this.path = '/uploads';
         this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
     }
-    UploadsEndpoint.prototype.getById = function (id, auth) {
+    getById(id, auth) {
         return this.defaultEndpoint.getById(id, auth);
-    };
-    UploadsEndpoint.prototype.list = function (page, pageSize, auth) {
-        if (page === void 0) { page = 1; }
-        if (pageSize === void 0) { pageSize = 20; }
-        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
-    };
-    UploadsEndpoint.prototype.create = function (payload, auth) {
+    }
+    list(page = 1, pageSize = 20, auth) {
+        return this.defaultEndpoint.list({ page, page_size: pageSize }, auth);
+    }
+    create(payload, auth) {
         return this.defaultEndpoint.create({ upload: payload }, auth);
-    };
-    UploadsEndpoint.prototype.remove = function (id, auth) {
+    }
+    remove(id, auth) {
         return this.defaultEndpoint.remove(id, auth);
-    };
-    return UploadsEndpoint;
-}());
+    }
+}
 exports.UploadsEndpoint = UploadsEndpoint;

package/dist/lib/endpoint/webhookDeliveries.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhookDeliveriesEndpoint = void 0;
-var endpoint_1 = require("./endpoint");
-var WebhookDeliveriesEndpoint = /** @class */ (function () {
-    function WebhookDeliveriesEndpoint(artaClient) {
+const endpoint_1 = require("./endpoint");
+class WebhookDeliveriesEndpoint {
+    constructor(artaClient) {
         this.artaClient = artaClient;
         this.path = '/webhook_deliveries';
         this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient);
     }
-    WebhookDeliveriesEndpoint.prototype.getById = function (id, auth) {
+    getById(id, auth) {
         return this.defaultEndpoint.getById(id, auth);
-    };
-    WebhookDeliveriesEndpoint.prototype.list = function (page, pageSize, auth) {
-        if (page === void 0) { page = 1; }
-        if (pageSize === void 0) { pageSize = 20; }
-        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
-    };
-    return WebhookDeliveriesEndpoint;
-}());
+    }
+    list(page = 1, pageSize = 20, auth) {
+        return this.defaultEndpoint.list({ page, page_size: pageSize }, auth);
+    }
+}
 exports.WebhookDeliveriesEndpoint = WebhookDeliveriesEndpoint;

package/dist/lib/endpoint/webhooks.js

@@ -1,124 +1,49 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhooksEndpoint = void 0;
-var endpoint_1 = require("./endpoint");
-var WebhooksEndpoint = /** @class */ (function () {
-    function WebhooksEndpoint(artaClient) {
+const endpoint_1 = require("./endpoint");
+class WebhooksEndpoint {
+    constructor(artaClient) {
         this.artaClient = artaClient;
         this.path = '/webhooks';
         this.defaultEndpoint = new endpoint_1.DefaultEndpoint(this.path, this.artaClient, this.withFunctionCalls.bind(this));
     }
-    WebhooksEndpoint.prototype.withFunctionCalls = function (webhook) {
-        var _this = this;
-        webhook.ping = function (auth) { return _this.ping(webhook.id, auth); };
-        webhook.getSecret = function (auth) { return _this.getSecret(webhook.id, auth); };
-        webhook.resetSecret = function (auth) { return _this.resetSecret(webhook.id, auth); };
+    withFunctionCalls(webhook) {
+        webhook.ping = (auth) => this.ping(webhook.id, auth);
+        webhook.getSecret = (auth) => this.getSecret(webhook.id, auth);
+        webhook.resetSecret = (auth) => this.resetSecret(webhook.id, auth);
         return webhook;
-    };
-    WebhooksEndpoint.prototype.getById = function (id, auth) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.defaultEndpoint.getById(id, auth)];
-            });
-        });
-    };
-    WebhooksEndpoint.prototype.list = function (page, pageSize, auth) {
-        if (page === void 0) { page = 1; }
-        if (pageSize === void 0) { pageSize = 20; }
-        return this.defaultEndpoint.list({ page: page, page_size: pageSize }, auth);
-    };
-    WebhooksEndpoint.prototype.listAll = function (auth) {
+    }
+    async getById(id, auth) {
+        return this.defaultEndpoint.getById(id, auth);
+    }
+    list(page = 1, pageSize = 20, auth) {
+        return this.defaultEndpoint.list({ page, page_size: pageSize }, auth);
+    }
+    listAll(auth) {
         return this.defaultEndpoint.listAll(auth);
-    };
-    WebhooksEndpoint.prototype.create = function (payload, auth) {
+    }
+    create(payload, auth) {
         return this.defaultEndpoint.create({ webhook: payload }, auth);
-    };
-    WebhooksEndpoint.prototype.update = function (id, payload, auth) {
-        return __awaiter(this, void 0, void 0, function () {
-            var webhookUpdate;
-            return __generator(this, function (_a) {
-                webhookUpdate = { webhook: payload };
-                return [2 /*return*/, this.defaultEndpoint.update(id, webhookUpdate, auth)];
-            });
-        });
-    };
-    WebhooksEndpoint.prototype.remove = function (id, auth) {
+    }
+    async update(id, payload, auth) {
+        const webhookUpdate = { webhook: payload };
+        return this.defaultEndpoint.update(id, webhookUpdate, auth);
+    }
+    remove(id, auth) {
         return this.defaultEndpoint.remove(id, auth);
-    };
-    WebhooksEndpoint.prototype.ping = function (id, auth) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.artaClient.post("".concat(this.path, "/").concat(id, "/ping"), auth)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    WebhooksEndpoint.prototype.getSecret = function (id, auth) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.artaClient.get("".concat(this.path, "/").concat(id, "/secret_token"), auth)];
-                    case 1:
-                        secret = _a.sent();
-                        return [2 /*return*/, secret.secret_token];
-                }
-            });
-        });
-    };
-    WebhooksEndpoint.prototype.resetSecret = function (id, auth) {
-        return __awaiter(this, void 0, void 0, function () {
-            var newSecret;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.artaClient.patch("".concat(this.path, "/").concat(id, "/secret_token/reset"), auth)];
-                    case 1:
-                        newSecret = _a.sent();
-                        return [2 /*return*/, newSecret.secret_token];
-                }
-            });
-        });
-    };
-    return WebhooksEndpoint;
-}());
+    }
+    async ping(id, auth) {
+        await this.artaClient.post(`${this.path}/${id}/ping`, auth);
+        return;
+    }
+    async getSecret(id, auth) {
+        const secret = await this.artaClient.get(`${this.path}/${id}/secret_token`, auth);
+        return secret.secret_token;
+    }
+    async resetSecret(id, auth) {
+        const newSecret = await this.artaClient.patch(`${this.path}/${id}/secret_token/reset`, auth);
+        return newSecret.secret_token;
+    }
+}
 exports.WebhooksEndpoint = WebhooksEndpoint;

package/dist/lib/error.js

@@ -1,54 +1,33 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArtaSDKError = void 0;
-var parseArtaError = function (apiError) {
-    var formattedArtaError = '';
-    for (var _i = 0, _a = Object.keys(apiError.errors); _i < _a.length; _i++) {
-        var key = _a[_i];
+const parseArtaError = (apiError) => {
+    let formattedArtaError = '';
+    for (const key of Object.keys(apiError.errors)) {
         if (key === 'detail') {
-            return "".concat(apiError.errors['detail'], ", ");
+            return `${apiError.errors['detail']}, `;
         }
         else if (Array.isArray(apiError.errors[key])) {
-            for (var _b = 0, _c = apiError.errors[key]; _b < _c.length; _b++) {
-                var error = _c[_b];
-                formattedArtaError += "".concat(key, " ").concat(error, ", ");
+            for (const error of apiError.errors[key]) {
+                formattedArtaError += `${key} ${error}, `;
             }
         }
         else {
-            formattedArtaError += "".concat(key, " ").concat(apiError.errors[key], ", ");
+            formattedArtaError += `${key} ${apiError.errors[key]}, `;
         }
     }
     return formattedArtaError;
 };
-var ArtaSDKError = /** @class */ (function (_super) {
-    __extends(ArtaSDKError, _super);
-    function ArtaSDKError(apiError, status) {
-        var _this = this;
-        var keys = Object.keys(apiError.errors);
+class ArtaSDKError extends Error {
+    constructor(apiError, status) {
+        const keys = Object.keys(apiError.errors);
         if (keys.length === 0) {
-            _this = _super.call(this, "Unknwon API error, HTTP status: ".concat(status)) || this;
+            super(`Unknwon API error, HTTP status: ${status}`);
         }
         else {
-            _this = _super.call(this, "".concat(parseArtaError(apiError), "HTTP status: ").concat(status)) || this;
+            super(`${parseArtaError(apiError)}HTTP status: ${status}`);
         }
-        Object.setPrototypeOf(_this, ArtaSDKError.prototype);
-        return _this;
+        Object.setPrototypeOf(this, ArtaSDKError.prototype);
     }
-    return ArtaSDKError;
-}(Error));
+}
 exports.ArtaSDKError = ArtaSDKError;

package/dist/lib/logging.js

@@ -1,13 +1,4 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogger = exports.initLogger = void 0;
 var LogLevel;
@@ -18,59 +9,38 @@ var LogLevel;
     LogLevel[LogLevel["INFO"] = 3] = "INFO";
     LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
 })(LogLevel || (LogLevel = {}));
-var LoggerWrapper = /** @class */ (function () {
-    function LoggerWrapper(logger, loggerVerbosity) {
+class LoggerWrapper {
+    constructor(logger, loggerVerbosity) {
         this.logger = logger;
         this.verbosity = LogLevel[loggerVerbosity];
     }
-    LoggerWrapper.prototype.debug = function (message) {
-        var _a;
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
-        }
+    debug(message, ...optionalParams) {
         if (this.verbosity >= LogLevel.DEBUG) {
-            (_a = this.logger).debug.apply(_a, __spreadArray([message], optionalParams, false));
-        }
-    };
-    LoggerWrapper.prototype.info = function (message) {
-        var _a;
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
+            this.logger.debug(message, ...optionalParams);
         }
+    }
+    info(message, ...optionalParams) {
         if (this.verbosity >= LogLevel.INFO) {
-            (_a = this.logger).info.apply(_a, __spreadArray([message], optionalParams, false));
-        }
-    };
-    LoggerWrapper.prototype.warn = function (message) {
-        var _a;
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
+            this.logger.info(message, ...optionalParams);
         }
+    }
+    warn(message, ...optionalParams) {
         if (this.verbosity >= LogLevel.WARN) {
-            (_a = this.logger).warn.apply(_a, __spreadArray([message], optionalParams, false));
-        }
-    };
-    LoggerWrapper.prototype.error = function (message) {
-        var _a;
-        var optionalParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            optionalParams[_i - 1] = arguments[_i];
+            this.logger.warn(message, ...optionalParams);
         }
+    }
+    error(message, ...optionalParams) {
         if (this.verbosity >= LogLevel.ERROR) {
-            (_a = this.logger).error.apply(_a, __spreadArray([message], optionalParams, false));
+            this.logger.error(message, ...optionalParams);
         }
-    };
-    return LoggerWrapper;
-}());
-var _logger;
-var initLogger = function (logger, loggerVerbosity) {
+    }
+}
+let _logger;
+const initLogger = (logger, loggerVerbosity) => {
     _logger = new LoggerWrapper(logger, loggerVerbosity);
 };
 exports.initLogger = initLogger;
-var getLogger = function () {
+const getLogger = () => {
     if (!_logger) {
         (0, exports.initLogger)(console, 'ERROR');
     }

package/dist/lib/net/FetchHttpClient.js

@@ -1,79 +1,23 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FetchHttpClient = exports.FetchHttpClientResponse = void 0;
-var logging_1 = require("../logging");
-var FetchHttpClientResponse = /** @class */ (function () {
-    function FetchHttpClientResponse(res) {
-        var _this = this;
+const logging_1 = require("../logging");
+class FetchHttpClientResponse {
+    constructor(res) {
         this.res = res;
         this.headers = {};
         this.statusCode = res.status;
-        res.headers.forEach(function (value, key) {
-            _this.headers[key] = value;
+        res.headers.forEach((value, key) => {
+            this.headers[key] = value;
         });
     }
-    FetchHttpClientResponse.prototype.json = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.res.json()];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    return FetchHttpClientResponse;
-}());
+    async json() {
+        return await this.res.json();
+    }
+}
 exports.FetchHttpClientResponse = FetchHttpClientResponse;
 function initParams(params) {
-    var defaultParams = {
+    const defaultParams = {
         protocol: 'https',
         port: 443,
         path: '/',
@@ -82,50 +26,41 @@ function initParams(params) {
         requestData: null,
         timeout: 30000,
     };
-    return __assign(__assign({}, defaultParams), params);
+    return {
+        ...defaultParams,
+        ...params,
+    };
 }
-var FetchHttpClient = /** @class */ (function () {
-    function FetchHttpClient() {
+class FetchHttpClient {
+    constructor() {
         this.logger = (0, logging_1.getLogger)();
     }
-    FetchHttpClient.prototype.request = function (host, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, protocol, port, path, method, timeout, headers, requestData, url, fetchUrl, setTimeoutId, rejectTimeout, response;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = initParams(params), protocol = _a.protocol, port = _a.port, path = _a.path, method = _a.method, timeout = _a.timeout, headers = _a.headers, requestData = _a.requestData;
-                        url = "".concat(protocol, "://").concat(host, ":").concat(port).concat(path);
-                        this.logger.debug("[".concat(method, "] ").concat(url));
-                        fetchUrl = fetch(url, {
-                            method: method,
-                            headers: headers,
-                            body: requestData,
-                        });
-                        setTimeoutId = null;
-                        rejectTimeout = new Promise(function (_, reject) {
-                            setTimeoutId = setTimeout(function () {
-                                reject(new Error("Request timed out to ".concat(host, ":").concat(port)));
-                            }, timeout);
-                        });
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, Promise.race([
-                                fetchUrl,
-                                rejectTimeout,
-                            ])];
-                    case 2:
-                        response = (_b.sent());
-                        return [2 /*return*/, new FetchHttpClientResponse(response)];
-                    case 3:
-                        setTimeoutId != null && clearTimeout(setTimeoutId);
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
-                }
-            });
+    async request(host, params) {
+        const { protocol, port, path, method, timeout, headers, requestData } = initParams(params);
+        const url = `${protocol}://${host}:${port}${path}`;
+        this.logger.debug(`[${method}] ${url}`);
+        const fetchUrl = fetch(url, {
+            method,
+            headers,
+            body: requestData,
         });
-    };
-    return FetchHttpClient;
-}());
+        let setTimeoutId = null;
+        const rejectTimeout = new Promise((_resolve, reject) => {
+            setTimeoutId = setTimeout(() => {
+                reject(new Error(`Request timed out to ${host}:${port}`));
+            }, timeout);
+        });
+        try {
+            const response = (await Promise.race([
+                fetchUrl,
+                rejectTimeout,
+            ]));
+            return new FetchHttpClientResponse(response);
+        }
+        finally {
+            if (setTimeoutId != null)
+                clearTimeout(setTimeoutId);
+        }
+    }
+}
 exports.FetchHttpClient = FetchHttpClient;

package/dist/lib/queryParams.js

@@ -5,16 +5,15 @@ exports.defaultQueryParams = {
     page: 1,
     page_size: 20,
 };
-var parseQueryParams = function (params) {
-    var parsedParams = '';
-    for (var _i = 0, _a = Object.entries(params); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
+const parseQueryParams = (params) => {
+    let parsedParams = '';
+    for (const [key, value] of Object.entries(params)) {
         if (key && value) {
             if (parsedParams === '') {
-                parsedParams = "?".concat(key, "=").concat(value);
+                parsedParams = `?${key}=${value}`;
             }
             else {
-                parsedParams += "&".concat(key, "=").concat(value);
+                parsedParams += `&${key}=${value}`;
             }
         }
     }

package/dist/lib/utils.js

@@ -1,32 +1,25 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseService = void 0;
 exports.createDateAsUTC = createDateAsUTC;
 exports.convertDatesToUtc = convertDatesToUtc;
 function createDateAsUTC(dateStr) {
-    var date = new Date(dateStr);
-    var timestamp = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+    const date = new Date(dateStr);
+    const timestamp = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
     return new Date(timestamp);
 }
 function convertDatesToUtc(artaResponse) {
-    return __assign(__assign({}, artaResponse), { created_at: artaResponse.created_at
+    return {
+        ...artaResponse,
+        created_at: artaResponse.created_at
             ? createDateAsUTC(artaResponse.created_at)
-            : undefined, updated_at: artaResponse.updated_at
+            : undefined,
+        updated_at: artaResponse.updated_at
             ? createDateAsUTC(artaResponse.updated_at)
-            : undefined });
+            : undefined,
+    };
 }
-var parseService = function (s) {
+const parseService = (s) => {
     s.amount = Number(s.amount);
     if (s.included_services) {
         s.included_services.forEach(exports.parseService);