@vafast/api-client 0.1.1 → 0.1.3

package/src/core/typed-client.ts

@@ -1,305 +0,0 @@
-// 导入必要的类型
-import type {
-  ApiClientConfig,
-  RequestConfig,
-  ApiResponse,
-  QueryParams,
-  PathParams,
-  RequestBody,
-  Server,
-  Route,
-  RouteHandler,
-  InferRouteHandler,
-  InferServer,
-  RoutePath,
-  RouteMethod,
-  RouteHandlerType,
-} from "../types";
-import { VafastApiClient } from "./api-client";
-import { replacePathParams } from "../utils";
-
-// 类型推断类型 - 重新导出
-export type { InferRouteHandler, InferServer, RoutePath, RouteMethod, RouteHandlerType };
-
-// 定义 HTTP 方法类型
-type HttpMethod = "get" | "post" | "put" | "delete" | "patch" | "head" | "options";
-
-// 类型守卫函数
-function isHttpMethod(prop: string): prop is HttpMethod {
-  return ["get", "post", "put", "delete", "patch", "head", "options"].includes(prop);
-}
-
-// 类型安全的 HTTP 方法映射
-type HttpMethodMap = {
-  get: (path: string, query?: QueryParams, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-  post: (path: string, body?: RequestBody, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-  put: (path: string, body?: RequestBody, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-  delete: (path: string, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-  patch: (
-    path: string,
-    body?: RequestBody,
-    config?: RequestConfig
-  ) => Promise<ApiResponse<unknown>>;
-  head: (path: string, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-  options: (path: string, config?: RequestConfig) => Promise<ApiResponse<unknown>>;
-};
-
-// 改进的参数类型判断
-function isRequestBody(value: unknown): value is RequestBody {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    !(value instanceof FormData)
-  );
-}
-
-function isQueryParams(value: unknown): value is QueryParams {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    !(value instanceof FormData)
-  );
-}
-
-// 改进的路径构建函数
-function normalizePath(basePath: string, prop: string): string {
-  const cleanBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  const cleanProp = prop.startsWith("/") ? prop.slice(1) : prop;
-  return `${cleanBase}/${cleanProp}`;
-}
-
-// 类型安全的客户端接口
-export interface TypedApiClient<T> {
-  // 基础 HTTP 方法
-  get<P extends string>(
-    path: P,
-    query?: QueryParams,
-    config?: RequestConfig
-  ): Promise<ApiResponse<unknown>>;
-
-  post<P extends string>(
-    path: P,
-    body?: RequestBody,
-    config?: RequestConfig
-  ): Promise<ApiResponse<unknown>>;
-
-  put<P extends string>(
-    path: P,
-    body?: RequestBody,
-    config?: RequestConfig
-  ): Promise<ApiResponse<unknown>>;
-
-  delete<P extends string>(path: P, config?: RequestConfig): Promise<ApiResponse<unknown>>;
-
-  patch<P extends string>(
-    path: P,
-    body?: RequestBody,
-    config?: RequestConfig
-  ): Promise<ApiResponse<unknown>>;
-
-  head<P extends string>(path: P, config?: RequestConfig): Promise<ApiResponse<unknown>>;
-
-  options<P extends string>(path: P, config?: RequestConfig): Promise<ApiResponse<unknown>>;
-
-  // 动态路径方法
-  [key: string]: unknown;
-}
-
-/**
- * 创建类型安全的 API 客户端
- */
-export function createTypedClient<T extends Server>(
-  server: T,
-  config?: ApiClientConfig
-): TypedApiClient<T> {
-  const apiClient = new VafastApiClient(config);
-
-  // 创建代理对象，支持链式调用
-  return new Proxy({} as TypedApiClient<T>, {
-    get(target, prop: string) {
-      // 如果是 HTTP 方法，返回对应的请求方法
-      if (isHttpMethod(prop)) {
-        return (path: string, bodyOrQuery?: RequestBody | QueryParams, config?: RequestConfig) => {
-          const method = prop.toUpperCase();
-
-          if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
-            // 暂时使用类型断言，保持功能正常
-            return (apiClient as any)[prop](path, bodyOrQuery as QueryParams, config);
-          } else {
-            return (apiClient as any)[prop](path, bodyOrQuery as RequestBody, config);
-          }
-        };
-      }
-
-      // 如果是路径段，返回新的代理对象
-      return createPathProxy(apiClient, prop);
-    },
-  });
-}
-
-/**
- * 创建路径代理
- */
-function createPathProxy(apiClient: VafastApiClient, basePath: string) {
-  return new Proxy({} as Record<string, unknown>, {
-    get(target, prop: string) {
-      const currentPath = normalizePath(basePath, prop);
-
-      // 如果是 HTTP 方法，返回对应的请求方法
-      if (isHttpMethod(prop)) {
-        return (bodyOrQuery?: RequestBody | QueryParams, config?: RequestConfig) => {
-          const method = prop.toUpperCase();
-
-          if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
-            // 使用类型安全的方法调用
-            const clientMethod = apiClient[prop as keyof HttpMethodMap];
-            const queryParams = bodyOrQuery as QueryParams | undefined;
-            return (clientMethod as any)(basePath, queryParams, config);
-          } else {
-            const clientMethod = apiClient[prop as keyof HttpMethodMap];
-            const requestBody = bodyOrQuery as RequestBody | undefined;
-            return (clientMethod as any)(basePath, requestBody, config);
-          }
-        };
-      }
-
-      // 如果是路径段，返回新的代理对象
-      return createPathProxy(apiClient, currentPath);
-    },
-
-    // 处理函数调用（用于动态路径）
-    apply(target, thisArg, args) {
-      const [params, bodyOrQuery, config] = args as [
-        PathParams,
-        RequestBody | QueryParams,
-        RequestConfig?
-      ];
-
-      // 替换路径参数
-      const resolvedPath = replacePathParams(basePath, params || {});
-
-      // 使用改进的参数类型判断
-      if (bodyOrQuery && isRequestBody(bodyOrQuery) && !config) {
-        // 如果有 body 参数，使用 POST 方法
-        return apiClient.post(resolvedPath, bodyOrQuery, config);
-      } else {
-        // 否则使用 GET
-        return apiClient.get(resolvedPath, bodyOrQuery as QueryParams, config);
-      }
-    },
-  });
-}
-
-/**
- * 创建基于路由的客户端
- */
-export function createRouteBasedClient<T extends Server>(
-  server: T,
-  config?: ApiClientConfig
-): TypedApiClient<T> {
-  const apiClient = new VafastApiClient(config);
-
-  // 分析服务器路由，创建类型安全的客户端
-  return createTypedClientFromRoutes(server, apiClient);
-}
-
-/**
- * 从路由创建类型安全的客户端
- */
-function createTypedClientFromRoutes<T extends Server>(
-  server: T,
-  apiClient: VafastApiClient
-): TypedApiClient<T> {
-  // 这里可以根据实际的路由结构来生成客户端
-  // 由于 Vafast 的路由结构，我们需要动态分析
-
-  return new Proxy({} as TypedApiClient<T>, {
-    get(target, prop: string) {
-      // 返回一个可以处理动态路径的对象
-      return createDynamicPathHandler(apiClient, prop);
-    },
-  });
-}
-
-/**
- * 创建动态路径处理器
- */
-function createDynamicPathHandler(apiClient: VafastApiClient, basePath: string) {
-  return new Proxy({} as Record<string, unknown>, {
-    get(target, prop: string) {
-      const currentPath = normalizePath(basePath, prop);
-
-      // 如果是 HTTP 方法
-      if (isHttpMethod(prop)) {
-        return (bodyOrQuery?: RequestBody | QueryParams, config?: RequestConfig) => {
-          const method = prop.toUpperCase();
-
-          if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
-            // 使用类型安全的方法调用
-            const clientMethod = apiClient[prop as keyof HttpMethodMap];
-            const queryParams = bodyOrQuery as QueryParams | undefined;
-            return clientMethod(basePath, queryParams, config);
-          } else {
-            const clientMethod = apiClient[prop as keyof HttpMethodMap];
-            const requestBody = bodyOrQuery as RequestBody | undefined;
-            return (clientMethod as any)(basePath, requestBody, config);
-          }
-        };
-      }
-
-      // 继续构建路径
-      return createDynamicPathHandler(apiClient, currentPath);
-    },
-
-    // 处理函数调用
-    apply(target, thisArg, args) {
-      const [params, bodyOrQuery, config] = args as [
-        PathParams,
-        RequestBody | QueryParams,
-        RequestConfig?
-      ];
-
-      // 替换路径参数
-      const resolvedPath = replacePathParams(basePath, params || {});
-
-      // 使用改进的参数类型判断
-      if (bodyOrQuery && isRequestBody(bodyOrQuery) && !config) {
-        return apiClient.post(resolvedPath, bodyOrQuery);
-      } else {
-        return apiClient.get(resolvedPath, bodyOrQuery as QueryParams, config);
-      }
-    },
-  });
-}
-
-/**
- * 创建简单的类型安全客户端
- */
-export function createSimpleClient<T extends Server>(
-  server: T,
-  config?: ApiClientConfig
-): TypedApiClient<T> {
-  const apiClient = new VafastApiClient(config);
-
-  return {
-    get: (path: string, query?: QueryParams, config?: RequestConfig) =>
-      (apiClient as any).get(path, query, config),
-
-    post: (path: string, body?: RequestBody, config?: RequestConfig) =>
-      (apiClient as any).post(path, body, config),
-
-    put: (path: string, body?: RequestBody, config?: RequestConfig) =>
-      (apiClient as any).put(path, body, config),
-
-    delete: (path: string, config?: RequestConfig) => (apiClient as any).delete(path, config),
-
-    patch: (path: string, body?: RequestBody, config?: RequestConfig) =>
-      (apiClient as any).patch(path, body, config),
-
-    head: (path: string, config?: RequestConfig) => (apiClient as any).head(path, config),
-
-    options: (path: string, config?: RequestConfig) => (apiClient as any).options(path, config),
-  } as TypedApiClient<T>;
-}

package/src/utils/index.ts

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