@vafast/api-client 0.1.1 → 0.1.2

package/src/index.ts

@@ -1,73 +1,42 @@
-// 核心 API 客户端
-export { VafastApiClient } from './core/api-client'
-export { 
-  createTypedClient, 
-  createRouteBasedClient, 
-  createSimpleClient,
-  type TypedApiClient 
-} from './core/typed-client'
+/**
+ * Vafast API Client
+ * 
+ * 类型安全的 Eden 风格 API 客户端
+ * 
+ * @example
+ * ```typescript
+ * import { eden, InferEden } from '@vafast/api-client'
+ * import { defineRoutes, route, createHandler, Type } from 'vafast'
+ * 
+ * // 定义路由（无需 as const）
+ * const routes = defineRoutes([
+ *   route('GET', '/users', createHandler(...)),
+ *   route('POST', '/users', createHandler(...))
+ * ])
+ * 
+ * // 自动推断类型
+ * type Api = InferEden<typeof routes>
+ * const api = eden<Api>('http://localhost:3000')
+ * 
+ * // 类型安全的调用
+ * const { data } = await api.users.get({ page: 1 })
+ * ```
+ */
 
-// WebSocket 客户端
-export { 
-  VafastWebSocketClient, 
-  createWebSocketClient, 
-  createTypedWebSocketClient 
-} from './websocket/websocket-client'
+// Eden 客户端（核心）
+export {
+  eden,
+  type EdenConfig,
+  type EdenClient,
+  type InferEden,
+  type SSEEvent,
+  type SSESubscribeOptions,
+  type SSESubscription,
+} from './core/eden'
 
 // 类型定义
 export type {
-  // 基础类型
   HTTPMethod,
   RequestConfig,
   ApiResponse,
-  QueryParams,
-  PathParams,
-  RequestBody,
-  ApiClientConfig,
-  
-  // 类型推断
-  InferRouteHandler,
-  InferServer,
-  RoutePath,
-  RouteMethod,
-  RouteHandlerType,
-  
-  // WebSocket 类型
-  WebSocketEvent,
-  WebSocketClient,
-  
-  // 文件类型
-  FileUpload,
-  ApiFormData,
-  
-  // 中间件和拦截器
-  ApiMiddleware,
-  Interceptor,
-  
-  // 配置类型
-  CacheConfig,
-  RetryConfig,
-  LogConfig
 } from './types'
-
-// 工具函数
-export {
-  buildQueryString,
-  replacePathParams,
-  isFile,
-  isFileUpload,
-  hasFiles,
-  createFormData,
-  deepMerge,
-  delay,
-  exponentialBackoff,
-  validateStatus,
-  parseResponse,
-  createError,
-  cloneRequest,
-  isRetryableError
-} from './utils'
-
-// 默认导出
-import { VafastApiClient } from './core/api-client'
-export default VafastApiClient

package/src/types/index.ts

@@ -1,133 +1,34 @@
-// 基础类型定义
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS'
-
-// 简化的 vafast 类型定义
-export interface Server {
-  routes: Record<string, Route>
-}
-
-export interface Route {
-  method: string
-  path: string
-  handler: RouteHandler
-}
+/**
+ * 类型定义
+ */
 
-export interface RouteHandler {
-  (req: unknown, res: unknown): unknown
-}
+/** HTTP 方法 */
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS'
 
 /**
  * 请求配置
  */
 export interface RequestConfig {
+  /** 请求头 */
   headers?: Record<string, string>
+  /** 超时时间（毫秒） */
   timeout?: number
-  retries?: number
-  retryDelay?: number
-  body?: RequestBody
+  /** 取消信号 */
+  signal?: AbortSignal
 }
 
-// 响应类型
+/**
+ * API 响应
+ */
 export interface ApiResponse<T = unknown> {
+  /** 响应数据 */
   data: T | null
+  /** 错误信息 */
   error: Error | null
+  /** HTTP 状态码 */
   status: number
+  /** 响应头 */
   headers: Headers
+  /** 原始响应对象 */
   response: Response
 }
