sdk-node-apis-efi/dist/cjs/internal/httpClient.js

Module for integration with Efi Bank API

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SDK_IDENTIFIER = void 0;
exports.buildHttpsAgent = buildHttpsAgent;
exports.httpRequest = httpRequest;
const axios_1 = __importDefault(require("axios"));
const node_fs_1 = __importDefault(require("node:fs"));
const node_https_1 = __importDefault(require("node:https"));
const version_js_1 = require("./version.js");
exports.SDK_IDENTIFIER = `efi-node-${version_js_1.PACKAGE_VERSION}`;
function buildHttpsAgent(options) {
    if (!options.certificate)
        return undefined;
    try {
        if (options.cert_base64) {
            if (options.pemKey) {
                return new node_https_1.default.Agent({
                    cert: Buffer.from(options.certificate, 'base64'),
                    key: Buffer.from(options.pemKey, 'base64'),
                    passphrase: '',
                });
            }
            return new node_https_1.default.Agent({
                pfx: Buffer.from(options.certificate, 'base64'),
                passphrase: '',
            });
        }
        if (options.pemKey) {
            return new node_https_1.default.Agent({
                cert: node_fs_1.default.readFileSync(options.certificate),
                key: node_fs_1.default.readFileSync(options.pemKey),
                passphrase: '',
            });
        }
        return new node_https_1.default.Agent({
            pfx: node_fs_1.default.readFileSync(options.certificate),
            passphrase: '',
        });
    }
    catch (error) {
        throw new Error('Erro ao ler o certificado ou chave: ' + error.message);
    }
}
function resolveRoute(route, params = {}) {
    const queryParams = { ...params };
    const resolvedRoute = route.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
        const value = queryParams[key];
        if (value === undefined || value === null) {
            throw new Error(`Parametro de rota ausente: ${key}`);
        }
        delete queryParams[key];
        return encodeURIComponent(String(value));
    });
    return { route: resolvedRoute, queryParams };
}
function hasQueryParams(params) {
    return Object.keys(params).some((key) => params[key] !== undefined);
}
function normalizeError(error) {
    let errorData = error.response?.data ?? error;
    const errorUrl = error.request?.res?.responseUrl || '';
    if (errorUrl.includes('/v2/gn/pix/comprovantes')) {
        try {
            const decoder = new TextDecoder('utf-8');
            const errorText = decoder.decode(errorData);
            errorData = JSON.parse(errorText);
        }
        catch {
            errorData = error.response?.data ?? error;
        }
    }
    return errorData;
}
async function httpRequest(options) {
    const { baseUrl, endpoint, body, params = {}, headers = {}, partner_token, skipMtlsChecking, authorization, idempotencyKey, } = options;
    const { route, queryParams } = resolveRoute(endpoint.route, params);
    const agent = buildHttpsAgent(options);
    const defaultHeaders = {
        'api-sdk': exports.SDK_IDENTIFIER,
        ...(authorization ? { Authorization: authorization } : {}),
        ...(skipMtlsChecking ? { 'x-skip-mtls-checking': 'true' } : {}),
        ...(partner_token ? { 'partner-token': partner_token } : {}),
        ...(idempotencyKey ? { 'x-idempotency-key': idempotencyKey } : {}),
    };
    const config = {
        url: baseUrl + route,
        method: endpoint.method.toLowerCase(),
        data: body,
        headers: { ...defaultHeaders, ...headers },
        ...(endpoint.responseType ? { responseType: endpoint.responseType } : {}),
        ...(hasQueryParams(queryParams) ? { params: queryParams } : {}),
        ...(agent ? { httpsAgent: agent } : {}),
    };
    try {
        const response = await (0, axios_1.default)(config);
        return response.data;
    }
    catch (error) {
        throw normalizeError(error);
    }
}