@smash-sdk/core/dist/cjs/http/axiosClient.js

Smash Sdk Core

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AxiosClient = void 0;
const tslib_1 = require("tslib");
const axios_1 = tslib_1.__importStar(require("axios"));
const sdkError_1 = require("../errors/sdkError");
const types_1 = require("./types");
const fast_xml_parser_1 = require("fast-xml-parser");
const qs_1 = tslib_1.__importDefault(require("qs"));
;
const defaultAxiosConfig = {
    maxContentLength: Infinity,
    maxBodyLength: Infinity,
    responseType: 'json',
};
class AxiosClient {
    constructor() {
        this.client = axios_1.default.create(defaultAxiosConfig);
    }
    setHttpConfiguration(configuration) {
        this.client = axios_1.default.create({ ...defaultAxiosConfig, ...configuration });
    }
    handle(request) {
        return new Promise(async (resolve, reject) => {
            try {
                const axiosParams = this.transformToAxiosParams(request);
                const response = await this.client.request(axiosParams);
                const smashResponse = this.transformToSmashResponse(response);
                resolve(smashResponse);
            }
            catch (error) {
                if (error?.code === axios_1.AxiosError.ERR_NETWORK) {
                    reject(new sdkError_1.NetworkError(error));
                }
                else if (error?.code === axios_1.AxiosError.ECONNABORTED) {
                    reject(new sdkError_1.ConnectionAbortedError(error));
                }
                else if (error?.code === axios_1.AxiosError.ETIMEDOUT) {
                    reject(new sdkError_1.TimeoutError(error));
                }
                else if ((!error?.response && error?.request)) {
                    reject(new sdkError_1.NetworkError(error));
                }
                else if (error?.response?.status || (request.bypassErrorHandler && error instanceof axios_1.AxiosError && error?.response)) {
                    const smashResponse = this.transformToSmashResponse(error.response);
                    resolve(smashResponse);
                }
                else {
                    reject(new sdkError_1.UnknownError(error));
                }
            }
        });
    }
    ;
    transformToSmashResponse(response) {
        if (response?.headers?.['content-type'] === 'application/xml' && typeof response?.data === 'string') {
            const parser = new fast_xml_parser_1.XMLParser();
            response.data = parser.parse(response.data);
        }
        return new types_1.HttpResponse({ ...response, body: response.data });
    }
    transformToAxiosParams(request) {
        return {
            method: request.method.toLowerCase(),
            url: request.getUrl(),
            headers: request.headers,
            data: request.bodyParameters,
            params: request.queryParameters,
            paramsSerializer: (params) => qs_1.default.stringify(params, { arrayFormat: 'repeat' }),
            responseType: request.responseType === 'object' ? 'json' : 'stream',
            onUploadProgress: (event) => {
                if (request.onUploadProgress) {
                    const parsedEvent = {
                        uploadedBytes: event.loaded,
                        totalBytes: event.total,
                        timestamp: event.timeStamp,
                    };
                    request.onUploadProgress(parsedEvent);
                }
            },
        };
    }
}
exports.AxiosClient = AxiosClient;