-
-// 查询参数类型
-export type QueryParams = Record<string, string | number | boolean | undefined | null>
-
-// 路径参数类型
-export type PathParams = Record<string, string | number>
-
-// 请求体类型
-export type RequestBody = unknown
-
-// API 客户端配置
-export interface ApiClientConfig extends RequestConfig {
-  baseURL?: string
-  defaultHeaders?: Record<string, string>
-  timeout?: number
-  retries?: number
-  retryDelay?: number
-  validateStatus?: (status: number) => boolean
-}
-
-// 类型推断类型
-export type InferRouteHandler<T> = T extends RouteHandler ? T : never
-export type InferServer<T> = T extends Server ? T : never
-export type RoutePath<T> = T extends Route ? T['path'] : never
-export type RouteMethod<T> = T extends Route ? T['method'] : never
-export type RouteHandlerType<T> = T extends Route ? T['handler'] : never
-
-// WebSocket 事件类型
-export interface WebSocketEvent<T = unknown> {
-  type: string
-  data: T
-  timestamp: number
-}
-
-// WebSocket 客户端类型
-export interface WebSocketClient {
-  connect(): Promise<void>
-  disconnect(): void
-  send(data: unknown): void
-  on(event: string, callback: (data: unknown) => void): void
-  off(event: string, callback: (data: unknown) => void): void
-  isConnected(): boolean
-}
-
-// 文件上传类型
-export interface FileUpload {
-  file: File | Blob
-  filename?: string
-  contentType?: string
-}
-
-// 表单数据类型（重命名避免与全局 FormData 冲突）
-export interface ApiFormData {
-  [key: string]: string | number | boolean | File | Blob | FileUpload | ApiFormData | (string | number | boolean | File | Blob | FileUpload | ApiFormData)[] | unknown
-}
-
-// 中间件类型
-export interface ApiMiddleware {
-  name: string
-  onRequest?: (request: Request, config: RequestConfig) => Request | Promise<Request>
-  onResponse?: (response: Response, config: RequestConfig) => Response | Promise<Response>
-  onError?: (error: Error, config: RequestConfig) => Error | Promise<Error>
-}
-
-// 缓存配置类型
-export interface CacheConfig {
-  enabled: boolean
-  ttl: number
-  maxSize: number
-  strategy: 'memory' | 'localStorage' | 'sessionStorage'
-}
-
-// 重试配置类型
-export interface RetryConfig {
-  enabled: boolean
-  maxRetries: number
-  retryDelay: number
-  backoffMultiplier: number
-  retryableStatuses: number[]
-}
-
-// 拦截器类型
-export interface Interceptor {
-  request?: (config: RequestConfig) => RequestConfig | Promise<RequestConfig>
-  response?: (response: Response) => Response | Promise<Response>
-  error?: (error: Error) => Error | Promise<Error>
-}
-
-// 日志配置类型
-export interface LogConfig {
-  enabled: boolean
-  level: 'debug' | 'info' | 'warn' | 'error'
-  format: 'json' | 'text'
-  includeHeaders: boolean
-  includeBody: boolean
-}

package/test/eden.test.ts

