@taruvi/sdk 1.5.0 → 1.5.1

package/tests/unit/edge-cases/robustness.test.ts

@@ -1,258 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Database } from '../../../src/lib/database/DatabaseClient.js'
-import { Storage } from '../../../src/lib/storage/StorageClient.js'
-import { Client } from '../../../src/client.js'
-
-const mockHttpClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-    put: vi.fn(),
-    patch: vi.fn(),
-    delete: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-describe('Non-JSON / empty / malformed responses', () => {
-    beforeEach(() => vi.clearAllMocks())
-
-    it('handles empty response (204 no content)', async () => {
-        mockHttpClient.get.mockResolvedValue(undefined)
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toBeUndefined()
-    })
-
-    it('handles null response body', async () => {
-        mockHttpClient.get.mockResolvedValue(null)
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toBeNull()
-    })
-
-    it('handles empty string response', async () => {
-        mockHttpClient.get.mockResolvedValue('')
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toBe('')
-    })
-
-    it('handles plain text response', async () => {
-        mockHttpClient.get.mockResolvedValue('Internal Server Error')
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toBe('Internal Server Error')
-    })
-
-    it('handles empty array response', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toEqual([])
-    })
-
-    it('handles empty object response', async () => {
-        mockHttpClient.get.mockResolvedValue({})
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toEqual({})
-    })
-
-    it('propagates network error from httpClient', async () => {
-        mockHttpClient.get.mockRejectedValue(new Error('Network Error'))
-        await expect(new Database(mockClient).from('accounts').execute()).rejects.toThrow('Network Error')
-    })
-
-    it('propagates network error for Database graph', async () => {
-        mockHttpClient.get.mockRejectedValue(new Error('ECONNREFUSED'))
-        await expect(new Database(mockClient).from('employees').execute()).rejects.toThrow('ECONNREFUSED')
-    })
-
-    it('propagates network error for Storage', async () => {
-        mockHttpClient.get.mockRejectedValue(new Error('timeout'))
-        await expect(new Storage(mockClient).from('documents').execute()).rejects.toThrow('timeout')
-    })
-
-    it('handles response with unexpected shape', async () => {
-        mockHttpClient.get.mockResolvedValue(42)
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect(result).toBe(42)
-    })
-
-    it('handles response with extra unknown fields', async () => {
-        mockHttpClient.get.mockResolvedValue({ status: 'success', data: [], unknown_field: true, nested: { deep: 1 } })
-        const result = await new Database(mockClient).from('accounts').execute()
-        expect((result as any).unknown_field).toBe(true)
-    })
-})
-
-describe('Encoding edge cases', () => {
-    beforeEach(() => vi.clearAllMocks())
-
-    it('encodes special characters in table name', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('my-table_v2').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('/datatables/my-table_v2/'))
-    })
-
-    it('encodes special characters in record ID', async () => {
-        mockHttpClient.get.mockResolvedValue({})
-        await new Database(mockClient).from('accounts').get('abc-123-def').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('/abc-123-def/'))
-    })
-
-    it('encodes filter value with spaces', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('accounts').filter('name', 'eq', 'John Doe').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('name=John+Doe'))
-    })
-
-    it('encodes filter value with special characters', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('accounts').filter('email', 'eq', 'user@example.com').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('email=user%40example.com'))
-    })
-
-    it('encodes filter value with ampersand', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('accounts').filter('company', 'eq', 'A&B Corp').execute()
-        const url = mockHttpClient.get.mock.calls[0][0]
-        expect(url).toContain('company=A%26B')
-    })
-
-    it('handles unicode in filter values', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('accounts').filter('name', 'icontains', '日本語').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('name__icontains='))
-    })
-
-    it('encodes graph relationship types with special chars', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('employees').types(['reports_to']).execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('relationship_type=reports_to'))
-    })
-
-    it('handles storage bucket with hyphens', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Storage(mockClient).from('my-bucket-name').execute()
-        expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('/buckets/my-bucket-name/'), undefined)
-    })
-
-    it('handles empty string filter value', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        await new Database(mockClient).from('accounts').filter('status', 'eq', '').execute()
-        const url = mockHttpClient.get.mock.calls[0][0]
-        expect(url).toContain('status=')
-    })
-})
-
-describe('Builder immutability', () => {
-    beforeEach(() => vi.clearAllMocks())
-
-    it('Database: chaining does not mutate original instance', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Database(mockClient).from('accounts')
-        const filtered = base.filter('status', 'eq', 'active')
-        const sorted = base.sort('name', 'asc')
-
-        await filtered.execute()
-        const filteredUrl = mockHttpClient.get.mock.calls[0][0]
-
-        await sorted.execute()
-        const sortedUrl = mockHttpClient.get.mock.calls[1][0]
-
-        expect(filteredUrl).toContain('status=active')
-        expect(filteredUrl).not.toContain('ordering=name')
-
-        expect(sortedUrl).toContain('ordering=name')
-        expect(sortedUrl).not.toContain('status=active')
-    })
-
-    it('Database: page does not affect sibling chain', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Database(mockClient).from('accounts')
-        const page1 = base.page(1)
-        const page2 = base.page(2)
-
-        await page1.execute()
-        await page2.execute()
-
-        expect(mockHttpClient.get.mock.calls[0][0]).toContain('page=1')
-        expect(mockHttpClient.get.mock.calls[1][0]).toContain('page=2')
-        expect(mockHttpClient.get.mock.calls[0][0]).not.toContain('page=2')
-    })
-
-    it('Database graph: chaining does not mutate original instance', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Database(mockClient).from('employees')
-        const descendants = base.get('1').include('descendants').depth(3)
-        const ancestors = base.get('4').include('ancestors')
-
-        await descendants.execute()
-        const descUrl = mockHttpClient.get.mock.calls[0][0]
-
-        await ancestors.execute()
-        const ancUrl = mockHttpClient.get.mock.calls[1][0]
-
-        expect(descUrl).toContain('/1/')
-        expect(descUrl).toContain('include=descendants')
-        expect(descUrl).toContain('depth=3')
-
-        expect(ancUrl).toContain('/4/')
-        expect(ancUrl).toContain('include=ancestors')
-        expect(ancUrl).not.toContain('depth=3')
-    })
-
-    it('Database graph: format does not leak between chains', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Database(mockClient).from('employees')
-        const tree = base.format('tree')
-        const graph = base.format('graph')
-
-        await tree.execute()
-        await graph.execute()
-
-        expect(mockHttpClient.get.mock.calls[0][0]).toContain('format=tree')
-        expect(mockHttpClient.get.mock.calls[0][0]).not.toContain('format=graph')
-        expect(mockHttpClient.get.mock.calls[1][0]).toContain('format=graph')
-        expect(mockHttpClient.get.mock.calls[1][0]).not.toContain('format=tree')
-    })
-
-    it('Storage: filter does not mutate original instance', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Storage(mockClient).from('documents')
-        const pdfs = base.filter({ mimetype: 'application/pdf' })
-        const images = base.filter({ mimetype_category: 'image' })
-
-        await pdfs.execute()
-        await images.execute()
-
-        expect(mockHttpClient.get.mock.calls[0][0]).toContain('mimetype=application')
-        expect(mockHttpClient.get.mock.calls[0][0]).not.toContain('mimetype_category')
-        expect(mockHttpClient.get.mock.calls[1][0]).toContain('mimetype_category=image')
-    })
-
-    it('Database: get does not affect list chain', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        const base = new Database(mockClient).from('accounts')
-        const single = base.get('123')
-        const list = base.page(1)
-
-        await single.execute()
-        await list.execute()
-
-        expect(mockHttpClient.get.mock.calls[0][0]).toContain('/123/')
-        expect(mockHttpClient.get.mock.calls[1][0]).not.toContain('/123/')
-    })
-
-    it('Database: edge operations do not affect traversal chain', async () => {
-        mockHttpClient.get.mockResolvedValue([])
-        mockHttpClient.post.mockResolvedValue({})
-        const base = new Database(mockClient).from('employees')
-        const traversal = base.get('1').include('descendants')
-        const edge = base.edges().create([{ from_id: 1, to_id: 2, type: 'manager' }])
-
-        await traversal.execute()
-        await edge.execute()
-
-        expect(mockHttpClient.get.mock.calls[0][0]).toContain('/data/1/')
-        expect(mockHttpClient.post.mock.calls[0][0]).toContain('_edges/data/')
-    })
-})

