@ragbits/api-client 0.0.1

package/src/test/RagbitsClient.test.ts

@@ -0,0 +1,484 @@
+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
+        })
+    })
+})

package/src/test/mocks/handlers.ts

@@ -0,0 +1,98 @@
+import { http, HttpResponse } from 'msw'
+import { defaultConfigResponse } from '../utils'
+
+export const handlers = [
+    // Config endpoint with conditional error handling
+    http.get('http://127.0.0.1:8000/api/config', ({ request }) => {
+        const url = new URL(request.url)
+        if (url.searchParams.get('error') === 'true') {
+            return new HttpResponse(null, { status: 500 })
+        }
+
+        return HttpResponse.json(defaultConfigResponse)
+    }),
+
+    // Feedback endpoint
+    http.post('http://127.0.0.1:8000/api/feedback', async ({ request }) => {
+        const _body = await request.json()
+        return HttpResponse.json({
+            status: 'success',
+        })
+    }),
+
+    // Chat streaming endpoint
+    http.post('http://127.0.0.1:8000/api/chat', ({ request }) => {
+        const url = new URL(request.url)
+
+        // Handle different test scenarios
+        if (url.searchParams.get('error') === 'true') {
+            return new HttpResponse(null, { status: 500 })
+        }
+
+        if (url.searchParams.get('malformed') === 'true') {
+            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' },
+            })
+        }
+
+        if (url.searchParams.get('empty') === 'true') {
+            return new HttpResponse(null, {
+                headers: { 'Content-Type': 'text/event-stream' },
+            })
+        }
+
+        if (url.searchParams.get('slow') === 'true') {
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve(
+                        HttpResponse.json({
+                            type: 'text',
+                            content: 'Slow response',
+                        })
+                    )
+                }, 1000)
+            })
+        }
+
+        const encoder = new TextEncoder()
+
+        const stream = new ReadableStream({
+            start(controller) {
+                const messages = [
+                    { type: 'text', content: 'Hello there!' },
+                    { type: 'text', content: 'How can I help you?' },
+                    { type: 'message_id', content: 'msg-123' },
+                    { type: 'conversation_id', content: 'conv-456' },
+                ]
+
+                messages.forEach((message, index) => {
+                    setTimeout(() => {
+                        controller.enqueue(
+                            encoder.encode(
+                                `data: ${JSON.stringify(message)}\n\n`
+                            )
+                        )
+                        if (index === messages.length - 1) {
+                            controller.close()
+                        }
+                    }, index * 10)
+                })
+            },
+        })
+
+        return new HttpResponse(stream, {
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            },
+        })
+    }),
+]

package/src/test/setup.ts

@@ -0,0 +1,23 @@
+import '@testing-library/jest-dom'
+import { beforeAll, afterEach, afterAll } from 'vitest'
+import { setupServer } from 'msw/node'
+import { handlers } from './mocks/handlers'
+
+// Setup MSW server
+export const server = setupServer(...handlers)
+
+beforeAll(() => {
+    // Start the interception on the client side before all tests run.
+    server.listen({ onUnhandledRequest: 'error' })
+})
+
+afterEach(() => {
+    // Reset any request handlers that we may add during the tests,
+    // so they don't affect other tests.
+    server.resetHandlers()
+})
+
+afterAll(() => {
+    // Clean up after the tests are finished.
+    server.close()
+})

package/src/test/types.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest'
+import * as RagbitsApiClient from '../index'
+
+describe('Package Exports', () => {
+    it('should export RagbitsClient class', () => {
+        expect(RagbitsApiClient.RagbitsClient).toBeDefined()
+        expect(typeof RagbitsApiClient.RagbitsClient).toBe('function')
+    })
+
+    it('should export MessageRole enum with correct values', () => {
+        expect(RagbitsApiClient.MessageRole).toBeDefined()
+        expect(RagbitsApiClient.MessageRole.USER).toBe('user')
+        expect(RagbitsApiClient.MessageRole.ASSISTANT).toBe('assistant')
+        expect(RagbitsApiClient.MessageRole.SYSTEM).toBe('system')
+    })
+
+    it('should export ChatResponseType enum with correct values', () => {
+        expect(RagbitsApiClient.ChatResponseType).toBeDefined()
+        expect(RagbitsApiClient.ChatResponseType.TEXT).toBe('text')
+        expect(RagbitsApiClient.ChatResponseType.REFERENCE).toBe('reference')
+        expect(RagbitsApiClient.ChatResponseType.STATE_UPDATE).toBe(
+            'state_update'
+        )
+        expect(RagbitsApiClient.ChatResponseType.MESSAGE_ID).toBe('message_id')
+        expect(RagbitsApiClient.ChatResponseType.CONVERSATION_ID).toBe(
+            'conversation_id'
+        )
+    })
+
+    it('should export FeedbackType enum with correct values', () => {
+        expect(RagbitsApiClient.FeedbackType).toBeDefined()
+        expect(RagbitsApiClient.FeedbackType.LIKE).toBe('like')
+        expect(RagbitsApiClient.FeedbackType.DISLIKE).toBe('dislike')
+    })
+})

package/src/test/utils.ts

@@ -0,0 +1,28 @@
+import type { ConfigResponse } from '../types'
+
+// Shared config response for tests
+export const defaultConfigResponse: ConfigResponse = {
+    feedback: {
+        like: {
+            enabled: true,
+            form: {
+                title: 'Like Form',
+                type: 'object',
+                required: ['like_reason'],
+                properties: {
+                    like_reason: {
+                        title: 'Like Reason',
+                        description: 'Why do you like this?',
+                        type: 'string',
+                        minLength: 1,
+                    },
+                },
+            },
+        },
+        dislike: {
+            enabled: true,
+            form: null,
+        },
+    },
+    customization: null,
+}