@vafast/api-client 0.1.1 → 0.1.2

package/src/websocket/websocket-client.ts

@@ -1,347 +0,0 @@
-import type { WebSocketClient, WebSocketEvent } from '../types'
-
-/**
- * Vafast WebSocket 客户端
- */
-export class VafastWebSocketClient implements WebSocketClient {
-  private ws: WebSocket | null = null
-  private url: string
-  private eventListeners = new Map<string, Set<(data: any) => void>>()
-  private reconnectAttempts = 0
-  private maxReconnectAttempts = 5
-  private reconnectDelay = 1000
-  private isReconnecting = false
-  private autoReconnect = true
-
-  constructor(url: string, options: {
-    autoReconnect?: boolean
-    maxReconnectAttempts?: number
-    reconnectDelay?: number
-  } = {}) {
-    this.url = url
-    this.autoReconnect = options.autoReconnect ?? true
-    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5
-    this.reconnectDelay = options.reconnectDelay ?? 1000
-  }
-
-  /**
-   * 连接到 WebSocket 服务器
-   */
-  async connect(): Promise<void> {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.url)
-        
-        this.ws.onopen = () => {
-          this.reconnectAttempts = 0
-          this.isReconnecting = false
-          resolve()
-        }
-        
-        this.ws.onclose = (event) => {
-          if (this.autoReconnect && !this.isReconnecting && this.reconnectAttempts < this.maxReconnectAttempts) {
-            this.scheduleReconnect()
-          }
-        }
-        
-        this.ws.onerror = (error) => {
-          reject(error)
-        }
-        
-        this.ws.onmessage = (event) => {
-          this.handleMessage(event)
-        }
-      } catch (error) {
-        reject(error)
-      }
-    })
-  }
-
-  /**
-   * 断开 WebSocket 连接
-   */
-  disconnect(): void {
-    this.autoReconnect = false
-    if (this.ws) {
-      this.ws.close()
-      this.ws = null
-    }
-  }
-
-  /**
-   * 发送数据
-   */
-  send(data: any): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error('WebSocket is not connected')
-    }
-
-    if (typeof data === 'string') {
-      this.ws.send(data)
-    } else {
-      this.ws.send(JSON.stringify(data))
-    }
-  }
-
-  /**
-   * 监听事件
-   */
-  on(event: string, callback: (data: any) => void): void {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set())
-    }
-    this.eventListeners.get(event)!.add(callback)
-  }
-
-  /**
-   * 移除事件监听器
-   */
-  off(event: string, callback: (data: any) => void): void {
-    const listeners = this.eventListeners.get(event)
-    if (listeners) {
-      listeners.delete(callback)
-      if (listeners.size === 0) {
-        this.eventListeners.delete(event)
-      }
-    }
-  }
-
-  /**
-   * 检查是否已连接
-   */
-  isConnected(): boolean {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN
-  }
-
-  /**
-   * 获取连接状态
-   */
-  getReadyState(): number {
-    return this.ws ? this.ws.readyState : WebSocket.CLOSED
-  }
-
-  /**
-   * 获取连接状态文本
-   */
-  getReadyStateText(): string {
-    const states: Record<number, string> = {
-      [WebSocket.CONNECTING]: 'CONNECTING',
-      [WebSocket.OPEN]: 'OPEN',
-      [WebSocket.CLOSING]: 'CLOSING',
-      [WebSocket.CLOSED]: 'CLOSED'
-    }
-    return states[this.getReadyState()] || 'UNKNOWN'
-  }
-
-  /**
-   * 设置自动重连
-   */
-  setAutoReconnect(enabled: boolean): void {
-    this.autoReconnect = enabled
-  }
-
-  /**
-   * 设置最大重连次数
-   */
-  setMaxReconnectAttempts(attempts: number): void {
-    this.maxReconnectAttempts = attempts
-  }
-
-  /**
-   * 设置重连延迟
-   */
-  setReconnectDelay(delay: number): void {
-    this.reconnectDelay = delay
-  }
-
-  /**
-   * 手动重连
-   */
-  async reconnect(): Promise<void> {
-    if (this.isReconnecting) {
-      return
-    }
-
-    this.isReconnecting = true
-    this.disconnect()
-    
-    // 等待一段时间后重连
-    await new Promise(resolve => setTimeout(resolve, this.reconnectDelay))
-    
-    try {
-      await this.connect()
-    } catch (error) {
-      this.isReconnecting = false
-      throw error
-    }
-  }
-
-  /**
-   * 获取事件监听器数量
-   */
-  getEventListenerCount(event: string): number {
-    const listeners = this.eventListeners.get(event)
-    return listeners ? listeners.size : 0
-  }
-
-  /**
-   * 清除所有事件监听器
-   */
-  clearEventListeners(event?: string): void {
-    if (event) {
-      this.eventListeners.delete(event)
-    } else {
-      this.eventListeners.clear()
-    }
-  }
-
-  /**
-   * 获取所有事件名称
-   */
-  getEventNames(): string[] {
-    return Array.from(this.eventListeners.keys())
-  }
-
-  /**
-   * 处理接收到的消息
-   */
-  private handleMessage(event: MessageEvent): void {
-    let data: any
-    
-    try {
-      data = JSON.parse(event.data)
-    } catch {
-      data = event.data
-    }
-
-    const wsEvent: WebSocketEvent = {
-      type: 'message',
-      data,
-      timestamp: Date.now()
-    }
-
-    // 触发消息事件监听器
-    this.triggerEvent('message', wsEvent)
-    
-    // 如果有特定类型的事件监听器，也触发它们
-    if (data && typeof data === 'object' && data.type) {
-      this.triggerEvent(data.type, data)
-    }
-  }
-
-  /**
-   * 触发事件
-   */
-  private triggerEvent(event: string, data: any): void {
-    const listeners = this.eventListeners.get(event)
-    if (listeners) {
-      listeners.forEach(callback => {
-        try {
-          callback(data)
-        } catch (error) {
-          console.error(`Error in WebSocket event listener for ${event}:`, error)
-        }
-      })
-    }
-  }
-
-  /**
-   * 安排重连
-   */
-  private scheduleReconnect(): void {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      return
-    }
-
-    this.reconnectAttempts++
-    this.isReconnecting = true
-
-    setTimeout(async () => {
-      try {
-        await this.connect()
-      } catch (error) {
-        console.error('WebSocket reconnection failed:', error)
-        if (this.reconnectAttempts < this.maxReconnectAttempts) {
-          this.scheduleReconnect()
-        }
-      }
-    }, this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1))
-  }
-}
-
-/**
- * 创建 WebSocket 客户端
- */
-export function createWebSocketClient(
-  url: string,
-  options?: {
-    autoReconnect?: boolean
-    maxReconnectAttempts?: number
-    reconnectDelay?: number
-  }
-): VafastWebSocketClient {
-  return new VafastWebSocketClient(url, options)
-}
-
-/**
- * 创建类型安全的 WebSocket 客户端
- */
-export function createTypedWebSocketClient<T = any>(
-  url: string,
-  options?: {
-    autoReconnect?: boolean
-    maxReconnectAttempts?: number
-    reconnectDelay?: number
-  }
-): VafastWebSocketClient & {
-  on<K extends keyof T>(event: K, callback: (data: T[K]) => void): void
-  send<K extends keyof T>(event: K, data: T[K]): void
-} {
-  const client = new VafastWebSocketClient(url, options)
-  
-  // Create a new object that extends the client
-  const typedClient = Object.create(Object.getPrototypeOf(client))
-  
-  // Copy all properties and methods from the client
-  for (const key of Object.getOwnPropertyNames(client)) {
-    const descriptor = Object.getOwnPropertyDescriptor(client, key)
-    if (descriptor) {
-      Object.defineProperty(typedClient, key, descriptor)
-    }
-  }
-  
-  // Copy all symbol properties
-  for (const symbol of Object.getOwnPropertySymbols(client)) {
-    const descriptor = Object.getOwnPropertyDescriptor(client, symbol)
-    if (descriptor) {
-      Object.defineProperty(typedClient, symbol, descriptor)
-    }
-  }
-  
-  // Override the on method for typed events
-  typedClient.on = (event: keyof T, callback: (data: any) => void): void => {
-    client.on(String(event), callback)
-  }
-  
-  // Override the send method for typed events
-  typedClient.send = (event: keyof T, data: any): void => {
-    // Use the original client's send method directly
-    client.send({ type: event, data })
-  }
-  
-  // Ensure the typed client has access to the original client's properties
-  Object.defineProperty(typedClient, 'ws', {
-    get() {
-      return (client as any).ws
-    },
-    set(value) {
-      (client as any).ws = value
-    }
-  })
-  
-  return typedClient
-}