package/tests/unit/errors/errors.test.ts

@@ -1,236 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-    TaruviError,
-    ValidationError,
-    AuthError,
-    ForbiddenError,
-    NotFoundError,
-    ConflictError,
-    TimeoutError,
-    NetworkError,
-    RateLimitError,
-    createErrorFromResponse,
-    ErrorCode
-} from '../../../src/lib-internal/errors/index.js'
-
-describe('Error classes', () => {
-    it('TaruviError has correct properties', () => {
-        const err = new TaruviError('Something broke', 500, ErrorCode.INTERNAL_ERROR, 'db down', { field: 'bad' }, { extra: 1 })
-        expect(err).toBeInstanceOf(Error)
-        expect(err.name).toBe('TaruviError')
-        expect(err.message).toBe('Something broke')
-        expect(err.statusCode).toBe(500)
-        expect(err.code).toBe('INTERNAL_ERROR')
-        expect(err.detail).toBe('db down')
-        expect(err.errors).toEqual({ field: 'bad' })
-        expect(err.data).toEqual({ extra: 1 })
-    })
-
-    it('ValidationError defaults', () => {
-        const err = new ValidationError()
-        expect(err.name).toBe('ValidationError')
-        expect(err.statusCode).toBe(400)
-        expect(err.code).toBe('VALIDATION_ERROR')
-        expect(err.message).toBe('Validation failed')
-    })
-
-    it('ValidationError with field errors', () => {
-        const err = new ValidationError('Bad input', 'check fields', { email: 'required' })
-        expect(err.errors).toEqual({ email: 'required' })
-        expect(err.detail).toBe('check fields')
-    })
-
-    it('AuthError defaults', () => {
-        const err = new AuthError()
-        expect(err.name).toBe('AuthError')
-        expect(err.statusCode).toBe(401)
-        expect(err.code).toBe('UNAUTHORIZED')
-    })
-
-    it('ForbiddenError defaults', () => {
-        const err = new ForbiddenError()
-        expect(err.name).toBe('ForbiddenError')
-        expect(err.statusCode).toBe(403)
-        expect(err.code).toBe('FORBIDDEN')
-    })
-
-    it('NotFoundError defaults', () => {
-        const err = new NotFoundError()
-        expect(err.name).toBe('NotFoundError')
-        expect(err.statusCode).toBe(404)
-        expect(err.code).toBe('NOT_FOUND')
-    })
-
-    it('ConflictError defaults', () => {
-        const err = new ConflictError()
-        expect(err.name).toBe('ConflictError')
-        expect(err.statusCode).toBe(409)
-        expect(err.code).toBe('CONFLICT')
-    })
-
-    it('TimeoutError defaults', () => {
-        const err = new TimeoutError()
-        expect(err.name).toBe('TimeoutError')
-        expect(err.statusCode).toBe(504)
-        expect(err.code).toBe('GATEWAY_TIMEOUT')
-    })
-
-    it('NetworkError defaults', () => {
-        const err = new NetworkError()
-        expect(err.name).toBe('NetworkError')
-        expect(err.statusCode).toBe(0)
-        expect(err.code).toBe('NETWORK_ERROR')
-    })
-
-    it('RateLimitError defaults', () => {
-        const err = new RateLimitError()
-        expect(err.name).toBe('RateLimitError')
-        expect(err.statusCode).toBe(429)
-        expect(err.code).toBe('RATE_LIMITED')
-        expect(err.retryAfter).toBeUndefined()
-    })
-
-    it('RateLimitError with retryAfter', () => {
-        const err = new RateLimitError('Too many requests', 60)
-        expect(err.message).toBe('Too many requests')
-        expect(err.retryAfter).toBe(60)
-        expect(err).toBeInstanceOf(TaruviError)
-    })
-
-    it('all errors are instanceof TaruviError', () => {
-        expect(new ValidationError()).toBeInstanceOf(TaruviError)
-        expect(new AuthError()).toBeInstanceOf(TaruviError)
-        expect(new ForbiddenError()).toBeInstanceOf(TaruviError)
-        expect(new NotFoundError()).toBeInstanceOf(TaruviError)
-        expect(new ConflictError()).toBeInstanceOf(TaruviError)
-        expect(new TimeoutError()).toBeInstanceOf(TaruviError)
-        expect(new NetworkError()).toBeInstanceOf(TaruviError)
-        expect(new RateLimitError()).toBeInstanceOf(TaruviError)
-    })
-
-    it('all errors are instanceof Error', () => {
-        expect(new TaruviError('x', 500)).toBeInstanceOf(Error)
-        expect(new ValidationError()).toBeInstanceOf(Error)
-        expect(new NetworkError()).toBeInstanceOf(Error)
-    })
-})
-
-describe('createErrorFromResponse', () => {
-    it('400 with VALIDATION_ERROR code returns ValidationError', () => {
-        const err = createErrorFromResponse(400, {
-            status: 'error',
-            code: 'VALIDATION_ERROR',
-            message: 'Email is required',
-            errors: { email: 'This field is required' }
-        })
-        expect(err).toBeInstanceOf(ValidationError)
-        expect(err.message).toBe('Email is required')
-        expect(err.errors).toEqual({ email: 'This field is required' })
-    })
-
-    it('400 with BAD_REQUEST code returns TaruviError', () => {
-        const err = createErrorFromResponse(400, {
-            status: 'error',
-            code: 'BAD_REQUEST',
-            message: 'Invalid input'
-        })
-        expect(err).toBeInstanceOf(TaruviError)
-        expect(err).not.toBeInstanceOf(ValidationError)
-        expect(err.code).toBe('BAD_REQUEST')
-    })
-
-    it('401 returns AuthError', () => {
-        const err = createErrorFromResponse(401, {
-            status: 'error',
-            code: 'UNAUTHORIZED',
-            message: 'Token expired'
-        })
-        expect(err).toBeInstanceOf(AuthError)
-        expect(err.message).toBe('Token expired')
-    })
-
-    it('403 returns ForbiddenError', () => {
-        const err = createErrorFromResponse(403, {
-            status: 'error',
-            code: 'FORBIDDEN',
-            message: 'Not allowed'
-        })
-        expect(err).toBeInstanceOf(ForbiddenError)
-    })
-
-    it('404 returns NotFoundError', () => {
-        const err = createErrorFromResponse(404, {
-            status: 'error',
-            code: 'NOT_FOUND',
-            message: 'User not found'
-        })
-        expect(err).toBeInstanceOf(NotFoundError)
-        expect(err.message).toBe('User not found')
-    })
-
-    it('409 returns ConflictError', () => {
-        const err = createErrorFromResponse(409, {
-            status: 'error',
-            code: 'CONFLICT',
-            message: 'Duplicate entry',
-            detail: 'Email already exists'
-        })
-        expect(err).toBeInstanceOf(ConflictError)
-        expect(err.detail).toBe('Email already exists')
-    })
-
-    it('504 returns TimeoutError', () => {
-        const err = createErrorFromResponse(504, {
-            status: 'error',
-            code: 'GATEWAY_TIMEOUT',
-            message: 'Query timeout'
-        })
-        expect(err).toBeInstanceOf(TimeoutError)
-    })
-
-    it('429 returns RateLimitError', () => {
-        const err = createErrorFromResponse(429, {
-            status: 'error',
-            code: 'RATE_LIMITED',
-            message: 'Too many requests'
-        })
-        expect(err).toBeInstanceOf(RateLimitError)
-        expect(err.message).toBe('Too many requests')
-    })
-
-    it('500 returns TaruviError', () => {
-        const err = createErrorFromResponse(500, {
-            status: 'error',
-            code: 'INTERNAL_ERROR',
-            message: 'Server error'
-        })
-        expect(err).toBeInstanceOf(TaruviError)
-        expect(err.statusCode).toBe(500)
-    })
-
-    it('handles missing body', () => {
-        const err = createErrorFromResponse(500, undefined)
-        expect(err).toBeInstanceOf(TaruviError)
-        expect(err.message).toBe('Request failed')
-    })
-
-    it('handles body with extra data field', () => {
-        const err = createErrorFromResponse(400, {
-            status: 'error',
-            code: 'BAD_REQUEST',
-            message: 'Bad',
-            data: { hint: 'check params' }
-        })
-        expect(err.data).toEqual({ hint: 'check params' })
-    })
-
-    it('handles unknown status code', () => {
-        const err = createErrorFromResponse(422, {
-            status: 'error',
-            code: 'VALIDATION_ERROR',
-            message: 'Unprocessable'
-        })
-        expect(err).toBeInstanceOf(TaruviError)
-        expect(err.statusCode).toBe(422)
-    })
-})

