@outputai/http 0.2.1-next.af8a069.0 → 0.2.1-next.b87b58f.0

package/dist/hooks/trace_response.d.ts

@@ -1,6 +0,0 @@
-import type { AfterResponseHook } from 'ky';
-/**
- * Traces HTTP response for observability using Output.ai tracing
- * Respects OUTPUT_TRACE_HTTP_VERBOSE environment variable for detailed logging
- */
-export declare const traceResponse: AfterResponseHook;

package/dist/hooks/trace_response.js

@@ -1,26 +0,0 @@
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { redactHeaders, createTraceId, parseResponseBody } from '#utils/index.js';
-import { config } from '#config.js';
-/**
- * Traces HTTP response for observability using Output.ai tracing
- * Respects OUTPUT_TRACE_HTTP_VERBOSE environment variable for detailed logging
- */
-export const traceResponse = async (request, _options, response, _state) => {
-    const traceId = createTraceId(request);
-    // Skip tracing if no X-Request-ID header is present
-    if (!traceId) {
-        console.warn('traceResponse: Skipping response tracing - no X-Request-ID header');
-        return response;
-    }
-    const details = {
-        status: response.status,
-        statusText: response.statusText
-    };
-    if (config.logVerbose) {
-        const responseHeaders = Object.fromEntries(response.headers.entries());
-        details.headers = redactHeaders(responseHeaders);
-        details.body = await parseResponseBody(response);
-    }
-    Tracing.addEventEnd({ id: traceId, details });
-    return response;
-};

package/dist/hooks/trace_response.spec.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { traceResponse } from './trace_response.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { config } from '../config.js';
-vi.mock('../utils/index.js', () => ({
-    redactHeaders: vi.fn((h) => h),
-    parseResponseBody: vi.fn(async () => ({ mocked: true })),
-    createTraceId: vi.fn(() => 'trace-id')
-}));
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventEnd: vi.fn()
-    }
-}));
-vi.mock('../config.js', () => ({
-    config: { logVerbose: false }
-}));
-const mockedTracing = vi.mocked(Tracing, true);
-const mockedConfig = vi.mocked(config);
-describe('http/hooks/trace_response', () => {
-    beforeEach(() => {
-        mockedTracing.addEventEnd.mockClear();
-        mockedConfig.logVerbose = false;
-    });
-    it('traces minimal details when verbose logging is disabled', async () => {
-        mockedConfig.logVerbose = false;
-        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
-        const response = new Response('ok', { status: 200, statusText: 'OK' });
-        const options = {};
-        const state = { retryCount: 0 };
-        const result = await traceResponse(request, options, response, state);
-        expect(result).toBe(response);
-        expect(mockedTracing.addEventEnd).toHaveBeenCalledTimes(1);
-        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
-        expect(arg.details).toEqual({ status: 200, statusText: 'OK' });
-    });
-    it('traces headers and parsed JSON body when verbose logging is enabled', async () => {
-        mockedConfig.logVerbose = true;
-        const request = new Request('https://api.example.com/users', { method: 'POST' });
-        const response = new Response(JSON.stringify({ success: true }), {
-            status: 201,
-            statusText: 'Created',
-            headers: { 'content-type': 'application/json', authorization: 'secret', 'x-custom': 'v' }
-        });
-        const options = {};
-        const state = { retryCount: 0 };
-        await traceResponse(request, options, response, state);
-        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
-        expect(arg.details.status).toBe(201);
-        expect(arg.details.statusText).toBe('Created');
-        expect(arg.details.headers).toEqual({ 'content-type': 'application/json', authorization: 'secret', 'x-custom': 'v' });
-        expect(arg.details.body).toEqual({ mocked: true });
-    });
-    it('traces text body for non-JSON content types', async () => {
-        mockedConfig.logVerbose = true;
-        const request = new Request('https://api.example.com/ping', { method: 'GET' });
-        const response = new Response('pong', {
-            status: 200,
-            statusText: 'OK',
-            headers: { 'content-type': 'text/plain' }
-        });
-        const options = {};
-        const state = { retryCount: 0 };
-        await traceResponse(request, options, response, state);
-        const arg = mockedTracing.addEventEnd.mock.calls[0][0];
-        expect(arg.details.body).toEqual({ mocked: true });
-    });
-});

package/dist/index.integration.test.js

