@vafast/api-client 0.1.1 → 0.1.2

package/test/typed-client.test.ts

@@ -1,304 +0,0 @@
-import { describe, expect, it, beforeEach, mock } from 'bun:test'
-import { 
-  createTypedClient, 
-  createRouteBasedClient, 
-  createSimpleClient,
-  type TypedApiClient 
-} from '../src'
-
-// Mock VafastApiClient
-const MockVafastApiClient = mock(() => ({
-  get: mock(() => Promise.resolve({ data: 'test', error: null, status: 200, headers: new Headers(), response: new Response() })),
-  post: mock(() => Promise.resolve({ data: 'created', error: null, status: 201, headers: new Headers(), response: new Response() })),
-  put: mock(() => Promise.resolve({ data: 'updated', error: null, status: 200, headers: new Headers(), response: new Response() })),
-  delete: mock(() => Promise.resolve({ data: 'deleted', error: null, status: 200, headers: new Headers(), response: new Response() })),
-  patch: mock(() => Promise.resolve({ data: 'patched', error: null, status: 200, headers: new Headers(), response: new Response() })),
-  head: mock(() => Promise.resolve({ data: null, error: null, status: 200, headers: new Headers(), response: new Response() })),
-  options: mock(() => Promise.resolve({ data: null, error: null, status: 200, headers: new Headers(), response: new Response() }))
-}))
-
-// Mock server type
-interface MockServer {
-  routes: {
-    '/users': {
-      GET: { query: { page?: number; limit?: number } }
-      POST: { body: { name: string; email: string } }
-    }
-    '/users/:id': {
-      GET: { params: { id: string } }
-      PUT: { params: { id: string }; body: Partial<{ name: string; email: string }> }
-      DELETE: { params: { id: string } }
-    }
-    '/posts': {
-      GET: { query: { author?: string; category?: string } }
-      POST: { body: { title: string; content: string; authorId: string } }
-    }
-    '/posts/:id': {
-      GET: { params: { id: string } }
-      PUT: { params: { id: string }; body: Partial<{ title: string; content: string }> }
-      DELETE: { params: { id: string } }
-    }
-  }
-}
-
-describe('Typed Client', () => {
-  let mockServer: MockServer
-
-  beforeEach(() => {
-    mockServer = {
-      routes: {
-        '/users': {
-          GET: { query: { page: 1, limit: 10 } },
-          POST: { body: { name: 'John', email: 'john@example.com' } }
-        },
-        '/users/:id': {
-          GET: { params: { id: '123' } },
-          PUT: { params: { id: '123' }, body: { name: 'John Updated' } },
-          DELETE: { params: { id: '123' } }
-        },
-        '/posts': {
-          GET: { query: { author: 'user123', category: 'tech' } },
-          POST: { body: { title: 'Test Post', content: 'Content', authorId: 'user123' } }
-        },
-        '/posts/:id': {
-          GET: { params: { id: '456' } },
-          PUT: { params: { id: '456' }, body: { title: 'Updated Post' } },
-          DELETE: { params: { id: '456' } }
-        }
-      }
-    }
-  })
-
-  describe('createTypedClient', () => {
-    it('should create typed client from server', () => {
-      const typedClient = createTypedClient<MockServer>(mockServer as any, {
-        baseURL: 'https://api.example.com'
-      })
-      expect(typedClient).toBeDefined()
-    })
-
-    it('should support HTTP method calls', async () => {
-      const typedClient = createTypedClient<MockServer>(mockServer as any)
-      
-      // Test GET method
-      const getResponse = await typedClient.get('/users', { page: 1, limit: 10 })
-      expect(getResponse).toBeDefined()
-      // Note: The actual response will depend on the implementation
-      expect(getResponse).toHaveProperty('data')
-      
-      // Test POST method
-      const postResponse = await typedClient.post('/users', { name: 'Jane', email: 'jane@example.com' })
-      expect(postResponse).toBeDefined()
-      expect(postResponse).toHaveProperty('data')
-      
-      // Test PUT method
-      const putResponse = await typedClient.put('/users/123', { name: 'Jane Updated' })
-      expect(putResponse).toBeDefined()
-      expect(putResponse).toHaveProperty('data')
-      
-      // Test DELETE method
-      const deleteResponse = await typedClient.delete('/users/123')
-      expect(deleteResponse).toBeDefined()
-      expect(deleteResponse).toHaveProperty('data')
-      
-      // Test PATCH method
-      const patchResponse = await typedClient.patch('/users/123', { name: 'Jane Patched' })
-      expect(patchResponse).toBeDefined()
-      expect(patchResponse).toHaveProperty('data')
-      
-      // Test HEAD method
-      const headResponse = await typedClient.head('/users')
-      expect(headResponse).toBeDefined()
-      expect(headResponse).toHaveProperty('data')
-      
-      // Test OPTIONS method
-      const optionsResponse = await typedClient.options('/users')
-      expect(optionsResponse).toBeDefined()
-      expect(optionsResponse).toHaveProperty('data')
-    })
-
-    it('should support path-based calls', async () => {
-      const typedClient = createTypedClient<MockServer>(mockServer as any)
-      
-      // Test path segments
-      const usersClient = (typedClient as any).users
-      expect(usersClient).toBeDefined()
-      
-      // Test nested path segments
-      const postsClient = (typedClient as any).posts
-      expect(postsClient).toBeDefined()
-    })
-
-    it('should handle dynamic path parameters', async () => {
-      const typedClient = createTypedClient<MockServer>(mockServer as any)
-      
-      // Test dynamic path with parameters
-      const userClient = (typedClient as any).users
-      if (typeof userClient === 'function') {
-        const response = await userClient({ id: '123' })
-        expect(response).toBeDefined()
-      }
-    })
-  })
-
-  describe('createRouteBasedClient', () => {
-    it('should create route-based client', () => {
-      const routeClient = createRouteBasedClient<MockServer>(mockServer as any, {
-        baseURL: 'https://api.example.com'
-      })
-      expect(routeClient).toBeDefined()
-    })
-
-    it('should support dynamic path handling', async () => {
-      const routeClient = createRouteBasedClient<MockServer>(mockServer as any)
-      
-      // Test dynamic path creation
-      const dynamicPath = (routeClient as any).users
-      expect(dynamicPath).toBeDefined()
-      
-      if (typeof dynamicPath === 'function') {
-        const response = await dynamicPath({ id: '123' })
-        expect(response).toBeDefined()
-      }
-    })
-  })
-
-  describe('createSimpleClient', () => {
-    it('should create simple client', () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any, {
-        baseURL: 'https://api.example.com'
-      })
-      expect(simpleClient).toBeDefined()
-    })
-
-    it('should have all HTTP methods', () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any)
-      
-      expect(typeof simpleClient.get).toBe('function')
-      expect(typeof simpleClient.post).toBe('function')
-      expect(typeof simpleClient.put).toBe('function')
-      expect(typeof simpleClient.delete).toBe('function')
-      expect(typeof simpleClient.patch).toBe('function')
-      expect(typeof simpleClient.head).toBe('function')
-      expect(typeof simpleClient.options).toBe('function')
-    })
-
-    it('should make HTTP requests correctly', async () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any)
-      
-      // Test GET request
-      const getResponse = await simpleClient.get('/users', { page: 1, limit: 10 })
-      expect(getResponse).toBeDefined()
-      expect(getResponse).toHaveProperty('data')
-      
-      // Test POST request
-      const postResponse = await simpleClient.post('/users', { name: 'John', email: 'john@example.com' })
-      expect(postResponse).toBeDefined()
-      expect(postResponse).toHaveProperty('data')
-      
-      // Test PUT request
-      const putResponse = await simpleClient.put('/users/123', { name: 'John Updated' })
-      expect(putResponse).toBeDefined()
-      expect(putResponse).toHaveProperty('data')
-      
-      // Test DELETE request
-      const deleteResponse = await simpleClient.delete('/users/123')
-      expect(deleteResponse).toBeDefined()
-      expect(deleteResponse).toHaveProperty('data')
-    })
-
-    it('should handle query parameters', async () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any)
-      
-      const response = await simpleClient.get('/users', { page: 2, limit: 20, search: 'john' })
-      expect(response).toBeDefined()
-    })
-
-    it('should handle request body', async () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any)
-      
-      const response = await simpleClient.post('/users', { 
-        name: 'Jane Doe', 
-        email: 'jane@example.com',
-        age: 25
-      })
-      expect(response).toBeDefined()
-    })
-
-    it('should handle custom request config', async () => {
-      const simpleClient = createSimpleClient<MockServer>(mockServer as any)
-      
-      const response = await simpleClient.get('/users', { page: 1, limit: 10 }, {
-        headers: { 'X-Custom-Header': 'test' },
-        timeout: 10000
-      })
-      expect(response).toBeDefined()
-    })
-  })
-
-  describe('Type Safety', () => {
-    it('should maintain type safety for server types', () => {
-      // This test ensures TypeScript compilation works correctly
-      const typedClient: TypedApiClient<MockServer> = createTypedClient<MockServer>(mockServer as any)
-      expect(typedClient).toBeDefined()
-    })
-
-    it('should support generic type constraints', () => {
-      // Test with different server types
-      interface SimpleServer {
-        routes: {
-          '/health': {
-            GET: {}
-          }
-        }
-      }
-      
-      const simpleServer: SimpleServer = {
-        routes: {
-          '/health': { GET: {} }
-        }
-      }
-      
-      const client = createTypedClient<SimpleServer>(simpleServer as any)
-      expect(client).toBeDefined()
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should handle client creation errors gracefully', () => {
-      // Test with invalid server
-      const invalidClient = createTypedClient(null as any)
-      expect(invalidClient).toBeDefined()
-    })
-
-    it('should handle missing routes gracefully', () => {
-      const emptyServer = { routes: {} }
-      const client = createTypedClient(emptyServer as any)
-      expect(client).toBeDefined()
-    })
-  })
-
-  describe('Integration', () => {
-    it('should work with different server configurations', () => {
-      const configs = [
-        { baseURL: 'https://api1.example.com' },
-        { baseURL: 'https://api2.example.com', timeout: 5000 },
-        { baseURL: 'https://api3.example.com', retries: 3 }
-      ]
-      
-      configs.forEach(config => {
-        const client = createSimpleClient<MockServer>(mockServer as any, config)
-        expect(client).toBeDefined()
-      })
-    })
-
-    it('should support method chaining patterns', () => {
-      const client = createSimpleClient<MockServer>(mockServer as any)
-      
-      // Test that methods return the client for chaining
-      expect(client).toBeDefined()
-      expect(typeof client.get).toBe('function')
-      expect(typeof client.post).toBe('function')
-    })
-  })
-})

