jiren 1.4.5 → 1.5.5

package/components/client-node.ts

@@ -1,473 +0,0 @@
-import { ResponseCache } from "./cache";
-import type {
-  RequestOptions,
-  JirenResponse,
-  JirenResponseBody,
-  WarmupUrlConfig,
-  UrlRequestOptions,
-  UrlEndpoint,
-  CacheConfig,
-} from "./types";
-
-/** URL configuration with optional cache */
-export type UrlConfig = string | { url: string; cache?: boolean | CacheConfig };
-
-/** Options for JirenClient constructor */
-export interface JirenClientOptions<
-  T extends readonly WarmupUrlConfig[] | Record<string, UrlConfig> =
-    | readonly WarmupUrlConfig[]
-    | Record<string, UrlConfig>
-> {
-  /** URLs to warmup (pre-connect) */
-  warmup?: string[] | T;
-
-  /** Benchmark mode (Ignored in Node.js fallback) */
-  benchmark?: boolean;
-}
-
-/** Helper to extract keys from Warmup Config */
-export type ExtractWarmupKeys<
-  T extends readonly WarmupUrlConfig[] | Record<string, UrlConfig>
-> = T extends readonly WarmupUrlConfig[]
-  ? T[number]["key"]
-  : T extends Record<string, UrlConfig>
-  ? keyof T
-  : never;
-
-/** Type-safe URL accessor - maps keys to UrlEndpoint objects */
-export type UrlAccessor<
-  T extends readonly WarmupUrlConfig[] | Record<string, UrlConfig>
-> = {
-  [K in ExtractWarmupKeys<T>]: UrlEndpoint;
-};
-
-/**
- * Helper function to define warmup URLs with type inference.
- */
-export function defineUrls<const T extends readonly WarmupUrlConfig[]>(
-  urls: T
-): T {
-  return urls;
-}
-
-export class JirenClient<
-  T extends readonly WarmupUrlConfig[] | Record<string, UrlConfig> =
-    | readonly WarmupUrlConfig[]
-    | Record<string, UrlConfig>
-> {
-  private urlMap: Map<string, string> = new Map();
-  private cacheConfig: Map<string, { enabled: boolean; ttl: number }> =
-    new Map();
-  private antibotConfig: Map<string, boolean> = new Map();
-  private cache: ResponseCache;
-
-  /** Type-safe URL accessor for warmed-up URLs */
-  public readonly url: UrlAccessor<T>;
-
-  constructor(options?: JirenClientOptions<T>) {
-    // Initialize cache
-    this.cache = new ResponseCache(100);
-
-    // Process warmup URLs
-    if (options?.warmup) {
-      const urls: string[] = [];
-      const warmup = options.warmup;
-
-      if (Array.isArray(warmup)) {
-        for (const item of warmup) {
-          if (typeof item === "string") {
-            urls.push(item);
-          } else {
-            // WarmupUrlConfig with key and optional cache
-            const config = item as WarmupUrlConfig;
-            urls.push(config.url);
-            this.urlMap.set(config.key, config.url);
-
-            // Store cache config
-            if (config.cache) {
-              const cacheConfig =
-                typeof config.cache === "boolean"
-                  ? { enabled: true, ttl: 60000 }
-                  : { enabled: true, ttl: config.cache.ttl || 60000 };
-              this.cacheConfig.set(config.key, cacheConfig);
-            }
-
-            // Store antibot config
-            if (config.antibot) {
-              this.antibotConfig.set(config.key, true);
-            }
-          }
-        }
-      } else {
-        // Record<string, UrlConfig>
-        for (const [key, urlConfig] of Object.entries(warmup)) {
-          if (typeof urlConfig === "string") {
-            // Simple string URL
-            urls.push(urlConfig);
-            this.urlMap.set(key, urlConfig);
-          } else {
-            // URL config object with cache
-            urls.push(urlConfig.url);
-            this.urlMap.set(key, urlConfig.url);
-
-            // Store cache config
-            if (urlConfig.cache) {
-              const cacheConfig =
-                typeof urlConfig.cache === "boolean"
-                  ? { enabled: true, ttl: 60000 }
-                  : { enabled: true, ttl: urlConfig.cache.ttl || 60000 };
-              this.cacheConfig.set(key, cacheConfig);
-            }
-
-            // Store antibot config
-            if ((urlConfig as { antibot?: boolean }).antibot) {
-              this.antibotConfig.set(key, true);
-            }
-          }
-        }
-      }
-
-      if (urls.length > 0) {
-        this.warmup(urls);
-      }
-
-      // Preload L2 disk cache entries into L1 memory for cached endpoints
-      // This ensures user's first request hits L1 (~0.001ms) instead of L2 (~5ms)
-      for (const [key, config] of this.cacheConfig.entries()) {
-        if (config.enabled) {
-          const url = this.urlMap.get(key);
-          if (url) {
-            this.cache.preloadL1(url);
-          }
-        }
-      }
-    }
-
-    // Create proxy for type-safe URL access
-    this.url = this.createUrlAccessor();
-  }
-
-  /**
-   * Wait for warmup to complete (no-op for fetch client)
-   */
-  public async waitForWarmup(): Promise<void> {
-    // No-op - fetch client warmup is fire-and-forget
-  }
-
-  /**
-   * Creates a proxy-based URL accessor for type-safe access.
-   */
-  private createUrlAccessor(): UrlAccessor<T> {
-    const self = this;
-
-    return new Proxy({} as UrlAccessor<T>, {
-      get(_target, prop: string) {
-        const baseUrl = self.urlMap.get(prop);
-        if (!baseUrl) {
-          throw new Error(
-            `URL key "${prop}" not found. Available keys: ${Array.from(
-              self.urlMap.keys()
-            ).join(", ")}`
-          );
-        }
-
-        const buildUrl = (path?: string) =>
-          path
-            ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`
-            : baseUrl;
-
-        return {
-          get: async <R = any>(
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
-            const cacheConfig = self.cacheConfig.get(prop);
-
-            // Check if antibot is enabled for this URL (from warmup config or per-request)
-            const useAntibot =
-              options?.antibot ?? self.antibotConfig.get(prop) ?? false;
-
-            if (cacheConfig?.enabled) {
-              const cached = self.cache.get(baseUrl, options?.path, options);
-              if (cached) return cached as any;
-            }
-
-            const response = await self.request<R>(
-              "GET",
-              buildUrl(options?.path),
-              null,
-              {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                responseType: options?.responseType,
-                antibot: useAntibot,
-              }
-            );
-
-            if (
-              cacheConfig?.enabled &&
-              typeof response === "object" &&
-              "status" in response
-            ) {
-              self.cache.set(
-                baseUrl,
-                response as JirenResponse,
-                cacheConfig.ttl,
-                options?.path,
-                options
-              );
-            }
-
-            return response;
-          },
-
-          post: async <R = any>(
-            body?: string | null,
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
-            return self.request<R>(
-              "POST",
-              buildUrl(options?.path),
-              body || null,
-              {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                responseType: options?.responseType,
-              }
-            );
-          },
-
-          put: async <R = any>(
-            body?: string | null,
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
-            return self.request<R>(
-              "PUT",
-              buildUrl(options?.path),
-              body || null,
-              {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                responseType: options?.responseType,
-              }
-            );
-          },
-
-          patch: async <R = any>(
-            body?: string | null,
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
-            return self.request<R>(
-              "PATCH",
-              buildUrl(options?.path),
-              body || null,
-              {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                responseType: options?.responseType,
-              }
-            );
-          },
-
-          delete: async <R = any>(
-            body?: string | null,
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
-            return self.request<R>(
-              "DELETE",
-              buildUrl(options?.path),
-              body || null,
-              {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                responseType: options?.responseType,
-              }
-            );
-          },
-
-          head: async (
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<any>> => {
-            return self.request("HEAD", buildUrl(options?.path), null, {
-              headers: options?.headers,
-              maxRedirects: options?.maxRedirects,
-              antibot: options?.antibot,
-            });
-          },
-
-          options: async (
-            options?: UrlRequestOptions
-          ): Promise<JirenResponse<any>> => {
-            return self.request("OPTIONS", buildUrl(options?.path), null, {
-              headers: options?.headers,
-              maxRedirects: options?.maxRedirects,
-              antibot: options?.antibot,
-            });
-          },
-
-          prefetch: async (options?: UrlRequestOptions): Promise<void> => {
-            self.cache.clear(baseUrl);
-            const cacheConfig = self.cacheConfig.get(prop);
-            if (cacheConfig?.enabled) {
-              await self.request("GET", buildUrl(options?.path), null, {
-                headers: options?.headers,
-                maxRedirects: options?.maxRedirects,
-                antibot: options?.antibot,
-              });
-            }
-          },
-        } as UrlEndpoint;
-      },
-    });
-  }
-
-  public close(): void {
-    // No-op for fetch client
-  }
-
-  public async warmup(urls: string[]): Promise<void> {
-    // Basic prefetch for Node.js fallback (HEAD request)
-    await Promise.allSettled(
-      urls.map((url) =>
-        fetch(url, { method: "HEAD", signal: AbortSignal.timeout(2000) }).catch(
-          () => {}
-        )
-      )
-    );
-  }
-
-  /**
-   * @deprecated Use warmup() instead
-   */
-  public prefetch(urls: string[]): void {
-    this.warmup(urls);
-  }
-
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions & { responseType: "json" }
-  ): Promise<T>;
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions & { responseType: "text" }
-  ): Promise<string>;
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions & { responseType: "arraybuffer" }
-  ): Promise<ArrayBuffer>;
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions & { responseType: "blob" }
-  ): Promise<Blob>;
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions
-  ): Promise<JirenResponse<T>>;
-  public async request<T = any>(
-    method: string,
-    url: string,
-    body?: string | null,
-    options?: RequestOptions | Record<string, string> | null
-  ): Promise<JirenResponse<T> | T | string | ArrayBuffer | Blob> {
-    // Normalize options
-    let headers: Record<string, string> = {};
-    let responseType: RequestOptions["responseType"] | undefined;
-
-    if (options) {
-      if (
-        "maxRedirects" in options ||
-        "headers" in options ||
-        "responseType" in options ||
-        "method" in options ||
-        "timeout" in options ||
-        "antibot" in options
-      ) {
-        const opts = options as RequestOptions;
-        if (opts.headers) headers = opts.headers;
-        if (opts.responseType) responseType = opts.responseType;
-      } else {
-        headers = options as Record<string, string>;
-      }
-    }
-
-    const fetchOptions: RequestInit = {
-      method,
-      headers: headers,
-      body: body || undefined,
-      redirect: "follow", // Native client follows redirects
-    };
-
-    const response = await fetch(url, fetchOptions);
-
-    // Auto-parse if requested
-    if (responseType) {
-      if (responseType === "json") return response.json() as Promise<T>;
-      if (responseType === "text") return response.text();
-      if (responseType === "arraybuffer") return response.arrayBuffer();
-      if (responseType === "blob") return response.blob();
-    }
-
-    // Construct JirenResponse
-    const responseHeaders: Record<string, string> = {};
-    response.headers.forEach((val, key) => {
-      responseHeaders[key] = val;
-    });
-
-    // Create a clone for each reading method to avoid "body used" error if user reads multiple times
-    // However, fetch body can only be read once. We replicate the behavior of the native client
-    // where we can read it. To do that we might need to buffer it OR just expose the raw response.
-    // The native client implementation buffers the whole body. Let's match that.
-
-    const buffer = await response.arrayBuffer();
-
-    let bodyUsed = false;
-    const consumeBody = () => {
-      bodyUsed = true;
-    };
-
-    const bodyObj: JirenResponseBody<T> = {
-      bodyUsed: false,
-      arrayBuffer: async () => {
-        consumeBody();
-        return buffer.slice(0);
-      },
-      blob: async () => {
-        consumeBody();
-        return new Blob([buffer]);
-      },
-      text: async () => {
-        consumeBody();
-        return new TextDecoder().decode(buffer);
-      },
-      json: async <R = T>(): Promise<R> => {
-        consumeBody();
-        const text = new TextDecoder().decode(buffer);
-        return JSON.parse(text);
-      },
-    };
-
-    Object.defineProperty(bodyObj, "bodyUsed", {
-      get: () => bodyUsed,
-    });
-
-    return {
-      url: response.url,
-      status: response.status,
-      statusText: response.statusText,
-      headers: responseHeaders,
-      ok: response.ok,
-      redirected: response.redirected,
-      type: response.type,
-      body: bodyObj,
-    } as JirenResponse<T>;
-  }
-}