@@ -1,389 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import ky from 'ky';
-import { httpClient } from './index.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import createTraceId from './utils/create_trace_id.js';
-import { traceRequest, traceResponse, traceError } from './hooks/index.js';
-import { applyFetchErrorTracing } from './hooks/trace_error.js';
-// Helper function for trace ID format validation
-const isUuidFormat = (traceId) => {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(traceId);
-};
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventStart: vi.fn(),
-        addEventEnd: vi.fn(),
-        addEventError: vi.fn()
-    }
-}));
-const mockedTracing = vi.mocked(Tracing, true);
-// Helper to get header value (httpbingo returns arrays)
-const getHeader = (headers, key) => {
-    const value = headers[key];
-    return Array.isArray(value) ? value[0] : value;
-};
-describe('HTTP Client Authentication Integration', () => {
-    const httpBinClient = httpClient({
-        prefixUrl: 'https://httpbingo.org',
-        timeout: 5000
-    });
-    const clientsClient = httpBinClient.extend({
-        headers: {
-            'X-API-Key': 'demo-api-key-12345'
-        }
-    });
-    const contractsClient = httpBinClient.extend({
-        headers: {
-            Authorization: `Basic ${Buffer.from('demo-user:demo-pass').toString('base64')}`
-        }
-    });
-    describe('Authentication Headers', () => {
-        it('should include API key for clients endpoints', async () => {
-            const response = await clientsClient.get('anything/clients');
-            const data = await response.json();
-            expect(getHeader(data.headers, 'X-Api-Key')).toBe('demo-api-key-12345');
-            expect(data.url).toContain('/anything/clients');
-            expect(data.method).toBe('GET');
-        }, 10000);
-        it('should include Basic auth for contracts endpoints', async () => {
-            const response = await contractsClient.get('anything/contracts');
-            const data = await response.json();
-            const authHeader = getHeader(data.headers, 'Authorization');
-            expect(authHeader).toMatch(/^Basic /);
-            expect(authHeader).toBe(`Basic ${Buffer.from('demo-user:demo-pass').toString('base64')}`);
-            expect(data.url).toContain('/anything/contracts');
-        }, 10000);
-        it('should remove auth headers when overridden with undefined', async () => {
-            const response = await clientsClient.get('anything/clients/export', {
-                headers: { 'X-API-Key': undefined }
-            });
-            const data = await response.json();
-            expect(getHeader(data.headers, 'X-Api-Key')).toBeUndefined();
-            expect(data.url).toContain('/anything/clients/export');
-        }, 10000);
-        it('should properly handle POST with JSON data and authentication', async () => {
-            const testData = { name: 'Test Client', email: 'test@example.com' };
-            const response = await clientsClient.post('anything/clients', { json: testData });
-            const data = await response.json();
-            expect(getHeader(data.headers, 'X-Api-Key')).toBe('demo-api-key-12345');
-            expect(data.json).toEqual(testData);
-            expect(data.method).toBe('POST');
-        }, 10000);
-    });
-    describe('URL Path Construction', () => {
-        it('should correctly build URLs with chained prefixUrl', async () => {
-            const response = await clientsClient.get('anything/clients/details');
-            const data = await response.json();
-            expect(data.url).toContain('/anything/clients/details');
-        }, 10000);
-        it('should handle root path correctly', async () => {
-            const response = await contractsClient.get('anything/contracts');
-            const data = await response.json();
-            expect(data.url).toMatch(/\/anything\/contracts\/?$/);
-        }, 10000);
-        it('should handle POST to specific endpoints', async () => {
-            const testContract = { clientId: '123', title: 'Test Contract', value: 5000 };
-            const response = await contractsClient.post('anything/contracts/create', { json: testContract });
-            const data = await response.json();
-            expect(data.url).toContain('/anything/contracts/create');
-            expect(data.method).toBe('POST');
-            expect(data.json).toEqual(testContract);
-        }, 10000);
-    });
-    describe('Authentication Override Patterns', () => {
-        it('should allow per-request header overrides', async () => {
-            const response = await clientsClient.get('anything/clients/public', {
-                headers: {
-                    'X-API-Key': 'different-key-456'
-                }
-            });
-            const data = await response.json();
-            expect(getHeader(data.headers, 'X-Api-Key')).toBe('different-key-456');
-        }, 10000);
-        it('should support multiple authentication methods', async () => {
-            const response = await contractsClient.get('anything/contracts/special', {
-                headers: {
-                    'X-Special-Token': 'special-value',
-                    'X-Client-ID': 'client-123'
-                }
-            });
-            const data = await response.json();
-            expect(getHeader(data.headers, 'Authorization')).toMatch(/^Basic /);
-            expect(getHeader(data.headers, 'X-Special-Token')).toBe('special-value');
-            expect(getHeader(data.headers, 'X-Client-Id')).toBe('client-123');
-        }, 10000);
-    });
-    describe('Real API Client Pattern', () => {
-        it('should demonstrate the complete authentication pattern', async () => {
-            const clientsResponse = await clientsClient.get('anything/clients');
-            const clientsData = await clientsResponse.json();
-            expect(getHeader(clientsData.headers, 'X-Api-Key')).toBe('demo-api-key-12345');
-            const createResponse = await clientsClient.post('anything/clients', {
-                json: { name: 'Test Client', email: 'test@example.com' }
-            });
-            const createData = await createResponse.json();
-            expect(getHeader(createData.headers, 'X-Api-Key')).toBe('demo-api-key-12345');
-            const exportResponse = await clientsClient.get('anything/clients/export', { headers: { 'X-API-Key': undefined } });
-            const exportData = await exportResponse.json();
-            expect(getHeader(exportData.headers, 'X-Api-Key')).toBeUndefined();
-            const contractsResponse = await contractsClient.get('anything/contracts');
-            const contractsResponseData = await contractsResponse.json();
-            expect(getHeader(contractsResponseData.headers, 'Authorization')).toMatch(/^Basic /);
-            const contractCreateResponse = await contractsClient.post('anything/contracts', {
-                json: { clientId: '123', title: 'Service Agreement', value: 10000 }
-            });
-            const contractCreateData = await contractCreateResponse.json();
-            expect(getHeader(contractCreateData.headers, 'Authorization')).toMatch(/^Basic /);
-        }, 15000);
-    });
-    describe('Error Tracing', () => {
-        beforeEach(() => {
-            mockedTracing.addEventStart.mockClear();
-            mockedTracing.addEventEnd.mockClear();
-            mockedTracing.addEventError.mockClear();
-        });
-        it('should trace timeout errors exactly once (no double-tracing)', async () => {
-            const timeoutClient = httpClient({
-                prefixUrl: 'https://httpbingo.org',
-                timeout: 1 // 1ms timeout will definitely fail on /delay/5
-            });
-            // Timeout will throw either TimeoutError or DOMException (AbortError)
-            await expect(timeoutClient.get('delay/5')).rejects.toThrow();
-            // Timeout errors should be traced by the wrapped fetch exactly once
-            expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-            expect(errorCall).toHaveProperty('id');
-            expect(errorCall).toHaveProperty('details');
-            // In real execution, ky's timeout throws a DOMException (AbortError)
-            expect(errorCall.details).toHaveProperty('message');
-            expect(errorCall.details.message).toMatch(/Fetch aborted|Unknown error/);
-        }, 10000);
-    });
-    describe('Trace ID Lifecycle', () => {
-        beforeEach(() => {
-            mockedTracing.addEventStart.mockClear();
-            mockedTracing.addEventEnd.mockClear();
-            mockedTracing.addEventError.mockClear();
-        });
-        it('should use same UUID trace ID for addEventStart and addEventEnd on successful requests', async () => {
-            const response = await httpBinClient.get('anything/success-trace');
-            expect(response.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-            expect(mockedTracing.addEventEnd).toHaveBeenCalledTimes(1);
-            const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-            const endCall = mockedTracing.addEventEnd.mock.calls[0][0];
-            expect(isUuidFormat(startCall.id)).toBe(true);
-            expect(isUuidFormat(endCall.id)).toBe(true);
-            expect(startCall.id).toBe(endCall.id);
-        }, 10000);
-        it('should use same UUID trace ID for addEventStart and addEventError on HTTP errors', async () => {
-            const noRetryClient = httpBinClient.extend({
-                retry: { limit: 0 }
-            });
-            await expect(noRetryClient.get('status/500')).rejects.toThrow();
-            expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-            expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-            const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-            expect(isUuidFormat(startCall.id)).toBe(true);
-            expect(isUuidFormat(errorCall.id)).toBe(true);
-            expect(startCall.id).toBe(errorCall.id);
-        }, 10000);
-        it('should use same UUID trace ID for addEventStart and addEventError on timeout errors', async () => {
-            const timeoutClient = httpClient({
-                prefixUrl: 'https://httpbingo.org',
-                timeout: 50
-            });
-            await expect(timeoutClient.get('delay/2')).rejects.toThrow();
-            expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-            expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-            const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-            expect(isUuidFormat(startCall.id)).toBe(true);
-            expect(isUuidFormat(errorCall.id)).toBe(true);
-            expect(startCall.id).toBe(errorCall.id);
-        }, 10000);
-        it('should maintain trace ID consistency between ky hooks and wrapped fetch', async () => {
-            const errorClient = httpClient({
-                prefixUrl: 'https://httpbingo.org',
-                timeout: 1,
-                retry: { limit: 0 }
-            });
-            try {
-                await errorClient.get('delay/5');
-                expect.fail('Should have thrown timeout error');
-            }
-            catch {
-                // Expected timeout error
-            }
-            expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-            expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-            const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-            expect(isUuidFormat(startCall.id)).toBe(true);
-            expect(isUuidFormat(errorCall.id)).toBe(true);
-            expect(startCall.id).toBe(errorCall.id);
-        }, 10000);
-        it('should always use UUID format when assignRequestId hook is present', async () => {
-            const scenarios = [
-                { method: 'GET', url: 'anything/test-1' },
-                { method: 'POST', url: 'anything/test-2', body: { data: 'test' } },
-                { method: 'PUT', url: 'anything/test-3', body: { update: true } },
-                { method: 'DELETE', url: 'anything/test-4' }
-            ];
-            for (const scenario of scenarios) {
-                mockedTracing.addEventStart.mockClear();
-                mockedTracing.addEventEnd.mockClear();
-                if (scenario.method === 'GET') {
-                    await httpBinClient.get(scenario.url);
-                }
-                else if (scenario.method === 'POST') {
-                    await httpBinClient.post(scenario.url, { json: scenario.body });
-                }
-                else if (scenario.method === 'PUT') {
-                    await httpBinClient.put(scenario.url, { json: scenario.body });
-                }
-                else if (scenario.method === 'DELETE') {
-                    await httpBinClient.delete(scenario.url);
-                }
-                const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-                const endCall = mockedTracing.addEventEnd.mock.calls[0][0];
-                expect(isUuidFormat(startCall.id)).toBe(true);
-                expect(isUuidFormat(endCall.id)).toBe(true);
-                expect(startCall.id).toBe(endCall.id);
-            }
-        }, 15000);
-    });
-    describe('No Tracing Without X-Request-ID', () => {
-        beforeEach(() => {
-            mockedTracing.addEventStart.mockClear();
-            mockedTracing.addEventEnd.mockClear();
-            mockedTracing.addEventError.mockClear();
-            vi.spyOn(console, 'warn').mockImplementation(() => { });
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        it('should skip tracing when assignRequestId hook is not present', async () => {
-            const noUuidClient = ky.create({
-                prefixUrl: 'https://httpbingo.org',
-                hooks: {
-                    beforeRequest: [
-                        traceRequest
-                    ],
-                    afterResponse: [
-                        traceResponse
-                    ],
-                    beforeError: [
-                        traceError
-                    ]
-                }
-            });
-            const wrappedNoUuidClient = noUuidClient.extend({
-                fetch: applyFetchErrorTracing(globalThis.fetch)
-            });
-            const response = await wrappedNoUuidClient.get('anything/no-trace-test');
-            expect(response.status).toBe(200);
-            // No tracing should occur without X-Request-ID
-            expect(mockedTracing.addEventStart).not.toHaveBeenCalled();
-            expect(mockedTracing.addEventEnd).not.toHaveBeenCalled();
-            // Warning should be logged
-            expect(console.warn).toHaveBeenCalledWith('createTraceId: X-Request-ID header not found. Tracing will be skipped for this request.');
-        }, 10000);
-        it('should skip tracing for errors when X-Request-ID is missing', async () => {
-            const noUuidClient = ky.create({
-                prefixUrl: 'https://httpbingo.org',
-                hooks: {
-                    beforeRequest: [traceRequest],
-                    afterResponse: [traceResponse],
-                    beforeError: [traceError]
-                },
-                retry: { limit: 0 }
-            }).extend({
-                fetch: applyFetchErrorTracing(globalThis.fetch)
-            });
-            await expect(noUuidClient.get('status/500')).rejects.toThrow();
-            // No error tracing should occur without X-Request-ID
-            expect(mockedTracing.addEventStart).not.toHaveBeenCalled();
-            expect(mockedTracing.addEventError).not.toHaveBeenCalled();
-            // Warning should be logged
-            expect(console.warn).toHaveBeenCalled();
-        }, 10000);
-    });
-    describe('Trace ID Generation - Request Object Validation', () => {
-        beforeEach(() => {
-            mockedTracing.addEventStart.mockClear();
-            mockedTracing.addEventEnd.mockClear();
-            mockedTracing.addEventError.mockClear();
-        });
-        it('should pass a valid Request object to createTraceId', async () => {
-            const response = await httpBinClient.get('anything/trace-validation');
-            expect(response.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-            const traceId = startCall.id;
-            // Trace ID should be a UUID from X-Request-ID header
-            expect(isUuidFormat(traceId)).toBe(true);
-            // An empty object would return null (no X-Request-ID header)
-            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const emptyObjectResult = createTraceId({});
-            expect(emptyObjectResult).toBeNull();
-            warnSpy.mockRestore();
-        }, 10000);
-        it('should produce different trace IDs for GET vs POST to same endpoint', async () => {
-            mockedTracing.addEventStart.mockClear();
-            // Make GET request to specific endpoint
-            const getResponse = await httpBinClient.get('anything/trace-same-endpoint');
-            expect(getResponse.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            const getTraceId = mockedTracing.addEventStart.mock.calls[0][0].id;
-            mockedTracing.addEventStart.mockClear();
-            // Make POST request to SAME endpoint
-            const postResponse = await httpBinClient.post('anything/trace-same-endpoint', { json: { data: 'test' } });
-            expect(postResponse.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            const postTraceId = mockedTracing.addEventStart.mock.calls[0][0].id;
-            expect(getTraceId).not.toBe(postTraceId);
-            expect(isUuidFormat(getTraceId)).toBe(true);
-            expect(isUuidFormat(postTraceId)).toBe(true);
-        }, 10000);
-        it('should generate unique trace IDs for identical requests', async () => {
-            mockedTracing.addEventStart.mockClear();
-            const response1 = await httpBinClient.get('anything/unique-requests-1');
-            expect(response1.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            const traceId1 = mockedTracing.addEventStart.mock.calls[0][0].id;
-            mockedTracing.addEventStart.mockClear();
-            const response2 = await httpBinClient.get('anything/unique-requests-1');
-            expect(response2.status).toBe(200);
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            const traceId2 = mockedTracing.addEventStart.mock.calls[0][0].id;
-            expect(isUuidFormat(traceId1)).toBe(true);
-            expect(isUuidFormat(traceId2)).toBe(true);
-            expect(traceId1).not.toBe(traceId2);
-        }, 10000);
-        it('should maintain trace ID consistency during timeout errors', async () => {
-            const timeoutClient = httpClient({
-                prefixUrl: 'https://httpbingo.org',
-                timeout: 300
-            });
-            mockedTracing.addEventStart.mockClear();
-            mockedTracing.addEventError.mockClear();
-            try {
-                await timeoutClient.get('delay/3');
-                expect.fail('Should have thrown timeout error');
-            }
-            catch {
-                expect(mockedTracing.addEventStart).toHaveBeenCalled();
-                const startCall = mockedTracing.addEventStart.mock.calls[0][0];
-                const requestTraceId = startCall.id;
-                expect(mockedTracing.addEventError).toHaveBeenCalled();
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                const errorTraceId = errorCall.id;
-                expect(isUuidFormat(requestTraceId)).toBe(true);
-                expect(isUuidFormat(errorTraceId)).toBe(true);
-                expect(requestTraceId).toBe(errorTraceId);
-            }
-        }, 10000);
-    });
-});

package/dist/utils/create_trace_id.d.ts

@@ -1,13 +0,0 @@
-/**
- * Create a trace ID from the X-Request-ID header
- *
- * Returns the X-Request-ID header value if present, otherwise returns null.
- * When null is returned, tracing should be skipped entirely.
- *
- * The X-Request-ID header is assigned by the assignRequestId hook,
- * ensuring each request invocation has a unique identifier for tracing.
- *
- * @param {Request} request - The fetch API request object
- * @returns {string | null} The X-Request-ID value or null if not present
- */
-export default function createTraceId(request: Request): string | null;

package/dist/utils/create_trace_id.js

@@ -1,20 +0,0 @@
-/**
- * Create a trace ID from the X-Request-ID header
- *
- * Returns the X-Request-ID header value if present, otherwise returns null.
- * When null is returned, tracing should be skipped entirely.
- *
- * The X-Request-ID header is assigned by the assignRequestId hook,
- * ensuring each request invocation has a unique identifier for tracing.
- *
- * @param {Request} request - The fetch API request object
- * @returns {string | null} The X-Request-ID value or null if not present
- */
-export default function createTraceId(request) {
-    const requestId = request.headers?.get('X-Request-ID');
-    if (!requestId) {
-        console.warn('createTraceId: X-Request-ID header not found. Tracing will be skipped for this request.');
-        return null;
-    }
-    return requestId;
-}

package/dist/utils/create_trace_id.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/create_trace_id.spec.js

@@ -1,20 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import createTraceId from './create_trace_id.js';
-describe('utils/create_trace_id', () => {
-    it('returns the X-Request-ID header when present', () => {
-        const req = new Request('https://ex.com/users/1', {
-            method: 'GET',
-            headers: { 'X-Request-ID': 'test-uuid-123' }
-        });
-        const id = createTraceId(req);
-        expect(id).toBe('test-uuid-123');
-    });
-    it('returns null and logs warning when X-Request-ID header is missing', () => {
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const req = new Request('https://ex.com/users/1', { method: 'GET' });
-        const id = createTraceId(req);
-        expect(id).toBeNull();
-        expect(warnSpy).toHaveBeenCalledWith('createTraceId: X-Request-ID header not found. Tracing will be skipped for this request.');
-        warnSpy.mockRestore();
-    });
-});

package/dist/utils/index.d.ts

@@ -1,4 +0,0 @@
-export { default as parseResponseBody } from './parse_response_body.js';
-export { default as parseRequestBody } from './parse_request_body.js';
-export { default as redactHeaders } from './redact_headers.js';
-export { default as createTraceId } from './create_trace_id.js';

package/dist/utils/index.js

@@ -1,4 +0,0 @@
-export { default as parseResponseBody } from './parse_response_body.js';
-export { default as parseRequestBody } from './parse_request_body.js';
-export { default as redactHeaders } from './redact_headers.js';
-export { default as createTraceId } from './create_trace_id.js';

package/dist/utils/parse_request_body.d.ts

@@ -1,7 +0,0 @@
-/**
- * Safely parses request body as JSON, falling back to string if parsing fails
- *
- * @param {Request} request - The fetch API request object
- * @returns {object|string|null} The parsed response
- */
-export default function parseRequestBody(request: Request): Promise<object | string | null>;

package/dist/utils/parse_request_body.js

@@ -1,19 +0,0 @@
-/**
- * Safely parses request body as JSON, falling back to string if parsing fails
- *
- * @param {Request} request - The fetch API request object
- * @returns {object|string|null} The parsed response
- */
-export default async function parseRequestBody(request) {
-    if (!request.body) {
-        return null;
-    }
-    const cloned = request.clone();
-    const body = await cloned.text();
-    try {
-        return JSON.parse(body);
-    }
-    catch {
-        return body;
-    }
-}

package/dist/utils/parse_request_body.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/parse_request_body.spec.js

@@ -1,19 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import parseRequestBody from './parse_request_body.js';
-describe('utils/parse_request_body', () => {
-    it('returns null when no body is present', async () => {
-        const req = new Request('https://ex.com', { method: 'GET' });
-        const result = await parseRequestBody(req);
-        expect(result).toBeNull();
-    });
-    it('parses JSON body when present', async () => {
-        const req = new Request('https://ex.com', { method: 'POST', body: JSON.stringify({ a: 1 }) });
-        const result = await parseRequestBody(req);
-        expect(result).toEqual({ a: 1 });
-    });
-    it('returns raw text when not valid JSON', async () => {
-        const req = new Request('https://ex.com', { method: 'POST', body: 'not-json' });
-        const result = await parseRequestBody(req);
-        expect(result).toBe('not-json');
-    });
-});

package/dist/utils/parse_response_body.d.ts

@@ -1,10 +0,0 @@
-import type { KyResponse } from 'ky';
-/**
- * Parses response body based on content type:
- * - application/json = object
- * - text/plain = string
- *
- * @param {KyResponse} response
- * @returns {object|string|null} The parsed response
- */
-export default function parseResponseBody(response: KyResponse): Promise<object | string | null>;

package/dist/utils/parse_response_body.js

@@ -1,14 +0,0 @@
-/**
- * Parses response body based on content type:
- * - application/json = object
- * - text/plain = string
- *
- * @param {KyResponse} response
- * @returns {object|string|null} The parsed response
- */
-export default async function parseResponseBody(response) {
-    const cloned = response.clone();
-    const contentType = response.headers.get('content-type') || '';
-    const body = await cloned[contentType.includes('application/json') ? 'json' : 'text']();
-    return body || null;
-}

package/dist/utils/parse_response_body.spec.d.ts

@@ -1 +0,0 @@
-export {};