@ragbits/api-client 0.0.2 → 1.3.0

package/src/index.ts

@@ -1,213 +0,0 @@
-import type {
-    ClientConfig,
-    StreamCallbacks,
-    ApiEndpointPath,
-    ApiEndpointResponse,
-    TypedApiRequestOptions,
-    StreamingEndpointPath,
-    StreamingEndpointRequest,
-    StreamingEndpointStream,
-} from './types'
-
-/**
- * Client for communicating with the Ragbits API
- */
-export class RagbitsClient {
-    private readonly baseUrl: string
-
-    /**
-     * @param config - Configuration object
-     */
-    constructor(config: ClientConfig = {}) {
-        this.baseUrl = config.baseUrl || 'http://127.0.0.1:8000'
-
-        // Validate the base URL
-        try {
-            new URL(this.baseUrl)
-        } catch {
-            throw new Error(
-                `Invalid base URL: ${this.baseUrl}. Please provide a valid URL.`
-            )
-        }
-
-        if (this.baseUrl.endsWith('/')) {
-            this.baseUrl = this.baseUrl.slice(0, -1)
-        }
-    }
-
-    /**
-     * Get the base URL used by this client
-     */
-    getBaseUrl(): string {
-        return this.baseUrl
-    }
-
-    /**
-     * Build full API URL from path
-     * @private
-     */
-    private _buildApiUrl(path: string): string {
-        return `${this.baseUrl}${path}`
-    }
-
-    /**
-     * Make a request to the API
-     * @private
-     */
-    private async _makeRequest(
-        url: string,
-        options: RequestInit = {}
-    ): Promise<Response> {
-        const defaultOptions: RequestInit = {
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        }
-
-        const response = await fetch(url, { ...defaultOptions, ...options })
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`)
-        }
-        return response
-    }
-
-    /**
-     * Method to make API requests to known endpoints only
-     * @param endpoint - API endpoint path (must be predefined)
-     * @param options - Typed request options for the specific endpoint
-     */
-    async makeRequest<T extends ApiEndpointPath>(
-        endpoint: T,
-        options?: TypedApiRequestOptions<T>
-    ): Promise<ApiEndpointResponse<T>> {
-        const {
-            method = 'GET',
-            body,
-            headers = {},
-            ...restOptions
-        } = options || {}
-
-        const requestOptions: RequestInit = {
-            method,
-            headers,
-            ...restOptions, // This will include signal and other fetch options
-        }
-
-        if (body && method !== 'GET') {
-            requestOptions.body =
-                typeof body === 'string' ? body : JSON.stringify(body)
-        }
-
-        const response = await this._makeRequest(
-            this._buildApiUrl(endpoint),
-            requestOptions
-        )
-        return response.json()
-    }
-
-    /**
-     * Method for streaming requests to known endpoints only
-     * @param endpoint - Streaming endpoint path (must be predefined)
-     * @param data - Request data
-     * @param callbacks - Stream callbacks
-     * @param signal - Optional AbortSignal for cancelling the request
-     */
-    makeStreamRequest<T extends StreamingEndpointPath>(
-        endpoint: T,
-        data: StreamingEndpointRequest<T>,
-        callbacks: StreamCallbacks<StreamingEndpointStream<T>>,
-        signal?: AbortSignal
-    ): () => void {
-        let isCancelled = false
-
-        const processStream = async (response: Response): Promise<void> => {
-            const reader = response.body
-                ?.pipeThrough(new TextDecoderStream())
-                .getReader()
-
-            if (!reader) {
-                throw new Error('Response body is null')
-            }
-
-            while (!isCancelled && !signal?.aborted) {
-                try {
-                    const { value, done } = await reader.read()
-                    if (done) {
-                        callbacks.onClose?.()
-                        break
-                    }
-
-                    const lines = value.split('\n')
-                    for (const line of lines) {
-                        if (!line.startsWith('data: ')) continue
-
-                        try {
-                            const jsonString = line.replace('data: ', '').trim()
-                            const parsedData = JSON.parse(
-                                jsonString
-                            ) as StreamingEndpointStream<T>
-                            await callbacks.onMessage(parsedData)
-                        } catch (parseError) {
-                            console.error('Error parsing JSON:', parseError)
-                            await callbacks.onError(
-                                new Error('Error processing server response')
-                            )
-                        }
-                    }
-                } catch (streamError) {
-                    console.error('Stream error:', streamError)
-                    await callbacks.onError(new Error('Error reading stream'))
-                    break
-                }
-            }
-        }
-
-        const startStream = async (): Promise<void> => {
-            try {
-                const response = await fetch(this._buildApiUrl(endpoint), {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'text/event-stream',
-                    },
-                    body: JSON.stringify(data),
-                    signal,
-                })
-
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`)
-                }
-
-                await processStream(response)
-            } catch (error) {
-                if (signal?.aborted) {
-                    return
-                }
-
-                console.error('Request error:', error)
-                const errorMessage =
-                    error instanceof Error
-                        ? error.message
-                        : 'Error connecting to server'
-                await callbacks.onError(new Error(errorMessage))
-            }
-        }
-
-        try {
-            startStream()
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error
-                    ? error.message
-                    : 'Failed to start stream'
-            callbacks.onError(new Error(errorMessage))
-        }
-
-        return () => {
-            isCancelled = true
-        }
-    }
-}
-
-// Re-export types
-export * from './types'