@@ -0,0 +1,425 @@
+import { describe, expect, it, beforeEach, vi, afterEach } from 'vitest'
+import { eden } from '../src'
+
+// Mock fetch
+const mockFetch = vi.fn()
+globalThis.fetch = mockFetch
+
+describe('Eden Client', () => {
+  beforeEach(() => {
+    mockFetch.mockReset()
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify({ id: '1', name: 'John' }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+      })
+    )
+  })
+
+  // ============= 类型定义 =============
+  
+  interface TestContract {
+    users: {
+      get: { query: { page?: number }; return: { id: string }[] }
+      post: { body: { name: string }; return: { id: string } }
+      ':id': {
+        get: { return: { id: string; name: string } }
+        put: { body: { name: string }; return: { id: string; name: string } }
+        delete: { return: { success: boolean } }
+      }
+    }
+    chat: {
+      stream: {
+        get: { query: { prompt: string }; return: unknown; sse: true }
+      }
+    }
+  }
+
+  // ============= 基础请求测试 =============
+
+  describe('基础请求', () => {
+    it('应该发送 GET 请求', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      const result = await api.users.get({ page: 1 })
+      
+      expect(mockFetch).toHaveBeenCalled()
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toContain('/users')
+      expect(req.url).toContain('page=1')
+      expect(req.method).toBe('GET')
+      expect(result.status).toBe(200)
+    })
+
+    it('应该发送 POST 请求', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users.post({ name: 'John' })
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.method).toBe('POST')
+      expect(req.url).toContain('/users')
+    })
+
+    it('应该正确设置请求头', async () => {
+      const api = eden<TestContract>('http://localhost:3000', {
+        headers: { 'Authorization': 'Bearer token123' }
+      })
+      
+      await api.users.get()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.headers.get('Authorization')).toBe('Bearer token123')
+      expect(req.headers.get('Content-Type')).toBe('application/json')
+    })
+  })
+
+  // ============= 参数化路由测试 =============
+
+  describe('参数化路由', () => {
+    it('应该通过函数调用处理路径参数', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users({ id: '123' }).get()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/123')
+      expect(req.method).toBe('GET')
+    })
+
+    it('应该处理 PUT 请求和路径参数', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users({ id: '123' }).put({ name: 'Jane' })
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/123')
+      expect(req.method).toBe('PUT')
+    })
+
+    it('应该处理 DELETE 请求和路径参数', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users({ id: '456' }).delete()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/456')
+      expect(req.method).toBe('DELETE')
+    })
+
+    it('应该对路径参数进行 URL 编码', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users({ id: 'user/123' }).get()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/user%2F123')
+    })
+  })
+
+  // ============= 嵌套路由测试 =============
+
+  describe('嵌套路由', () => {
+    interface NestedContract {
+      users: {
+        ':id': {
+          posts: {
+            get: { return: { id: string }[] }
+            ':id': {
+              get: { return: { id: string; title: string } }
+            }
+          }
+        }
+      }
+    }
+
+    it('应该处理嵌套路径', async () => {
+      const api = eden<NestedContract>('http://localhost:3000')
+      
+      await api.users({ id: '123' }).posts.get()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/123/posts')
+    })
+
+    it('应该处理多层嵌套路径参数', async () => {
+      const api = eden<NestedContract>('http://localhost:3000')
+      
+      // 动态参数统一使用 :id
+      await api.users({ id: '123' }).posts({ id: '456' }).get()
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      expect(req.url).toBe('http://localhost:3000/users/123/posts/456')
+    })
+  })
+
+  // ============= 请求取消测试 =============
+
+  describe('请求取消', () => {
+    it('应该支持通过 AbortController 取消请求', async () => {
+      const controller = new AbortController()
+      
+      mockFetch.mockImplementation(() => {
+        return new Promise((_, reject) => {
+          controller.signal.addEventListener('abort', () => {
+            const error = new Error('This operation was aborted')
+            error.name = 'AbortError'
+            reject(error)
+          })
+        })
+      })
+
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      const promise = api.users.get(undefined, { signal: controller.signal })
+      controller.abort()
+      
+      const result = await promise
+      expect(result.error).toBeTruthy()
+      expect(result.status).toBe(0)
+    })
+
+    it('应该在超时后自动取消请求', async () => {
+      mockFetch.mockImplementation((input: Request | string) => {
+        return new Promise((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            resolve(new Response(JSON.stringify({}), { status: 200 }))
+          }, 5000)
+          
+          // 从 Request 对象获取 signal
+          const signal = input instanceof Request ? input.signal : undefined
+          signal?.addEventListener('abort', () => {
+            clearTimeout(timeoutId)
+            const error = new Error('This operation was aborted')
+            error.name = 'AbortError'
+            reject(error)
+          })
+        })
+      })
+
+      const api = eden<TestContract>('http://localhost:3000', { timeout: 100 })
+      
+      const result = await api.users.get()
+      
+      expect(result.error).toBeTruthy()
+      expect(result.status).toBe(0)
+    })
+  })
+
+  // ============= 拦截器测试 =============
+
+  describe('拦截器', () => {
+    it('应该执行 onRequest 拦截器', async () => {
+      const onRequest = vi.fn((req: Request) => {
+        return new Request(req.url, {
+          ...req,
+          headers: { ...Object.fromEntries(req.headers), 'X-Custom': 'value' }
+        })
+      })
+
+      const api = eden<TestContract>('http://localhost:3000', { onRequest })
+      
+      await api.users.get()
+      
+      expect(onRequest).toHaveBeenCalled()
+    })
+
+    it('应该执行 onResponse 拦截器', async () => {
+      const onResponse = vi.fn((response) => response)
+
+      const api = eden<TestContract>('http://localhost:3000', { onResponse })
+      
+      await api.users.get()
+      
+      expect(onResponse).toHaveBeenCalled()
+    })
+
+    it('应该在错误时执行 onError 回调', async () => {
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify({ error: 'Not found' }), {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' }
+        })
+      )
+
+      const onError = vi.fn()
+      const api = eden<TestContract>('http://localhost:3000', { onError })
+      
+      await api.users.get()
+      
+      expect(onError).toHaveBeenCalled()
+    })
+  })
+
+  // ============= 响应处理测试 =============
+
+  describe('响应处理', () => {
+    it('应该正确解析 JSON 响应', async () => {
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify({ users: [{ id: '1' }], total: 10 }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' }
+        })
+      )
+
+      const api = eden<TestContract>('http://localhost:3000')
+      const result = await api.users.get()
+      
+      expect(result.data).toEqual({ users: [{ id: '1' }], total: 10 })
+      expect(result.status).toBe(200)
+      expect(result.error).toBeNull()
+    })
+
+    it('应该正确解析文本响应', async () => {
+      mockFetch.mockResolvedValue(
+        new Response('Hello World', {
+          status: 200,
+          headers: { 'Content-Type': 'text/plain' }
+        })
+      )
+
+      const api = eden<TestContract>('http://localhost:3000')
+      const result = await api.users.get()
+      
+      expect(result.data).toBe('Hello World')
+    })
+
+    it('应该处理 HTTP 错误状态', async () => {
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify({ message: 'Unauthorized' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json' }
+        })
+      )
+
+      const api = eden<TestContract>('http://localhost:3000')
+      const result = await api.users.get()
+      
+      expect(result.status).toBe(401)
+      expect(result.error).toBeTruthy()
+      expect(result.error?.message).toContain('401')
+    })
+
+    it('应该处理网络错误', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      const api = eden<TestContract>('http://localhost:3000')
+      const result = await api.users.get()
+      
+      expect(result.error?.message).toBe('Network error')
+      expect(result.status).toBe(0)
+      expect(result.data).toBeNull()
+    })
+  })
+
+  // ============= Query 参数测试 =============
+
+  describe('Query 参数', () => {
+    it('应该正确构建查询字符串', async () => {
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users.get({ page: 2 })
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      const url = new URL(req.url)
+      expect(url.searchParams.get('page')).toBe('2')
+    })
+
+    it('应该忽略 undefined 和 null 值', async () => {
+      // 直接使用 TestContract，测试 users.get
+      const api = eden<TestContract>('http://localhost:3000')
+      
+      await api.users.get({ page: undefined })
+      
+      const req = mockFetch.mock.calls[0][0] as Request
+      const url = new URL(req.url)
+      // undefined 值不应该出现在查询字符串中
+      expect(url.searchParams.has('page')).toBe(false)
+    })
+  })
+})
+
+// ============= SSE 测试 =============
+
+describe('SSE 订阅', () => {
+  beforeEach(() => {
+    mockFetch.mockReset()
+  })
+
+  it('应该调用 subscribe 方法', async () => {
+    // 创建模拟 SSE 流
+    const encoder = new TextEncoder()
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode('data: {"message":"hello"}\n\n'))
+        controller.close()
+      }
+    })
+
+    mockFetch.mockResolvedValue(
+      new Response(stream, {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' }
+      })
+    )
+
+    interface SSEContract {
+      events: {
+        get: { query: { channel: string }; return: unknown; sse: { readonly __brand: 'SSE' } }
+      }
+    }
+
+    const api = eden<SSEContract>('http://localhost:3000')
+    const onMessage = vi.fn()
+    const onClose = vi.fn()
+
+    await new Promise<void>((resolve) => {
+      api.events.subscribe(
+        { channel: 'test' },
+        {
+          onMessage,
+          onClose: () => {
+            onClose()
+            resolve()
+          }
+        }
+      )
+    })
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(onMessage).toHaveBeenCalledWith({ message: 'hello' })
+    expect(onClose).toHaveBeenCalled()
+  })
+
+  it('应该支持取消订阅', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        // 永不关闭的流
+      }
+    })
+
+    mockFetch.mockResolvedValue(
+      new Response(stream, {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' }
+      })
+    )
+
+    interface SSEContract {
+      events: {
+        get: { return: unknown; sse: { readonly __brand: 'SSE' } }
+      }
+    }
+
+    const api = eden<SSEContract>('http://localhost:3000')
+    
+    const sub = api.events.subscribe({
+      onMessage: () => {}
+    })
+
+    expect(sub.connected).toBe(false) // 还在连接中
+    
+    sub.unsubscribe()
+    expect(sub.connected).toBe(false)
+  })
+})

package/tsconfig.json

@@ -13,7 +13,7 @@
     "sourceMap": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "types": ["bun-types"]
+    "types": []
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test"]

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: false,
+  },
+})
+