package/test/utils.test.ts

@@ -1,363 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  buildQueryString,
-  replacePathParams,
-  isFile,
-  isFileUpload,
-  hasFiles,
-  createFormData,
-  deepMerge,
-  delay,
-  exponentialBackoff,
-  validateStatus,
-  parseResponse,
-  createError,
-  cloneRequest,
-  isRetryableError
-} from '../src'
-
-describe('Utils', () => {
-  describe('buildQueryString', () => {
-    it('should build query string from object', () => {
-      const params = { page: 1, limit: 10, search: 'john' }
-      const result = buildQueryString(params)
-      expect(result).toBe('?page=1&limit=10&search=john')
-    })
-
-    it('should handle empty object', () => {
-      const result = buildQueryString({})
-      expect(result).toBe('')
-    })
-
-    it('should handle undefined and null values', () => {
-      const params = { page: 1, limit: undefined, search: null, active: true }
-      const result = buildQueryString(params)
-      expect(result).toBe('?page=1&active=true')
-    })
-
-    it('should handle array values', () => {
-      const params = { tags: ['js', 'ts'], page: 1 }
-      const result = buildQueryString(params)
-      expect(result).toBe('?tags=js&tags=ts&page=1')
-    })
-
-    it('should handle boolean values', () => {
-      const params = { active: true, verified: false }
-      const result = buildQueryString(params)
-      expect(result).toBe('?active=true&verified=false')
-    })
-  })
-
-  describe('replacePathParams', () => {
-    it('should replace path parameters', () => {
-      const path = '/users/:id/posts/:postId'
-      const params = { id: '123', postId: '456' }
-      const result = replacePathParams(path, params)
-      expect(result).toBe('/users/123/posts/456')
-    })
-
-    it('should handle path with no parameters', () => {
-      const path = '/users'
-      const params = {}
-      const result = replacePathParams(path, params)
-      expect(result).toBe('/users')
-    })
-
-    it('should handle numeric parameters', () => {
-      const path = '/users/:id'
-      const params = { id: 123 }
-      const result = replacePathParams(path, params)
-      expect(result).toBe('/users/123')
-    })
-
-    it('should handle missing parameters', () => {
-      const path = '/users/:id/posts/:postId'
-      const params = { id: '123' }
-      const result = replacePathParams(path, params)
-      expect(result).toBe('/users/123/posts/:postId')
-    })
-  })
-
-  describe('isFile', () => {
-    it('should identify File objects', () => {
-      const file = new File(['content'], 'test.txt')
-      expect(isFile(file)).toBe(true)
-    })
-
-    it('should identify Blob objects', () => {
-      const blob = new Blob(['content'])
-      expect(isFile(blob)).toBe(true)
-    })
-
-    it('should reject non-file objects', () => {
-      expect(isFile('string')).toBe(false)
-      expect(isFile(123)).toBe(false)
-      expect(isFile({})).toBe(false)
-      expect(isFile(null)).toBe(false)
-      expect(isFile(undefined)).toBe(false)
-    })
-  })
-
-  describe('isFileUpload', () => {
-    it('should identify FileUpload objects', () => {
-      const fileUpload = {
-        file: new File(['content'], 'test.txt'),
-        filename: 'custom.txt',
-        contentType: 'text/plain'
-      }
-      expect(isFileUpload(fileUpload)).toBe(true)
-    })
-
-    it('should reject non-FileUpload objects', () => {
-      expect(isFileUpload({})).toBe(false)
-      expect(isFileUpload({ file: 'string' })).toBe(false)
-      expect(isFileUpload(null)).toBe(false)
-      expect(isFileUpload(undefined)).toBe(false)
-    })
-  })
-
-  describe('hasFiles', () => {
-    it('should detect files in object', () => {
-      const obj = {
-        name: 'test',
-        file: new File(['content'], 'test.txt'),
-        metadata: { size: 100 }
-      }
-      expect(hasFiles(obj)).toBe(true)
-    })
-
-    it('should detect files in nested objects', () => {
-      const obj = {
-        user: {
-          avatar: new File(['content'], 'avatar.jpg'),
-          profile: { name: 'John' }
-        }
-      }
-      expect(hasFiles(obj)).toBe(true)
-    })
-
-    it('should detect files in arrays', () => {
-      const obj = {
-        files: [new File(['content'], 'file1.txt'), new File(['content'], 'file2.txt')]
-      }
-      expect(hasFiles(obj)).toBe(true)
-    })
-
-    it('should not detect files in object without files', () => {
-      const obj = {
-        name: 'test',
-        age: 25,
-        active: true
-      }
-      expect(hasFiles(obj)).toBe(false)
-    })
-  })
-
-  describe('createFormData', () => {
-    it('should create FormData from object', () => {
-      const data = {
-        name: 'John',
-        age: 25,
-        file: new File(['content'], 'test.txt')
-      }
-      const formData = createFormData(data)
-      expect(formData).toBeInstanceOf(globalThis.FormData)
-    })
-
-    it('should handle FileUpload objects', () => {
-      const data = {
-        name: 'John',
-        avatar: {
-          file: new File(['content'], 'avatar.jpg'),
-          filename: 'custom.jpg'
-        }
-      }
-      const formData = createFormData(data)
-      expect(formData).toBeInstanceOf(globalThis.FormData)
-    })
-
-    it('should handle array values', () => {
-      const data = {
-        tags: ['js', 'ts'],
-        files: [new File(['content'], 'file1.txt'), new File(['content'], 'file2.txt')]
-      }
-      const formData = createFormData(data)
-      expect(formData).toBeInstanceOf(globalThis.FormData)
-    })
-
-    it('should skip undefined and null values', () => {
-      const data = {
-        name: 'John',
-        age: undefined,
-        email: null,
-        active: true
-      }
-      const formData = createFormData(data)
-      expect(formData).toBeInstanceOf(globalThis.FormData)
-    })
-  })
-
-  describe('deepMerge', () => {
-    it('should merge objects deeply', () => {
-      const target = { a: 1, b: { c: 2, d: 3 } }
-      const source = { b: { d: 4, e: 5 }, f: 6 }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: 1, b: { c: 2, d: 4, e: 5 }, f: 6 })
-    })
-
-    it('should not modify original objects', () => {
-      const target = { a: 1, b: { c: 2 } }
-      const source = { b: { d: 3 } }
-      const result = deepMerge(target, source)
-      expect(target).toEqual({ a: 1, b: { c: 2 } })
-      expect(result).toEqual({ a: 1, b: { c: 2, d: 3 } })
-    })
-
-    it('should handle empty objects', () => {
-      const target = {}
-      const source = {}
-      const result = deepMerge(target, source)
-      expect(result).toEqual({})
-    })
-
-    it('should handle null and undefined', () => {
-      const target = { a: 1, b: { c: 2 } }
-      const source = { b: null, c: undefined }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: 1, b: null, c: undefined })
-    })
-  })
-
-  describe('delay', () => {
-    it('should delay execution', async () => {
-      const start = Date.now()
-      await delay(100)
-      const end = Date.now()
-      expect(end - start).toBeGreaterThanOrEqual(90)
-    })
-  })
-
-  describe('exponentialBackoff', () => {
-    it('should calculate exponential backoff', () => {
-      const result1 = exponentialBackoff(1, 1000, 10000)
-      const result2 = exponentialBackoff(2, 1000, 10000)
-      const result3 = exponentialBackoff(3, 1000, 10000)
-
-      expect(result1).toBeGreaterThanOrEqual(1000)
-      expect(result2).toBeGreaterThanOrEqual(2000)
-      expect(result3).toBeGreaterThanOrEqual(4000)
-    })
-
-    it('should respect max delay', () => {
-      const result = exponentialBackoff(10, 1000, 5000)
-      // Allow some tolerance for random jitter
-      expect(result).toBeLessThanOrEqual(6000)
-    })
-  })
-
-  describe('validateStatus', () => {
-    it('should validate successful status codes', () => {
-      expect(validateStatus(200)).toBe(true)
-      expect(validateStatus(201)).toBe(true)
-      expect(validateStatus(299)).toBe(true)
-    })
-
-    it('should reject error status codes', () => {
-      expect(validateStatus(400)).toBe(false)
-      expect(validateStatus(500)).toBe(false)
-      expect(validateStatus(404)).toBe(false)
-    })
-  })
-
-  describe('parseResponse', () => {
-    it('should parse JSON responses', async () => {
-      const response = new Response(JSON.stringify({ data: 'test' }), {
-        headers: { 'Content-Type': 'application/json' }
-      })
-      const result = await parseResponse(response)
-      expect(result).toEqual({ data: 'test' })
-    })
-
-    it('should parse text responses', async () => {
-      const response = new Response('Hello World', {
-        headers: { 'Content-Type': 'text/plain' }
-      })
-      const result = await parseResponse(response)
-      expect(result).toBe('Hello World')
-    })
-
-    it('should parse array buffer responses', async () => {
-      const buffer = new ArrayBuffer(8)
-      const response = new Response(buffer, {
-        headers: { 'Content-Type': 'application/octet-stream' }
-      })
-      const result = await parseResponse(response)
-      expect(result).toBeInstanceOf(ArrayBuffer)
-    })
-
-    it('should handle responses without content-type', async () => {
-      const response = new Response('Hello World')
-      const result = await parseResponse(response)
-      expect(result).toBe('Hello World')
-    })
-  })
-
-  describe('createError', () => {
-    it('should create error with status and data', () => {
-      const error = createError(404, 'Not Found', { resource: 'user' })
-      expect(error).toBeInstanceOf(Error)
-      expect((error as any).status).toBe(404)
-      expect((error as any).data).toEqual({ resource: 'user' })
-      expect((error as any).name).toBe('ApiError')
-    })
-
-    it('should create error without data', () => {
-      const error = createError(500, 'Internal Server Error')
-      expect(error).toBeInstanceOf(Error)
-      expect((error as any).status).toBe(500)
-      expect((error as any).data).toBeUndefined()
-    })
-  })
-
-  describe('cloneRequest', () => {
-    it('should clone request object', () => {
-      const original = new Request('https://example.com', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ test: true })
-      })
-      const cloned = cloneRequest(original)
-      expect(cloned).toBeInstanceOf(Request)
-      expect(cloned.url).toBe(original.url)
-      expect(cloned.method).toBe(original.method)
-    })
-  })
-
-  describe('isRetryableError', () => {
-    it('should identify retryable HTTP status codes', () => {
-      expect(isRetryableError(new Error(), 408)).toBe(true)
-      expect(isRetryableError(new Error(), 429)).toBe(true)
-      expect(isRetryableError(new Error(), 500)).toBe(true)
-      expect(isRetryableError(new Error(), 502)).toBe(true)
-      expect(isRetryableError(new Error(), 503)).toBe(true)
-      expect(isRetryableError(new Error(), 504)).toBe(true)
-    })
-
-    it('should reject non-retryable status codes', () => {
-      expect(isRetryableError(new Error(), 400)).toBe(false)
-      expect(isRetryableError(new Error(), 401)).toBe(false)
-      expect(isRetryableError(new Error(), 403)).toBe(false)
-      expect(isRetryableError(new Error(), 404)).toBe(false)
-    })
-
-    it('should identify network errors as retryable', () => {
-      const networkError = new Error('fetch failed')
-      expect(isRetryableError(networkError)).toBe(true)
-    })
-
-    it('should reject other errors as non-retryable', () => {
-      const otherError = new Error('Validation failed')
-      expect(isRetryableError(otherError)).toBe(false)
-    })
-  })
-})