@internxt/sdk 1.15.14 → 1.16.0

package/dist/shared/http/client.js

@@ -1,312 +1,202 @@
 "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 };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
-var axios_1 = __importDefault(require("axios"));
-var errors_1 = require("../types/errors");
-var retryWithBackoff_1 = require("./retryWithBackoff");
-var HttpClient = /** @class */ (function () {
-    function HttpClient(baseURL, unauthorizedCallback, retryOptions) {
-        var _this = this;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../types/errors");
+const retryWithBackoff_1 = require("./retryWithBackoff");
+class HttpClient {
+    axios;
+    unauthorizedCallback;
+    retryOptions;
+    static globalInterceptors = [];
+    static globalRetryOptions;
+    static setGlobalInterceptors(interceptors) {
+        HttpClient.globalInterceptors = interceptors;
+    }
+    /**
+     * Enables global retry with backoff for rate limit errors (429) across every HttpClient instance.
+     * @param [options] - Optional retry configuration options
+     * @param [options.maxRetries] - Maximum number of retry attempts (default: 5)
+     * @param [options.maxRetryAfter] - Maximum wait time in ms regardless of retry-after header value (default: 70000)
+     * @param [options.onRetry] - Callback invoked before each retry with the attempt number and delay in ms
+     */
+    static enableGlobalRetry(options) {
+        HttpClient.globalRetryOptions = (options ?? {});
+    }
+    static create(baseURL, unauthorizedCallback, retryOptions) {
+        if (unauthorizedCallback === undefined) {
+            unauthorizedCallback = () => null;
+        }
+        return new HttpClient(baseURL, unauthorizedCallback, retryOptions);
+    }
+    constructor(baseURL, unauthorizedCallback, retryOptions) {
         this.axios = axios_1.default.create({
             baseURL: baseURL,
         });
         this.unauthorizedCallback = unauthorizedCallback;
         this.retryOptions = retryOptions;
-        HttpClient.globalInterceptors.forEach(function (interceptor) {
+        HttpClient.globalInterceptors.forEach((interceptor) => {
             if (interceptor.request) {
-                _this.axios.interceptors.request.use(interceptor.request.onFulfilled, interceptor.request.onRejected);
+                this.axios.interceptors.request.use(interceptor.request.onFulfilled, interceptor.request.onRejected);
             }
             if (interceptor.response) {
-                _this.axios.interceptors.response.use(interceptor.response.onFulfilled, interceptor.response.onRejected);
+                this.axios.interceptors.response.use(interceptor.response.onFulfilled, interceptor.response.onRejected);
             }
         });
         this.initializeMiddleware();
     }
-    HttpClient.setGlobalInterceptors = function (interceptors) {
-        HttpClient.globalInterceptors = interceptors;
-    };
-    /**
-     * Enables global retry with backoff for rate limit errors (429) across every HttpClient instance.
-     * @param [options] - Optional retry configuration options
-     * @param [options.maxRetries] - Maximum number of retry attempts (default: 5)
-     * @param [options.maxRetryAfter] - Maximum wait time in ms regardless of retry-after header value (default: 70000)
-     * @param [options.onRetry] - Callback invoked before each retry with the attempt number and delay in ms
-     */
-    HttpClient.enableGlobalRetry = function (options) {
-        HttpClient.globalRetryOptions = (options !== null && options !== void 0 ? options : {});
-    };
-    HttpClient.create = function (baseURL, unauthorizedCallback, retryOptions) {
-        if (unauthorizedCallback === undefined) {
-            unauthorizedCallback = function () { return null; };
-        }
-        return new HttpClient(baseURL, unauthorizedCallback, retryOptions);
-    };
-    HttpClient.prototype.execute = function (fn) {
-        var _a;
-        var options = (_a = this.retryOptions) !== null && _a !== void 0 ? _a : HttpClient.globalRetryOptions;
+    execute(fn) {
+        const options = this.retryOptions ?? HttpClient.globalRetryOptions;
         if (!options) {
             return fn();
         }
         return (0, retryWithBackoff_1.retryWithBackoff)(fn, options);
-    };
+    }
     /**
      * Requests a GET
      * @param url
      * @param headers
      */
-    HttpClient.prototype.get = function (url, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.get(url, { headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async get(url, headers) {
+        return await this.execute(() => this.axios.get(url, { headers }));
+    }
     /**
      * Requests a GET
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.getWithParams = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.get(url, { params: params, headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async getWithParams(url, params, headers) {
+        return await this.execute(() => this.axios.get(url, { params, headers }));
+    }
     /**
      * Requests a GET with option to cancel
      * @param url
      * @param headers
      */
-    HttpClient.prototype.getCancellable = function (url, headers) {
-        var _this = this;
-        var currentCancel = function () { };
-        var requestCanceler = { cancel: function (message) { return currentCancel(message); } };
-        var promise = this.execute(function () {
-            var source = axios_1.default.CancelToken.source();
+    getCancellable(url, headers) {
+        let currentCancel = () => { };
+        const requestCanceler = { cancel: (message) => currentCancel(message) };
+        const promise = this.execute(() => {
+            const source = axios_1.default.CancelToken.source();
             currentCancel = source.cancel;
-            return _this.axios.get(url, { headers: headers, cancelToken: source.token });
+            return this.axios.get(url, { headers, cancelToken: source.token });
         });
-        return { promise: promise, requestCanceler: requestCanceler };
-    };
+        return { promise, requestCanceler };
+    }
     /**
      * Requests a POST
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.post = function (url, params, headers, signal) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.post(url, params, { headers: headers, signal: signal }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async post(url, params, headers, signal) {
+        return await this.execute(() => this.axios.post(url, params, { headers, signal }));
+    }
     /**
      * Requests a POST with fetch adapter and keep-alive option
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.postWithKeepAlive = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () {
-                            return _this.axios.post(url, params, {
-                                headers: headers,
-                                adapter: 'fetch',
-                                fetchOptions: {
-                                    keepalive: true,
-                                },
-                            });
-                        })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async postWithKeepAlive(url, params, headers) {
+        return await this.execute(() => this.axios.post(url, params, {
+            headers,
+            adapter: 'fetch',
+            fetchOptions: {
+                keepalive: true,
+            },
+        }));
+    }
     /**
      * Requests a POST FORM
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.postForm = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.postForm(url, params, { headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async postForm(url, params, headers) {
+        return await this.execute(() => this.axios.postForm(url, params, { headers }));
+    }
     /**
      * Requests a POST with option to cancel
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.postCancellable = function (url, params, headers) {
-        var _this = this;
-        var currentCancel = function () { };
-        var requestCanceler = { cancel: function (message) { return currentCancel(message); } };
-        var promise = this.execute(function () {
-            var source = axios_1.default.CancelToken.source();
+    postCancellable(url, params, headers) {
+        let currentCancel = () => { };
+        const requestCanceler = { cancel: (message) => currentCancel(message) };
+        const promise = this.execute(() => {
+            const source = axios_1.default.CancelToken.source();
             currentCancel = source.cancel;
-            return _this.axios.post(url, params, { headers: headers, cancelToken: source.token });
+            return this.axios.post(url, params, { headers, cancelToken: source.token });
         });
-        return { promise: promise, requestCanceler: requestCanceler };
-    };
+        return { promise, requestCanceler };
+    }
     /**
      * Requests PATCH
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.patch = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.patch(url, params, { headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async patch(url, params, headers) {
+        return await this.execute(() => this.axios.patch(url, params, { headers }));
+    }
     /**
      * Requests a PUT
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.put = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.put(url, params, { headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async put(url, params, headers) {
+        return await this.execute(() => this.axios.put(url, params, { headers }));
+    }
     /**
      * Requests a PUT FORM
      * @param url
      * @param params
      * @param headers
      */
-    HttpClient.prototype.putForm = function (url, params, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.putForm(url, params, { headers: headers }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async putForm(url, params, headers) {
+        return await this.execute(() => this.axios.putForm(url, params, { headers }));
+    }
     /**
      * Requests a DELETE
      * @param url
      * @param headers
      * @param params
      */
-    HttpClient.prototype.delete = function (url, headers, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execute(function () { return _this.axios.delete(url, { headers: headers, data: params }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async delete(url, headers, params) {
+        return await this.execute(() => this.axios.delete(url, { headers, data: params }));
+    }
     /**
      * Sets middlewares into the client for common behaviour managing
      * @private
      */
-    HttpClient.prototype.initializeMiddleware = function () {
+    initializeMiddleware() {
         this.axios.interceptors.response.use(HttpClient.extractData, this.normalizeError.bind(this));
-    };
+    }
     /**
      * Extracts the valuable data from the server's response
      * @param response
      * @private
      */
-    HttpClient.extractData = function (response) {
+    static extractData(response) {
         return response.data;
-    };
+    }
     /**
      * Converts the specific client error into a proprietary error for our apps
      * @param error
      * @private
      */
-    HttpClient.prototype.normalizeError = function (error) {
-        var _a, _b, _c, _d, _e, _f;
-        var baseUrl = (_b = (_a = error.config) === null || _a === void 0 ? void 0 : _a.baseURL) !== null && _b !== void 0 ? _b : '';
-        var url = (_d = (_c = error.config) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : '';
-        var method = (_f = (_e = error.config) === null || _e === void 0 ? void 0 : _e.method) !== null && _f !== void 0 ? _f : '';
-        var request = "".concat(method, " ").concat(baseUrl).concat(url);
+    normalizeError(error) {
+        const baseUrl = error.config?.baseURL ?? '';
+        const url = error.config?.url ?? '';
+        const method = error.config?.method ?? '';
+        const request = `${method} ${baseUrl}${url}`;
         if (error.response) {
             if (error.response.status === 401) {
                 this.unauthorizedCallback();
@@ -316,8 +206,6 @@ var HttpClient = /** @class */ (function () {
         else {
             throw new errors_1.AxiosUnknownError(error.message, request, error);
         }
-    };
-    HttpClient.globalInterceptors = [];
-    return HttpClient;
-}());
+    }
+}
 exports.HttpClient = HttpClient;

package/dist/shared/http/retryWithBackoff.js

@@ -1,80 +1,24 @@
 "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 };
-    }
-};
-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.retryWithBackoff = void 0;
-var HTTP_STATUS_TOO_MANY_REQUESTS = 429;
-var wait = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
-var isErrorWithStatus = function (error) {
+const HTTP_STATUS_TOO_MANY_REQUESTS = 429;
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isErrorWithStatus = (error) => {
     return typeof error === 'object' && error !== null;
 };
-var isRateLimitError = function (error) {
+const isRateLimitError = (error) => {
     if (!isErrorWithStatus(error)) {
         return false;
     }
     return error.status === HTTP_STATUS_TOO_MANY_REQUESTS;
 };
-var extractRetryAfter = function (error) {
-    var headers = error.headers;
-    var resetHeader = headers === null || headers === void 0 ? void 0 : headers['retry-after'];
+const extractRetryAfter = (error) => {
+    const headers = error.headers;
+    const resetHeader = headers?.['retry-after'];
     if (!resetHeader) {
         return undefined;
     }
-    var resetValueInSeconds = Number.parseInt(resetHeader, 10);
+    const resetValueInSeconds = Number.parseInt(resetHeader, 10);
     if (Number.isNaN(resetValueInSeconds)) {
         return undefined;
     }
@@ -92,52 +36,34 @@ var extractRetryAfter = function (error) {
  * @returns The result of the function if successful
  * @throws The original error if it's not a rate limit error, if max retries exceeded, or if retry-after header is missing
  */
-var retryWithBackoff = function (fn_1) {
-    var args_1 = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args_1[_i - 1] = arguments[_i];
-    }
-    return __awaiter(void 0, __spreadArray([fn_1], args_1, true), void 0, function (fn, options) {
-        var opts, lastError, attempt, error_1, retryAfter, delay, err;
-        if (options === void 0) { options = {}; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    opts = __assign({ maxRetries: 5, maxRetryAfter: 70000, onRetry: function () { } }, options);
-                    attempt = 1;
-                    _a.label = 1;
-                case 1:
-                    if (!(attempt <= opts.maxRetries)) return [3 /*break*/, 7];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 6]);
-                    return [4 /*yield*/, fn()];
-                case 3: return [2 /*return*/, _a.sent()];
-                case 4:
-                    error_1 = _a.sent();
-                    if (!isRateLimitError(error_1)) {
-                        throw error_1;
-                    }
-                    retryAfter = extractRetryAfter(error_1);
-                    if (!retryAfter) {
-                        throw error_1;
-                    }
-                    delay = Math.min(retryAfter, opts.maxRetryAfter);
-                    opts.onRetry(attempt, delay);
-                    lastError = error_1;
-                    return [4 /*yield*/, wait(delay)];
-                case 5:
-                    _a.sent();
-                    return [3 /*break*/, 6];
-                case 6:
-                    attempt++;
-                    return [3 /*break*/, 1];
-                case 7:
-                    err = lastError;
-                    err.message = "Max retries exceeded: ".concat(err.message);
-                    throw err;
+const retryWithBackoff = async (fn, options = {}) => {
+    const opts = {
+        maxRetries: 5,
+        maxRetryAfter: 70_000,
+        onRetry: () => { },
+        ...options,
+    };
+    let lastError;
+    for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (!isRateLimitError(error)) {
+                throw error;
+            }
+            const retryAfter = extractRetryAfter(error);
+            if (!retryAfter) {
+                throw error;
             }
-        });
-    });
+            const delay = Math.min(retryAfter, opts.maxRetryAfter);
+            opts.onRetry(attempt, delay);
+            lastError = error;
+            await wait(delay);
+        }
+    }
+    const err = lastError;
+    err.message = `Max retries exceeded: ${err.message}`;
+    throw err;
 };
 exports.retryWithBackoff = retryWithBackoff;