@vafast/api-client 0.1.1

package/src/utils/index.ts

@@ -0,0 +1,232 @@
+import type { QueryParams, PathParams, RequestBody, FileUpload, ApiFormData } from "../types";
+
+/**
+ * 构建查询字符串
+ */
+export function buildQueryString(params: QueryParams): string {
+  if (!params || Object.keys(params).length === 0) return "";
+
+  const searchParams = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => searchParams.append(key, String(v)));
+      } else {
+        searchParams.append(key, String(value));
+      }
+    }
+  }
+
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+
+/**
+ * 替换路径参数
+ */
+export function replacePathParams(path: string, params: PathParams): string {
+  let result = path;
+
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(`:${key}`, String(value));
+  }
+
+  return result;
+}
+
+/**
+ * 检查是否为文件对象
+ */
+export function isFile(value: unknown): value is File | Blob {
+  return value instanceof File || value instanceof Blob;
+}
+
+/**
+ * 检查是否为文件上传对象
+ */
+export function isFileUpload(value: unknown): value is FileUpload {
+  if (value === null || value === undefined) return false;
+  return (
+    value && typeof value === "object" && "file" in value && isFile((value as FileUpload).file)
+  );
+}
+
+/**
+ * 检查对象是否包含文件
+ */
+export function hasFiles(obj: unknown): boolean {
+  if (!obj || typeof obj !== "object") return false;
+
+  for (const value of Object.values(obj as Record<string, unknown>)) {
+    if (isFile(value) || isFileUpload(value)) return true;
+    if (Array.isArray(value) && value.some(isFile)) return true;
+    if (typeof value === "object" && hasFiles(value)) return true;
+  }
+
+  return false;
+}
+
+/**
+ * 创建 FormData
+ */
+export function createFormData(data: ApiFormData): globalThis.FormData {
+  const formData = new globalThis.FormData();
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined || value === null) continue;
+
+    if (isFileUpload(value)) {
+      formData.append(key, value.file, value.filename);
+    } else if (isFile(value)) {
+      formData.append(key, value);
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => {
+        if (isFileUpload(v)) {
+          formData.append(key, v.file, v.filename);
+        } else if (isFile(v)) {
+          formData.append(key, v);
+        } else {
+          formData.append(key, String(v));
+        }
+      });
+    } else {
+      formData.append(key, String(value));
+    }
+  }
+
+  return formData;
+}
+
+/**
+ * 深度合并对象
+ */
+export function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+  const result = { ...target } as T;
+
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const targetValue = result[key as keyof T];
+      if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key as keyof T] = deepMerge(targetValue, value) as T[keyof T];
+      } else {
+        result[key as keyof T] = value as T[keyof T];
+      }
+    } else {
+      result[key as keyof T] = value as T[keyof T];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 延迟函数
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * 指数退避重试延迟
+ */
+export function exponentialBackoff(attempt: number, baseDelay: number, maxDelay: number): number {
+  const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+  return delay + Math.random() * 1000; // 添加随机抖动
+}
+
+/**
+ * 验证状态码
+ */
+export function validateStatus(status: number): boolean {
+  return status >= 200 && status < 300;
+}
+
+/**
+ * 解析响应内容类型
+ */
+export function parseContentType(contentType: string | null): string {
+  if (!contentType) return "text/plain";
+  return contentType.split(";")[0].trim();
+}
+
+/**
+ * 解析响应数据
+ */
+export async function parseResponse(response: Response): Promise<any> {
+  const contentType = parseContentType(response.headers.get("content-type"));
+
+  switch (contentType) {
+    case "application/json":
+      return response.json();
+    case "application/octet-stream":
+      return response.arrayBuffer();
+    case "multipart/form-data":
+      const formData = await response.formData();
+      const data: Record<string, any> = {};
+      formData.forEach((value, key) => {
+        data[key] = value;
+      });
+      return data;
+    case "text/event-stream":
+      return response.body;
+    default:
+      return response.text();
+  }
+}
+
+/**
+ * 创建错误对象
+ */
+export function createError(status: number, message: string, data?: unknown): Error {
+  const error = new Error(message) as Error & { status: number; data?: unknown; name: string };
+  error.status = status;
+  error.data = data;
+  error.name = "ApiError";
+  return error;
+}
+
+/**
+ * 克隆请求对象
+ */
+export function cloneRequest(request: Request): Request {
+  return new Request(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+    mode: request.mode,
+    credentials: request.credentials,
+    cache: request.cache,
+    redirect: request.redirect,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy,
+    integrity: request.integrity,
+    keepalive: request.keepalive,
+    signal: request.signal,
+  });
+}
+
+/**
+ * 检查是否为可重试的错误
+ */
+export function isRetryableError(error: Error, status?: number): boolean {
+  if (status) {
+    return [408, 429, 500, 502, 503, 504].includes(status);
+  }
+
+  // 网络错误通常是可重试的
+  if (error.name === "TypeError" && error.message.includes("fetch")) {
+    return true;
+  }
+
+  // 检查其他网络相关错误
+  if (
+    error.message.includes("fetch") ||
+    error.message.includes("network") ||
+    error.message.includes("connection")
+  ) {
+    return true;
+  }
+
+  return false;
+}

package/src/websocket/websocket-client.ts

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