package/test/api-client.test.ts

@@ -1,262 +0,0 @@
-import { describe, expect, it, beforeEach, mock } from 'bun:test'
-import { VafastApiClient } from '../src'
-
-// Mock fetch
-const mockFetch = mock(() => 
-  Promise.resolve(new Response(JSON.stringify({ success: true }), {
-    status: 200,
-    headers: { 'Content-Type': 'application/json' }
-  }))
-)
-
-// Mock global fetch
-global.fetch = mockFetch
-
-describe('VafastApiClient', () => {
-  let client: VafastApiClient
-
-  beforeEach(() => {
-    client = new VafastApiClient({
-      baseURL: 'https://api.example.com',
-      timeout: 5000,
-      retries: 2
-    })
-    mockFetch.mockClear()
-  })
-
-  describe('Constructor', () => {
-    it('should create client with default config', () => {
-      const defaultClient = new VafastApiClient()
-      expect(defaultClient).toBeDefined()
-    })
-
-    it('should create client with custom config', () => {
-      expect(client).toBeDefined()
-    })
-
-    it('should merge config correctly', () => {
-      const customClient = new VafastApiClient({
-        baseURL: 'https://custom.api.com',
-        timeout: 10000
-      })
-      expect(customClient).toBeDefined()
-    })
-  })
-
-  describe('Middleware Management', () => {
-    it('should add middleware', () => {
-      const middleware = {
-        name: 'test',
-        onRequest: async (req: Request) => req
-      }
-
-      client.addMiddleware(middleware)
-      expect(client).toBeDefined()
-    })
-
-    it('should remove middleware', () => {
-      const middleware = {
-        name: 'test',
-        onRequest: async (req: Request) => req
-      }
-
-      client.addMiddleware(middleware)
-      client.removeMiddleware('test')
-      expect(client).toBeDefined()
-    })
-
-    it('should handle non-existent middleware removal', () => {
-      client.removeMiddleware('non-existent')
-      expect(client).toBeDefined()
-    })
-  })
-
-  describe('Interceptor Management', () => {
-    it('should add interceptor', () => {
-      const interceptor = {
-        request: async (config: any) => config
-      }
-
-      client.addInterceptor(interceptor)
-      expect(client).toBeDefined()
-    })
-
-    it('should remove interceptor', () => {
-      const interceptor = {
-        request: async (config: any) => config
-      }
-
-      client.addInterceptor(interceptor)
-      client.removeInterceptor(0)
-      expect(client).toBeDefined()
-    })
-
-    it('should handle invalid interceptor index', () => {
-      client.removeInterceptor(-1)
-      client.removeInterceptor(999)
-      expect(client).toBeDefined()
-    })
-  })
-
-  describe('Cache Management', () => {
-    it('should clear cache', () => {
-      client.clearCache()
-      const stats = client.getCacheStats()
-      expect(stats.size).toBe(0)
-      expect(stats.keys).toEqual([])
-    })
-
-    it('should get cache stats', () => {
-      const stats = client.getCacheStats()
-      expect(stats).toHaveProperty('size')
-      expect(stats).toHaveProperty('keys')
-      expect(Array.isArray(stats.keys)).toBe(true)
-    })
-  })
-
-  describe('Configuration Methods', () => {
-    it('should set cache config', () => {
-      const result = client.setCacheConfig({
-        enabled: true,
-        ttl: 300000,
-        maxSize: 100,
-        strategy: 'memory'
-      })
-      expect(result).toBe(client)
-    })
-
-    it('should set retry config', () => {
-      const result = client.setRetryConfig({
-        enabled: true,
-        maxRetries: 5,
-        retryDelay: 1000,
-        backoffMultiplier: 2,
-        retryableStatuses: [500, 502, 503]
-      })
-      expect(result).toBe(client)
-    })
-
-    it('should set log config', () => {
-      const result = client.setLogConfig({
-        enabled: true,
-        level: 'info',
-        format: 'json',
-        includeHeaders: true,
-        includeBody: false
-      })
-      expect(result).toBe(client)
-    })
-  })
-
-  describe('HTTP Methods', () => {
-    it('should make GET request', async () => {
-      const response = await client.get('/users', { page: 1, limit: 10 })
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make POST request', async () => {
-      const response = await client.post('/users', { name: 'John', email: 'john@example.com' })
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make PUT request', async () => {
-      const response = await client.put('/users/123', { name: 'John Updated' })
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make DELETE request', async () => {
-      const response = await client.delete('/users/123')
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make PATCH request', async () => {
-      const response = await client.patch('/users/123', { name: 'John Patched' })
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make HEAD request', async () => {
-      const response = await client.head('/users')
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should make OPTIONS request', async () => {
-      const response = await client.options('/users')
-      expect(response).toBeDefined()
-      expect(mockFetch).toHaveBeenCalled()
-    })
-  })
-
-  describe('Request Configuration', () => {
-    it('should handle custom headers', async () => {
-      const response = await client.get('/users', undefined, {
-        headers: { 'X-Custom-Header': 'test' }
-      })
-      expect(response).toBeDefined()
-    })
-
-    it('should handle timeout configuration', async () => {
-      const response = await client.get('/users', undefined, {
-        timeout: 10000
-      })
-      expect(response).toBeDefined()
-    })
-
-    it('should handle retry configuration', async () => {
-      const response = await client.get('/users', undefined, {
-        retries: 5,
-        retryDelay: 2000
-      })
-      expect(response).toBeDefined()
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should handle network errors gracefully', async () => {
-      // Mock fetch to throw error
-      const errorFetch = mock(() => Promise.reject(new Error('Network error')))
-      global.fetch = errorFetch
-
-      const response = await client.get('/users')
-      expect(response.error).toBeDefined()
-      expect(response.data).toBeNull()
-
-      // Restore original mock
-      global.fetch = mockFetch
-    })
-
-    it('should handle HTTP error statuses', async () => {
-      const errorFetch = mock(() => 
-        Promise.resolve(new Response('Not Found', { status: 404 }))
-      )
-      global.fetch = errorFetch
-
-      const response = await client.get('/users')
-      expect(response.status).toBe(404)
-
-      // Restore original mock
-      global.fetch = mockFetch
-    })
-  })
-
-  describe('URL Building', () => {
-    it('should build URLs correctly with baseURL', async () => {
-      const customClient = new VafastApiClient({
-        baseURL: 'https://api.example.com'
-      })
-
-      await customClient.get('/users')
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should handle absolute URLs', async () => {
-      await client.get('https://external.api.com/users')
-      expect(mockFetch).toHaveBeenCalled()
-    })
-  })
-})

