@outputai/http 0.1.1 → 0.1.2

package/dist/index.spec.js

@@ -1,391 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { httpClient, HTTPError, TimeoutError } from './index.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { config } from './config.js';
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventStart: vi.fn(),
-        addEventEnd: vi.fn(),
-        addEventError: vi.fn()
-    }
-}));
-vi.mock('./config.js', () => ({
-    config: {
-        logVerbose: false
-    }
-}));
-// Mock ky at the module level to intercept at the source
-vi.mock('ky', () => {
-    const createMockResponse = () => new Response(JSON.stringify({ success: true }), {
-        status: 200,
-        headers: { 'content-type': 'application/json' }
-    });
-    // Mock error types that match ky's actual error classes
-    // IMPORTANT: These must be the same instances exported by the mock
-    // so that instanceof checks work correctly
-    class MockHTTPError extends Error {
-        response;
-        request;
-        options;
-        constructor(response, request, options) {
-            super(`${response.status} ${response.statusText}`);
-            this.name = 'HTTPError';
-            this.response = response;
-            this.request = request;
-            this.options = options;
-        }
-    }
-    class MockTimeoutError extends Error {
-        request;
-        constructor(request) {
-            super('Request timed out');
-            this.name = 'TimeoutError';
-            this.request = request;
-        }
-    }
-    // Helper to extract URL string from various input types
-    const getUrlString = (input) => {
-        if (typeof input === 'string') {
-            return input;
-        }
-        if (input instanceof Request) {
-            return input.url;
-        }
-        return input.toString();
-    };
-    // Default mock fetch implementation
-    const defaultMockFetch = (input, init) => {
-        const urlStr = getUrlString(input);
-        const request = input instanceof Request ? input : new Request(urlStr, init);
-        // Simulate timeout error (bypass hooks, thrown at fetch level)
-        if (urlStr.includes('/timeout')) {
-            throw new MockTimeoutError(request);
-        }
-        // Simulate network error (bypass hooks, thrown at fetch level)
-        if (urlStr.includes('/network-error')) {
-            throw new TypeError('Failed to fetch');
-        }
-        // Simulate HTTP 500 error (goes through hooks)
-        if (urlStr.includes('/500')) {
-            return Promise.resolve(new Response('Internal Server Error', {
-                status: 500,
-                statusText: 'Internal Server Error'
-            }));
-        }
-        // Simulate HTTP 404 error (goes through hooks)
-        if (urlStr.includes('/404')) {
-            return Promise.resolve(new Response('Not Found', {
-                status: 404,
-                statusText: 'Not Found'
-            }));
-        }
-        return Promise.resolve(createMockResponse());
-    };
-    class MockKy {
-        hooks = {};
-        options = {};
-        customFetch;
-        constructor(options = {}) {
-            this.hooks = options.hooks || {};
-            // Use provided fetch or default mock fetch
-            this.customFetch = options.fetch || defaultMockFetch;
-            // Store options with fetch function included
-            this.options = {
-                ...options,
-                fetch: this.customFetch
-            };
-        }
-        async runHooks(hookType, ...args) {
-            const hooks = this.hooks[hookType] || [];
-            for (const hook of hooks) {
-                await hook(...args);
-            }
-        }
-        async get(url, options = {}) {
-            return this.makeRequest('GET', url, options);
-        }
-        async post(url, options = {}) {
-            return this.makeRequest('POST', url, options);
-        }
-        async put(url, options = {}) {
-            return this.makeRequest('PUT', url, options);
-        }
-        async patch(url, options = {}) {
-            return this.makeRequest('PATCH', url, options);
-        }
-        async delete(url, options = {}) {
-            return this.makeRequest('DELETE', url, options);
-        }
-        async makeRequest(method, url, options = {}) {
-            // Construct full URL like ky would
-            const fullUrl = this.options.prefixUrl ? `${this.options.prefixUrl}/${url}` : `https://example.com/${url}`;
-            const request = new Request(fullUrl, { method });
-            // Run beforeRequest hooks
-            await this.runHooks('beforeRequest', request);
-            // Use the custom fetch (which may be wrapped by applyFetchErrorTracing)
-            // Fetch-level errors (timeout, network) bypass hooks entirely and will throw
-            const response = await this.customFetch(request, { method });
-            // Check for HTTP errors (non-2xx status codes)
-            if (!response.ok) {
-                const httpError = new MockHTTPError(response, request, options);
-                // Run beforeError hooks for HTTP errors
-                try {
-                    await this.runHooks('beforeError', httpError);
-                }
-                catch (hookErr) {
-                    // Hooks can transform the error
-                    throw hookErr;
-                }
-                throw httpError;
-            }
-            // Run afterResponse hooks for successful responses
-            await this.runHooks('afterResponse', request, options, response);
-            return response;
-        }
-        extend(options = {}) {
-            // Handle function-based options (like applyDefaultOptions returns)
-            const resolvedOptions = typeof options === 'function' ? options(this.options) : options;
-            const mergedOptions = { ...this.options, ...resolvedOptions };
-            const mergedHooks = { ...this.hooks };
-            if (resolvedOptions.hooks) {
-                Object.entries(resolvedOptions.hooks).forEach(([hookType, hookArray]) => {
-                    mergedHooks[hookType] = [
-                        ...(this.hooks[hookType] || []),
-                        ...(Array.isArray(hookArray) ? hookArray : [])
-                    ];
-                });
-            }
-            mergedOptions.hooks = mergedHooks;
-            return new MockKy(mergedOptions);
-        }
-        create(options = {}) {
-            return new MockKy(options);
-        }
-    }
-    return {
-        default: new MockKy(),
-        create: (options) => new MockKy(options),
-        HTTPError: MockHTTPError,
-        TimeoutError: MockTimeoutError
-    };
-});
-const mockedTracing = vi.mocked(Tracing, true);
-const mockedConfig = vi.mocked(config);
-describe('HTTP Client', () => {
-    beforeEach(() => {
-        mockedTracing.addEventStart.mockClear();
-        mockedTracing.addEventEnd.mockClear();
-        mockedTracing.addEventError.mockClear();
-    });
-    describe('httpClient function', () => {
-        it('should create an HTTP client with default options', () => {
-            const client = httpClient();
-            expect(client).toBeDefined();
-            expect(typeof client.get).toBe('function');
-            expect(typeof client.post).toBe('function');
-            expect(typeof client.put).toBe('function');
-            expect(typeof client.patch).toBe('function');
-            expect(typeof client.delete).toBe('function');
-        });
-        it('should create an HTTP client with custom options', () => {
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com',
-                timeout: 5000
-            });
-            expect(client).toBeDefined();
-        });
-        it('should allow method chaining with extend', () => {
-            const client = httpClient();
-            const extendedClient = client.extend({
-                headers: { 'X-Custom': 'test' }
-            });
-            expect(extendedClient).toBeDefined();
-        });
-    });
-    describe('HTTP Client Interface', () => {
-        it('should have all HTTP methods', () => {
-            const client = httpClient();
-            expect(typeof client.get).toBe('function');
-            expect(typeof client.post).toBe('function');
-            expect(typeof client.put).toBe('function');
-            expect(typeof client.patch).toBe('function');
-            expect(typeof client.delete).toBe('function');
-        });
-    });
-    describe('Error Exports', () => {
-        it('should export HTTPError', () => {
-            expect(HTTPError).toBeDefined();
-            expect(typeof HTTPError).toBe('function');
-        });
-        it('should export TimeoutError', () => {
-            expect(TimeoutError).toBeDefined();
-            expect(typeof TimeoutError).toBe('function');
-        });
-    });
-    describe('Tracing Configuration', () => {
-        it('should not trace headers or bodies by default', async () => {
-            mockedConfig.logVerbose = false;
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            await client.get('users/1');
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-        });
-        it('should trace headers and bodies when verbose logging is enabled', async () => {
-            mockedConfig.logVerbose = true;
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            await client.post('users', { json: { name: 'test', email: 'test@example.com' } });
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-        });
-    });
-    describe('Hook Preservation', () => {
-        it('should preserve original hooks when extending client with custom hooks', async () => {
-            const customBeforeRequestCalled = vi.fn();
-            const customAfterResponseCalled = vi.fn();
-            const customBeforeErrorCalled = vi.fn();
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            const extendedClient = client.extend({
-                hooks: {
-                    beforeRequest: [
-                        async (request) => {
-                            customBeforeRequestCalled();
-                            return request;
-                        }
-                    ],
-                    afterResponse: [
-                        async (_request, _options, response) => {
-                            customAfterResponseCalled();
-                            return response;
-                        }
-                    ],
-                    beforeError: [
-                        async (error) => {
-                            customBeforeErrorCalled();
-                            return error;
-                        }
-                    ]
-                }
-            });
-            await extendedClient.get('users/1');
-            expect(customBeforeRequestCalled).toHaveBeenCalled();
-            expect(customAfterResponseCalled).toHaveBeenCalled();
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            expect(mockedTracing.addEventEnd).toHaveBeenCalled();
-        });
-    });
-    describe('Mocking Verification', () => {
-        it('should use mocked responses and not make real HTTP requests', async () => {
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            // Test GET request
-            const getResponse = await client.get('users/1');
-            const getData = await getResponse.json();
-            expect(getData).toEqual({ success: true });
-            // Test POST request
-            const postResponse = await client.post('users', { json: { name: 'test' } });
-            const postData = await postResponse.json();
-            expect(postData).toEqual({ success: true });
-            // Verify no actual network delay (should be very fast)
-            const startTime = Date.now();
-            await client.get('test');
-            const duration = Date.now() - startTime;
-            expect(duration).toBeLessThan(50); // Mocked calls should be nearly instantaneous
-            // Verify that responses come from mocks, not real HTTP
-            expect(getData.success).toBe(true);
-            expect(postData.success).toBe(true);
-        });
-    });
-    describe('Error Tracing', () => {
-        describe('Fetch-Level Errors (should be traced by wrapped fetch)', () => {
-            it('should trace timeout errors that bypass ky hooks', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/timeout')).rejects.toThrow(TimeoutError);
-                // Timeout errors should be traced by the wrapped fetch
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('message');
-                expect(errorCall.details).toHaveProperty('error');
-            });
-            it('should trace network errors that bypass ky hooks', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/network-error')).rejects.toThrow(TypeError);
-                // Network errors should be traced by the wrapped fetch
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('message');
-                expect(errorCall.details.message).toBe('Unknown error occurred');
-                expect(errorCall.details).toHaveProperty('error');
-            });
-        });
-        describe('HTTP Errors (should be traced by beforeError hook only)', () => {
-            it('should trace HTTP 500 errors via beforeError hook, not fetch wrapper', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                // HTTP errors should be traced by the beforeError hook (traceError)
-                // The wrapped fetch should NOT trace it (to prevent double-tracing)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('status', 500);
-                expect(errorCall.details).toHaveProperty('statusText', 'Internal Server Error');
-            });
-            it('should trace HTTP 404 errors via beforeError hook, not fetch wrapper', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/404')).rejects.toThrow(HTTPError);
-                // HTTP errors should be traced by the beforeError hook (traceError)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('status', 404);
-                expect(errorCall.details).toHaveProperty('statusText', 'Not Found');
-            });
-            it('should not double-trace HTTP errors', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                // Should only be traced once (by beforeError hook)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            });
-        });
-        describe('Error Type Differentiation', () => {
-            it('should handle timeout and HTTP errors differently in the same client', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                // Test timeout error
-                mockedTracing.addEventError.mockClear();
-                await expect(client.get('users/timeout')).rejects.toThrow(TimeoutError);
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const timeoutCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(timeoutCall.details).toHaveProperty('message');
-                expect(timeoutCall.details).toHaveProperty('error');
-                // Test HTTP error
-                mockedTracing.addEventError.mockClear();
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const httpCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(httpCall.details).toHaveProperty('status', 500);
-            });
-        });
-    });
-});

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 {};

