jiren 1.1.1 → 1.2.0

package/components/client.ts

@@ -1,23 +1,347 @@
 import { CString, toArrayBuffer, type Pointer } from "bun:ffi";
 import { lib } from "./native";
-import type { RequestOptions } from "./types";
+import { ResponseCache } from "./cache";
+import type {
+  RequestOptions,
+  JirenResponse,
+  JirenResponseBody,
+  WarmupUrlConfig,
+  UrlRequestOptions,
+  UrlEndpoint,
+  CacheConfig,
+} from "./types";
 
-export interface JirenClientOptions {
+const STATUS_TEXT: Record<number, string> = {
+  200: "OK",
+  201: "Created",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+};
+
+/** 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 on client creation (pre-connect + handshake) */
-  warmup?: string[];
+  warmup?: string[] | T;
+
+  /** Enable benchmark mode (Force HTTP/2, disable probing) */
+  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.
+ * This eliminates the need for 'as const'.
+ *
+ * @example
+ * ```typescript
+ * const client = new JirenClient({
+ *   warmup: defineUrls([
+ *     { key: "google", url: "https://google.com" },
+ *   ])
+ * });
+ * // OR
+ * const client = new JirenClient({
+ *   warmup: {
+ *      google: "https://google.com"
+ *   }
+ * });
+ * ```
+ */
+export function defineUrls<const T extends readonly WarmupUrlConfig[]>(
+  urls: T
+): T {
+  return urls;
 }
 
-export class JirenClient {
+export class JirenClient<
+  T extends readonly WarmupUrlConfig[] | Record<string, UrlConfig> =
+    | readonly WarmupUrlConfig[]
+    | Record<string, UrlConfig>
+> {
   private ptr: Pointer | null;
+  private urlMap: Map<string, string> = new Map();
+  private cacheConfig: Map<string, { enabled: boolean; ttl: number }> =
+    new Map();
+  private cache: ResponseCache;
+
+  /** Type-safe URL accessor for warmed-up URLs */
+  public readonly url: UrlAccessor<T>;
 
-  constructor(options?: JirenClientOptions) {
+  constructor(options?: JirenClientOptions<T>) {
     this.ptr = lib.symbols.zclient_new();
     if (!this.ptr) throw new Error("Failed to create native client instance");
 
-    // Warmup connections immediately if URLs provided
-    if (options?.warmup && options.warmup.length > 0) {
-      this.warmup(options.warmup);
+    // Initialize cache
+    this.cache = new ResponseCache(100);
+
+    // Enable benchmark mode if requested
+    if (options?.benchmark) {
+      lib.symbols.zclient_set_benchmark_mode(this.ptr, true);
+    }
+
+    // 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);
+            }
+          }
+        }
+      } 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);
+            }
+          }
+        }
+      }
+
+      if (urls.length > 0) {
+        this.warmup(urls);
+      }
     }
+
+    // Create proxy for type-safe URL access
+    this.url = this.createUrlAccessor();
+  }
+
+  /**
+   * Creates a proxy-based URL accessor for type-safe access to warmed-up URLs.
+   */
+  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(", ")}`
+          );
+        }
+
+        // Helper to build full URL with optional path
+        const buildUrl = (path?: string) =>
+          path
+            ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`
+            : baseUrl;
+
+        // Return a UrlEndpoint object with all HTTP methods
+        return {
+          get: async <R = any>(
+            options?: UrlRequestOptions
+          ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            // Check if caching is enabled for this URL
+            const cacheConfig = self.cacheConfig.get(prop);
+
+            if (cacheConfig?.enabled) {
+              // Try to get from cache
+              const cached = self.cache.get(baseUrl, options?.path, options);
+              if (cached) {
+                return cached as any;
+              }
+            }
+
+            // Make the request
+            const response = await self.request<R>(
+              "GET",
+              buildUrl(options?.path),
+              null,
+              {
+                headers: options?.headers,
+                maxRedirects: options?.maxRedirects,
+                responseType: options?.responseType,
+                antibot: options?.antibot,
+              }
+            );
+
+            // Store in cache if enabled
+            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/refresh cache for this URL
+           * Clears existing cache and makes a fresh request
+           */
+          prefetch: async (options?: UrlRequestOptions): Promise<void> => {
+            // Clear cache for this URL
+            self.cache.clear(baseUrl);
+
+            // Make fresh request to populate cache
+            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;
+      },
+    });
   }
 
   /**
@@ -32,17 +356,24 @@ export class JirenClient {
   }
 
   /**
-   * Warm up connections to URLs (DNS resolve + QUIC handshake).
+   * Warm up connections to URLs (DNS resolve + QUIC handshake) in parallel.
    * Call this early (e.g., at app startup) so subsequent requests are fast.
    * @param urls - List of URLs to warm up
    */