package/tests/unit/functions/FunctionsClient.test.ts

@@ -1,99 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Functions } from '../../../src/lib/functions/FunctionsClient.js'
-import { Client } from '../../../src/client.js'
-
-const mockHttpClient = {
-    post: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-describe('Functions', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('execute()', () => {
-        it('executes function with default options', async () => {
-            const response = { data: { result: 'success' } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const functions = new Functions(mockClient)
-            const result = await functions.execute('my-function')
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/functions/my-function/execute/',
-                { async: false, params: {} }
-            )
-            expect(result).toEqual(response)
-        })
-
-        it('executes function with params', async () => {
-            const response = { data: { result: 'success' } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const functions = new Functions(mockClient)
-            await functions.execute('my-function', {
-                params: { key1: 'value1', key2: 123 }
-            })
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/functions/my-function/execute/',
-                { async: false, params: { key1: 'value1', key2: 123 } }
-            )
-        })
-
-        it('executes function asynchronously', async () => {
-            const response = {
-                invocation: {
-                    invocation_id: 'inv-123',
-                    celery_task_id: 'task-456',
-                    status: 'pending'
-                }
-            }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const functions = new Functions(mockClient)
-            const result = await functions.execute('long-task', { async: true })
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/functions/long-task/execute/',
-                { async: true, params: {} }
-            )
-            expect(result).toEqual(response)
-        })
-
-        it('executes function with async and params', async () => {
-            mockHttpClient.post.mockResolvedValue({})
-
-            const functions = new Functions(mockClient)
-            await functions.execute('process-data', {
-                async: true,
-                params: { data: 'test-data' }
-            })
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/functions/process-data/execute/',
-                { async: true, params: { data: 'test-data' } }
-            )
-        })
-
-        it('supports typed response', async () => {
-            interface MyResponse {
-                total: number
-                items: string[]
-            }
-            const response = { data: { total: 5, items: ['a', 'b', 'c'] } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const functions = new Functions(mockClient)
-            const result = await functions.execute<MyResponse>('get-items')
-
-            expect(result.data?.total).toBe(5)
-            expect(result.data?.items).toEqual(['a', 'b', 'c'])
-        })
-    })
-})