breathe-api/dist/tools/api-client.js

Model Context Protocol server for Breathe HR APIs with Swagger/OpenAPI support - also works with custom APIs

import axios from 'axios';
import { apiResponseCache, generateCacheKey, isCacheable, requestQueue, deduplicateRequest } from '../utils/cache.js';
import { ApiError } from '../utils/errors.js';
export async function makeApiRequest(request) {
    const startTime = Date.now();
    const shouldCache = isCacheable(request.url, request.method);
    const cacheKey = generateCacheKey({
        url: request.url,
        method: request.method,
        headers: request.headers,
        params: request.params,
        data: request.data
    });
    if (shouldCache) {
        const cached = apiResponseCache.get(cacheKey);
        if (cached) {
            return { ...cached, duration: 0 };
        }
    }
    const response = await deduplicateRequest(cacheKey, async () => {
        const queueResult = await requestQueue.add(async () => {
            const config = {
                url: request.url,
                method: request.method,
                headers: request.headers,
                params: request.params,
                data: request.data,
                timeout: request.timeout || 30000,
                validateStatus: () => true,
            };
            try {
                const response = await axios(config);
                const result = {
                    status: response.status,
                    statusText: response.statusText,
                    headers: response.headers,
                    data: response.data,
                    duration: Date.now() - startTime,
                };
                if (shouldCache && response.status >= 200 && response.status < 300) {
                    apiResponseCache.set(cacheKey, result);
                }
                return result;
            }
            catch (error) {
                if (axios.isAxiosError(error)) {
                    if (error.response) {
                        return {
                            status: error.response.status,
                            statusText: error.response.statusText,
                            headers: error.response.headers,
                            data: error.response.data,
                            duration: Date.now() - startTime,
                        };
                    }
                    throw ApiError.fromAxiosError(error);
                }
                throw ApiError.fromAxiosError(error);
            }
        });
        if (!queueResult) {
            throw new Error('Request queue returned undefined result');
        }
        return queueResult;
    });
    return response;
}
//# sourceMappingURL=api-client.js.map