-  public warmup(urls: string[]): void {
+  public async warmup(urls: string[]): Promise<void> {
     if (!this.ptr) throw new Error("Client is closed");
 
-    for (const url of urls) {
-      const urlBuffer = Buffer.from(url + "\0");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
-    }
+    // Warm up all URLs in parallel for faster startup
+    await Promise.all(
+      urls.map(
+        (url) =>
+          new Promise<void>((resolve) => {
+            const urlBuffer = Buffer.from(url + "\0");
+            lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
+            resolve();
+          })
+      )
+    );
   }
 
   /**
@@ -58,27 +389,67 @@ export class JirenClient {
    * @param url - The URL to request
    * @param body - The body content string (optional)
    * @param options - Request options (headers, maxRedirects, etc.) or just headers map
-   * @returns Promise resolving to Response object
+   * @returns Promise resolving to Response object or parsed body
    */
+  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> {
     if (!this.ptr) throw new Error("Client is closed");
 
     // Normalize options
     let headers: Record<string, string> = {};
     let maxRedirects = 5; // Default
+    let responseType: RequestOptions["responseType"] | undefined;
+    let antibot = false; // Default
 
     if (options) {
-      if ("maxRedirects" in options || "headers" in options) {
+      if (
+        "maxRedirects" in options ||
+        "headers" in options ||
+        "responseType" in options ||
+        "method" in options || // Check for any RequestOptions specific key
+        "timeout" in options ||
+        "antibot" in options
+      ) {
         // It is RequestOptions
         const opts = options as RequestOptions;
         if (opts.headers) headers = opts.headers;
         if (opts.maxRedirects !== undefined) maxRedirects = opts.maxRedirects;
-        // Merge top-level unknown keys as headers if lenient? No, strict to types.
+        if (opts.responseType) responseType = opts.responseType;
+        if (opts.antibot !== undefined) antibot = opts.antibot;
       } else {
         // Assume it's just headers Record<string, string> for backward compatibility
         headers = options as Record<string, string>;
@@ -99,13 +470,52 @@ export class JirenClient {
         "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
       accept:
         "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
-      "accept-encoding": "gzip, deflate, br",
+      "accept-encoding": "gzip",
       "accept-language": "en-US,en;q=0.9",
+      "sec-ch-ua":
+        '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+      "sec-ch-ua-mobile": "?0",
+      "sec-ch-ua-platform": '"macOS"',
+      "sec-fetch-dest": "document",
+      "sec-fetch-mode": "navigate",
+      "sec-fetch-site": "none",
+      "sec-fetch-user": "?1",
+      "upgrade-insecure-requests": "1",
     };
 
     const finalHeaders = { ...defaultHeaders, ...headers };
 
-    const headerStr = Object.entries(finalHeaders)
+    // Enforce Chrome header order
+    const orderedHeaders: Record<string, string> = {};
+    const keys = [
+      "sec-ch-ua",
+      "sec-ch-ua-mobile",
+      "sec-ch-ua-platform",
+      "upgrade-insecure-requests",
+      "user-agent",
+      "accept",
+      "sec-fetch-site",
+      "sec-fetch-mode",
+      "sec-fetch-user",
+      "sec-fetch-dest",
+      "accept-encoding",
+      "accept-language",
+    ];
+
+    // Add priority headers in order
+    for (const key of keys) {
+      if (finalHeaders[key]) {
+        orderedHeaders[key] = finalHeaders[key];
+        delete finalHeaders[key];
+      }
+    }
+
+    // Add remaining custom headers
+    for (const [key, value] of Object.entries(finalHeaders)) {
+      orderedHeaders[key] = value;
+    }
+
+    const headerStr = Object.entries(orderedHeaders)
       .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
       .join("\r\n");
 
@@ -119,60 +529,27 @@ export class JirenClient {
       urlBuffer,
       headersBuffer,
       bodyBuffer,
-      maxRedirects
+      maxRedirects,
+      antibot
     );
 
-    return this.parseResponse<T>(respPtr);
-  }
+    const response = this.parseResponse<T>(respPtr, url);
 
-  public async get<T = any>(
-    url: string,
-    options?: RequestOptions | Record<string, string>
-  ) {
-    return this.request<T>("GET", url, null, options);
-  }
-
-  public async post<T = any>(
-    url: string,
-    body: string,
-    options?: RequestOptions | Record<string, string>
-  ) {
-    return this.request<T>("POST", url, body, options);
-  }
-
-  public async put<T = any>(
-    url: string,
-    body: string,
-    options?: RequestOptions | Record<string, string>
-  ) {
-    return this.request<T>("PUT", url, body, options);
-  }
-
-  public async patch<T = any>(
-    url: string,
-    body: string,
-    options?: RequestOptions | Record<string, string>
-  ) {
-    return this.request<T>("PATCH", url, body, options);
-  }
-
-  public async delete<T = any>(
-    url: string,
-    body?: string,
-    options?: RequestOptions | Record<string, string>
-  ) {
-    return this.request<T>("DELETE", url, body || null, options);
-  }
-
-  public async head(url: string, headers?: Record<string, string>) {
-    return this.request("HEAD", url, null, headers);
-  }
+    // Auto-parse if requested
+    if (responseType) {
+      if (responseType === "json") return response.body.json();
+      if (responseType === "text") return response.body.text();
+      if (responseType === "arraybuffer") return response.body.arrayBuffer();
+      if (responseType === "blob") return response.body.blob();
+    }
 
-  public async options(url: string, headers?: Record<string, string>) {
-    return this.request("OPTIONS", url, null, headers);
+    return response;
   }
 
-  private parseResponse<T = any>(respPtr: Pointer | null) {
+  private parseResponse<T = any>(
+    respPtr: Pointer | null,
+    url: string
+  ): JirenResponse<T> {
     if (!respPtr)
       throw new Error("Native request failed (returned null pointer)");
 
@@ -181,20 +558,178 @@ export class JirenClient {
       const len = Number(lib.symbols.zclient_response_body_len(respPtr));
       const bodyPtr = lib.symbols.zclient_response_body(respPtr);
 
-      let bodyString = "";
+      const headersLen = Number(
+        lib.symbols.zclient_response_headers_len(respPtr)
+      );
+      let headersObj: Record<string, string> | NativeHeaders = {};
+
+      if (headersLen > 0) {
+        const rawHeadersPtr = lib.symbols.zclient_response_headers(respPtr);
+        if (rawHeadersPtr) {
+          // Copy headers to JS memory
+          // We need to copy because respPtr will be freed
+          const rawSrc = toArrayBuffer(rawHeadersPtr, 0, headersLen);
+          const raw = new Uint8Array(rawSrc.slice(0)); // Explicit copy
+
+          headersObj = new NativeHeaders(raw);
+        }
+      }
+
+      // Proxy for backward compatibility
+      const headersProxy = new Proxy(
+        headersObj instanceof NativeHeaders ? headersObj : {},
+        {
+          get(target, prop) {
+            if (target instanceof NativeHeaders && typeof prop === "string") {
+              if (prop === "toJSON") return () => target.toJSON();
+
+              // Try to get from native headers
+              const val = target.get(prop);
+              if (val !== null) return val;
+            }
+            return Reflect.get(target, prop);
+          },
+        }
+      ) as unknown as Record<string, string>; // Lie to TS
+
+      let buffer: ArrayBuffer | Buffer = new ArrayBuffer(0);
       if (len > 0 && bodyPtr) {
-        const buffer = toArrayBuffer(bodyPtr, 0, len);
-        bodyString = new TextDecoder().decode(buffer);
+        // Create a copy of the buffer because the native response is freed immediately after
+        buffer = toArrayBuffer(bodyPtr, 0, len).slice(0);
       }
 
+      let bodyUsed = false;
+      const consumeBody = () => {
+        if (bodyUsed) {
+        }
+        bodyUsed = true;
+      };
+
+      const bodyObj: JirenResponseBody<T> = {
+        bodyUsed: false,
+        arrayBuffer: async () => {
+          consumeBody();
+          if (Buffer.isBuffer(buffer)) {
+            const buf = buffer as Buffer;
+            return buf.buffer.slice(
+              buf.byteOffset,
+              buf.byteOffset + buf.byteLength
+            ) as ArrayBuffer;
+          }
+          return buffer as ArrayBuffer;
+        },
+        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);
+        },
+      };
+
+      // Update bodyUsed getter to reflect local variable
+      Object.defineProperty(bodyObj, "bodyUsed", {
+        get: () => bodyUsed,
+      });
+
       return {
+        url,
         status,
-        body: bodyString,
-        text: async () => bodyString,
-        json: async (): Promise<T> => JSON.parse(bodyString),
-      };
+        statusText: STATUS_TEXT[status] || "",
+        headers: headersProxy,
+        ok: status >= 200 && status < 300,
+        redirected: false,
+        type: "basic",
+        body: bodyObj,
+      } as JirenResponse<T>;
     } finally {
       lib.symbols.zclient_response_free(respPtr);
     }
   }
 }
+
+class NativeHeaders {
+  private raw: Uint8Array;
+  private len: number;
+  private decoder = new TextDecoder();
+  private cache = new Map<string, string>();
+  // We need a pointer to the raw buffer for FFI calls.
+  // Since we can't easily rely on ptr(this.raw) being stable if we stored it,
+  // we will pass this.raw to the FFI call directly each time.
+
+  constructor(raw: Uint8Array) {
+    this.raw = raw;
+    this.len = raw.byteLength;
+  }
+
+  get(name: string): string | null {
+    const target = name.toLowerCase();
+    if (this.cache.has(target)) return this.cache.get(target)!;
+
+    const keyBuf = Buffer.from(target + "\0");
+
+    // Debug log
+    // Pass the raw buffer directly. Bun handles the pointer.
+    const resPtr = lib.symbols.z_find_header_value(
+      this.raw as any,
+      this.len,
+      keyBuf
+    );
+
+    if (!resPtr) return null;
+
+    try {
+      // ZHeaderValue: { value_ptr: pointer, value_len: size_t }
+      // Assuming 64-bit architecture, pointers and size_t are 8 bytes.
+      // Struct size = 16 bytes.
+      const view = new DataView(toArrayBuffer(resPtr, 0, 16));
+      const valPtr = view.getBigUint64(0, true);
+      const valLen = Number(view.getBigUint64(8, true));
+
+      if (valLen === 0) {
+        this.cache.set(target, "");
+        return "";
+      }
+
+      // Convert valPtr to ArrayBuffer
+      // Note: valPtr points inside this.raw, but toArrayBuffer(ptr) creates a view on that memory.
+      const valBytes = toArrayBuffer(Number(valPtr) as any, 0, valLen);
+      const val = this.decoder.decode(valBytes);
+
+      this.cache.set(target, val);
+      return val;
+    } finally {
+      lib.symbols.zclient_header_value_free(resPtr);
+    }
+  }
+
+  // Fallback for when full object is needed (e.g. debugging)
+  // This is expensive as it reparses everything using the old offset method
+  // BUT we don't have the offset method easily available on the raw buffer unless we expose a new one?
+  // Wait, `zclient_response_parse_header_offsets` takes `Response*`.
+  // We don't have Response* anymore.
+  // We need `z_parse_header_offsets_from_raw(ptr, len)`.
+  // Or just parse in JS since we have the full buffer?
+  // Actually, we can just do a JS parser since we have the buffer.
+  // It's a fallback anyway.
+  toJSON(): Record<string, string> {
+    const obj: Record<string, string> = {};
+    const text = this.decoder.decode(this.raw);
+    const lines = text.split("\r\n");
+    for (const line of lines) {
+      if (!line) continue;
+      const colon = line.indexOf(":");
+      if (colon === -1) continue;
+      const key = line.substring(0, colon).trim().toLowerCase();
+      const val = line.substring(colon + 1).trim();
+      obj[key] = val;
+    }
+    return obj;
+  }
+}