package/src/test/RagbitsClient.test.ts

@@ -1,484 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { RagbitsClient } from '../index'
-import { server } from './setup'
-import { http, HttpResponse } from 'msw'
-import type { FeedbackRequest } from '../types'
-import { FeedbackType } from '../types'
-import { defaultConfigResponse } from './utils'
-
-describe('RagbitsClient', () => {
-    let client: RagbitsClient
-
-    beforeEach(() => {
-        client = new RagbitsClient()
-    })
-
-    describe('Constructor', () => {
-        it('should create client with default base URL', () => {
-            const defaultClient = new RagbitsClient()
-            expect(defaultClient).toBeInstanceOf(RagbitsClient)
-        })
-
-        it('should create client with custom base URL', () => {
-            const customClient = new RagbitsClient({
-                baseUrl: 'https://api.example.com',
-            })
-            expect(customClient).toBeInstanceOf(RagbitsClient)
-        })
-
-        it('should remove trailing slash from base URL', () => {
-            const clientWithSlash = new RagbitsClient({
-                baseUrl: 'https://api.example.com/',
-            })
-            expect(clientWithSlash).toBeInstanceOf(RagbitsClient)
-        })
-
-        it('should throw error for invalid base URL', () => {
-            expect(() => {
-                new RagbitsClient({ baseUrl: 'invalid-url' })
-            }).toThrow(
-                'Invalid base URL: invalid-url. Please provide a valid URL.'
-            )
-        })
-    })
-
-    describe('getBaseUrl', () => {
-        it('should return the base URL', () => {
-            expect(client.getBaseUrl()).toBe('http://127.0.0.1:8000')
-        })
-    })
-
-    describe('makeRequest', () => {
-        it('should make successful GET request', async () => {
-            const response = await client.makeRequest('/api/config')
-
-            expect(response).toEqual(defaultConfigResponse)
-        })
-
-        it('should make successful POST request with body', async () => {
-            const requestBody: FeedbackRequest = {
-                message_id: 'msg-123',
-                feedback: FeedbackType.LIKE,
-                payload: { reason: 'Great response!' },
-            }
-
-            const response = await client.makeRequest('/api/feedback', {
-                method: 'POST',
-                body: requestBody,
-            })
-
-            expect(response).toEqual({
-                status: 'success',
-            })
-        })
-
-        it('should handle request with custom headers', async () => {
-            server.use(
-                http.get('http://127.0.0.1:8000/api/config', ({ request }) => {
-                    const customHeader = request.headers.get('X-Custom-Header')
-                    return HttpResponse.json({
-                        feedback: {
-                            like: { enabled: true, form: null },
-                            dislike: { enabled: false, form: null },
-                        },
-                        receivedHeader: customHeader,
-                    })
-                })
-            )
-
-            const response = await client.makeRequest('/api/config', {
-                headers: {
-                    'X-Custom-Header': 'test-value',
-                },
-            })
-
-            // Check that the header was received by accessing the custom property
-            const responseWithHeader = response as typeof response & {
-                receivedHeader: string
-            }
-            expect(responseWithHeader.receivedHeader).toBe('test-value')
-        })
-
-        it('should handle HTTP errors', async () => {
-            // Mock error response for testing
-            server.use(
-                http.get('http://127.0.0.1:8000/api/config', () => {
-                    return new HttpResponse(null, { status: 500 })
-                })
-            )
-
-            await expect(client.makeRequest('/api/config')).rejects.toThrow(
-                'HTTP error! status: 500'
-            )
-        })
-
-        it('should handle request cancellation', async () => {
-            const abortController = new AbortController()
-
-            // Mock a slow config endpoint
-            server.use(
-                http.get('http://127.0.0.1:8000/api/config', () => {
-                    return new Promise((resolve) => {
-                        setTimeout(() => {
-                            resolve(
-                                HttpResponse.json({
-                                    feedback: {
-                                        like: { enabled: true, form: null },
-                                        dislike: { enabled: false, form: null },
-                                    },
-                                })
-                            )
-                        }, 1000)
-                    })
-                })
-            )
-
-            const requestPromise = client.makeRequest('/api/config', {
-                signal: abortController.signal,
-            })
-
-            // Cancel the request immediately
-            abortController.abort()
-
-            await expect(requestPromise).rejects.toThrow()
-        })
-    })
-
-    describe('makeStreamRequest', () => {
-        it('should handle streaming response', async () => {
-            const messages: unknown[] = []
-            const errors: Error[] = []
-            let closed = false
-
-            const cancelFn = client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: (data) => {
-                        messages.push(data)
-                        return Promise.resolve()
-                    },
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                    onClose: () => {
-                        closed = true
-                    },
-                }
-            )
-
-            // Wait for stream to complete
-            await new Promise((resolve) => {
-                const checkComplete = () => {
-                    if (closed || errors.length > 0) {
-                        resolve(void 0)
-                    } else {
-                        setTimeout(checkComplete, 50)
-                    }
-                }
-                checkComplete()
-            })
-
-            expect(messages).toHaveLength(4)
-            expect(messages[0]).toEqual({
-                type: 'text',
-                content: 'Hello there!',
-            })
-            expect(messages[1]).toEqual({
-                type: 'text',
-                content: 'How can I help you?',
-            })
-            expect(messages[2]).toEqual({
-                type: 'message_id',
-                content: 'msg-123',
-            })
-            expect(messages[3]).toEqual({
-                type: 'conversation_id',
-                content: 'conv-456',
-            })
-            expect(errors).toHaveLength(0)
-            expect(closed).toBe(true)
-
-            // Cleanup
-            cancelFn()
-        })
-
-        it('should handle stream cancellation', async () => {
-            const messages: unknown[] = []
-            const errors: Error[] = []
-
-            const cancelFn = client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: (data) => {
-                        messages.push(data)
-                        return Promise.resolve()
-                    },
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Cancel immediately
-            cancelFn()
-
-            // Wait a bit to ensure cancellation takes effect
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(messages.length).toBeLessThan(4) // Should not receive all messages
-        })
-
-        it('should handle stream errors', async () => {
-            server.use(
-                http.post('http://127.0.0.1:8000/api/chat', () => {
-                    return new HttpResponse(null, { status: 500 })
-                })
-            )
-
-            const errors: Error[] = []
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: () => Promise.resolve(),
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toContain('HTTP error! status: 500')
-        })
-
-        it('should handle malformed JSON in stream', async () => {
-            server.use(
-                http.post('http://127.0.0.1:8000/api/chat', () => {
-                    const encoder = new TextEncoder()
-
-                    const stream = new ReadableStream({
-                        start(controller) {
-                            controller.enqueue(
-                                encoder.encode('data: invalid-json\n\n')
-                            )
-                            controller.close()
-                        },
-                    })
-
-                    return new HttpResponse(stream, {
-                        headers: {
-                            'Content-Type': 'text/event-stream',
-                        },
-                    })
-                })
-            )
-
-            const errors: Error[] = []
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: () => Promise.resolve(),
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toBe('Error processing server response')
-        })
-
-        it('should handle stream with AbortSignal', async () => {
-            const abortController = new AbortController()
-            const messages: unknown[] = []
-            const errors: Error[] = []
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: (data) => {
-                        messages.push(data)
-                        return Promise.resolve()
-                    },
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                },
-                abortController.signal
-            )
-
-            // Abort after receiving first message (shorter delay to be more reliable)
-            setTimeout(() => {
-                abortController.abort()
-            }, 5)
-
-            // Wait longer for abort to take effect
-            await new Promise((resolve) => setTimeout(resolve, 200))
-
-            // Should receive fewer than 4 messages due to abort
-            // Allow for some variation in timing but ensure it's not all 4
-            expect(messages.length).toBeLessThanOrEqual(3)
-        })
-
-        it('should handle null response body', async () => {
-            server.use(
-                http.post('http://127.0.0.1:8000/api/chat', () => {
-                    return new HttpResponse(null, {
-                        headers: {
-                            'Content-Type': 'text/event-stream',
-                        },
-                    })
-                })
-            )
-
-            const errors: Error[] = []
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: () => Promise.resolve(),
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toBe('Response body is null')
-        })
-
-        it('should handle reader stream errors', async () => {
-            server.use(
-                http.post('http://127.0.0.1:8000/api/chat', () => {
-                    const stream = new ReadableStream({
-                        start(controller) {
-                            // Simulate a stream error by enqueuing something and then erroring
-                            const encoder = new TextEncoder()
-                            controller.enqueue(
-                                encoder.encode(
-                                    'data: {"type": "text", "content": "Starting"}\n\n'
-                                )
-                            )
-                            // Force an error in the stream
-                            controller.error(new Error('Stream read error'))
-                        },
-                    })
-
-                    return new HttpResponse(stream, {
-                        headers: {
-                            'Content-Type': 'text/event-stream',
-                        },
-                    })
-                })
-            )
-
-            const errors: Error[] = []
-            const messages: unknown[] = []
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: (data) => {
-                        messages.push(data)
-                        return Promise.resolve()
-                    },
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 200))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toBe('Error reading stream')
-        })
-
-        it('should handle synchronous errors in makeStreamRequest', async () => {
-            const errors: Error[] = []
-
-            // Create a spy to force a synchronous error
-            const originalFetch = global.fetch
-            global.fetch = vi.fn().mockImplementation(() => {
-                throw new Error('Synchronous fetch error')
-            })
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: () => Promise.resolve(),
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toBe('Synchronous fetch error')
-
-            // Restore original fetch
-            global.fetch = originalFetch
-        })
-
-        it('should handle non-Error exceptions in stream processing', async () => {
-            const errors: Error[] = []
-
-            // Mock fetch to throw a non-Error object
-            const originalFetch = global.fetch
-            global.fetch = vi.fn().mockImplementation(() => {
-                throw 'String error' // Non-Error exception
-            })
-
-            client.makeStreamRequest(
-                '/api/chat',
-                { message: 'Start streaming', history: [] },
-                {
-                    onMessage: () => Promise.resolve(),
-                    onError: (error) => {
-                        errors.push(error)
-                        return Promise.resolve()
-                    },
-                }
-            )
-
-            // Wait for error to be captured
-            await new Promise((resolve) => setTimeout(resolve, 100))
-
-            expect(errors).toHaveLength(1)
-            expect(errors[0].message).toBe('Error connecting to server')
-
-            // Restore original fetch
-            global.fetch = originalFetch
-        })
-    })
-})