@debugg-ai/debugg-ai-mcp/dist/utils/axiosTransport.js

Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.

// utils/axiosTransport.ts
import axios from "axios";
import { objToCamelCase, objToSnakeCase, } from "./objectNaming.js";
/**
 * A tiny wrapper around axios that keeps all your interceptors
 * but gives service factories a clean, typed surface.
 */
export class AxiosTransport {
    axios;
    constructor({ baseUrl, apiKey, tokenType = 'token', instance }) {
        // Use an injected instance or create one that mimics `axiosServices`
        // Use provided apiKey as the Token. Must be requested on the app.
        this.axios =
            instance ??
                axios.create({
                    baseURL: baseUrl.replace(/\/+$/, "/"),
                    timeout: 30_000,
                    headers: {
                        Accept: "application/json",
                        "Content-Type": "application/json",
                        ...(apiKey ? { Authorization: `${tokenType === 'bearer' ? 'Bearer' : 'Token'} ${apiKey}` } : {}),
                    },
                });
        /* ---------- INTERCEPTORS ---------- */
        // Response → camelCase
        this.axios.interceptors.response.use((res) => {
            res.data = objToCamelCase(res.data);
            return res;
        }, (err) => {
            const data = err.response?.data;
            if (data) {
                const strField = (v) => typeof v === 'string' && v ? v : null;
                const msg = typeof data === 'string'
                    ? data
                    : strField(data.detail) ??
                        strField(data.message) ??
                        strField(data.error) ??
                        JSON.stringify(data);
                const newErr = new Error(String(msg));
                newErr.statusCode = err.response?.status;
                newErr.responseData = data;
                newErr.responseHeaders = err.response?.headers;
                return Promise.reject(newErr);
            }
            // Network-class error (no response received) — preserve err.code (ECONNRESET, etc.)
            const networkErr = new Error(err.message || 'Unknown Axios error');
            if (err.code)
                networkErr.networkCode = err.code;
            return Promise.reject(networkErr);
        });
        // Request → snake_case
        this.axios.interceptors.request.use((cfg) => {
            if (cfg.data && typeof cfg.data === "object") {
                cfg.data = objToSnakeCase(cfg.data);
            }
            if (cfg.params && typeof cfg.params === "object") {
                cfg.params = objToSnakeCase(cfg.params);
            }
            return cfg;
        });
    }
    /* ---------- SHORTHAND METHODS ---------- */
    async request(cfg) {
        const res = await this.axios.request(cfg);
        return res.data;
    }
    get(url, params) {
        return this.request({ url, method: "GET", params });
    }
    post(url, data, cfg) {
        return this.request({ url, method: "POST", data, ...cfg });
    }
    put(url, data, cfg) {
        return this.request({ url, method: "PUT", data, ...cfg });
    }
    patch(url, data, cfg) {
        return this.request({ url, method: "PATCH", data, ...cfg });
    }
    delete(url, cfg) {
        return this.request({ url, method: "DELETE", ...cfg });
    }
}