package/test/basic.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it, beforeEach } from 'bun:test'
-import { VafastApiClient } from '../src'
-
-describe('VafastApiClient', () => {
-  let client: VafastApiClient
-
-  beforeEach(() => {
-    client = new VafastApiClient({
-      baseURL: 'https://api.example.com',
-      timeout: 5000,
-      retries: 2
-    })
-  })
-
-  it('should create client with default config', () => {
-    const defaultClient = new VafastApiClient()
-    expect(defaultClient).toBeDefined()
-  })
-
-  it('should create client with custom config', () => {
-    expect(client).toBeDefined()
-  })
-
-  it('should add and remove middleware', () => {
-    const middleware = {
-      name: 'test',
-      onRequest: async (req: Request) => req
-    }
-
-    client.addMiddleware(middleware)
-    expect(client.getCacheStats()).toBeDefined()
-
-    client.removeMiddleware('test')
-    expect(client.getCacheStats()).toBeDefined()
-  })
-
-  it('should add and remove interceptor', () => {
-    const interceptor = {
-      request: async (config: any) => config
-    }
-
-    client.addInterceptor(interceptor)
-    expect(client.getCacheStats()).toBeDefined()
-
-    client.removeInterceptor(0)
-    expect(client.getCacheStats()).toBeDefined()
-  })
-
-  it('should clear cache', () => {
-    client.clearCache()
-    const stats = client.getCacheStats()
-    expect(stats.size).toBe(0)
-    expect(stats.keys).toEqual([])
-  })
-})