package/dist/utils/parse_response_body.spec.js

@@ -1,19 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import parseResponseBody from './parse_response_body.js';
-describe('utils/parse_response_body', () => {
-    it('parses JSON when content-type is application/json', async () => {
-        const res = new Response(JSON.stringify({ ok: true }), { headers: { 'content-type': 'application/json' } });
-        const result = await parseResponseBody(res);
-        expect(result).toEqual({ ok: true });
-    });
-    it('returns text when content-type is not JSON', async () => {
-        const res = new Response('hello', { headers: { 'content-type': 'text/plain' } });
-        const result = await parseResponseBody(res);
-        expect(result).toBe('hello');
-    });
-    it('returns null for empty body', async () => {
-        const res = new Response('', { headers: { 'content-type': 'text/plain' } });
-        const result = await parseResponseBody(res);
-        expect(result).toBeNull();
-    });
-});

package/dist/utils/redact_headers.d.ts

@@ -1,6 +0,0 @@
-/**
- * Redacts sensitive headers for safe logging
- * @param headers - Headers object to redact
- * @returns Object with sensitive headers redacted
- */
-export default function redactHeaders(headers: Record<string, string> | Headers): Record<string, string>;

package/dist/utils/redact_headers.js

@@ -1,27 +0,0 @@
-/**
- * Sensitive header patterns for redaction (case-insensitive)
- */
-const SENSITIVE_HEADER_PATTERNS = [
-    /authorization/i,
-    /token/i,
-    /api-?key/i,
-    /secret/i,
-    /password/i,
-    /pwd/i,
-    /key/i,
-    /cookie/i
-];
-/**
- * Redacts sensitive headers for safe logging
- * @param headers - Headers object to redact
- * @returns Object with sensitive headers redacted
- */
-export default function redactHeaders(headers) {
-    const result = {};
-    const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
-    for (const [key, value] of entries) {
-        const isSensitive = SENSITIVE_HEADER_PATTERNS.some(pattern => pattern.test(key));
-        result[key] = isSensitive ? '[REDACTED]' : value;
-    }
-    return result;
-}

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

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