jiren 1.1.0 → 1.1.5

package/components/client.ts

@@ -0,0 +1,639 @@
+import { CString, toArrayBuffer, type Pointer } from "bun:ffi";
+import { lib } from "./native";
+import type {
+  RequestOptions,
+  JirenResponse,
+  JirenResponseBody,
+  WarmupUrlConfig,
+  UrlRequestOptions,
+  UrlEndpoint,
+} from "./types";
+
+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",
+};
+
+/** Options for JirenClient constructor */
+export interface JirenClientOptions<
+  T extends readonly WarmupUrlConfig[] | Record<string, string> =
+    | readonly WarmupUrlConfig[]
+    | Record<string, string>
+> {
+  /** URLs to warmup on client creation (pre-connect + handshake) */
+  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, string>
+> = T extends readonly WarmupUrlConfig[]
+  ? T[number]["key"]
+  : T extends Record<string, string>
+  ? keyof T
+  : never;
+
+/** Type-safe URL accessor - maps keys to UrlEndpoint objects */
+export type UrlAccessor<
+  T extends readonly WarmupUrlConfig[] | Record<string, string>
+> = {
+  [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<
+  T extends readonly WarmupUrlConfig[] | Record<string, string> =
+    | readonly WarmupUrlConfig[]
+    | Record<string, string>
+> {
+  private ptr: Pointer | null;
+  private urlMap: Map<string, string> = new Map();
+
+  /** Type-safe URL accessor for warmed-up URLs */
+  public readonly url: UrlAccessor<T>;
+
+  constructor(options?: JirenClientOptions<T>) {
+    this.ptr = lib.symbols.zclient_new();
+    if (!this.ptr) throw new Error("Failed to create native client instance");
+
+    // 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
+            const config = item as WarmupUrlConfig;
+            urls.push(config.url);
+            this.urlMap.set(config.key, config.url);
+          }
+        }
+      } else {
+        // Record<string, string>
+        for (const [key, url] of Object.entries(warmup)) {
+          urls.push(url as string);
+          this.urlMap.set(key, url as string);
+        }
+      }
+
+      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> => {
+            return self.request<R>("GET", buildUrl(options?.path), null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType,
+              antibot: options?.antibot,
+            });
+          },
+
+          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,
+            });
+          },
+        } as UrlEndpoint;
+      },
+    });
+  }
+
+  /**
+   * Free the native client resources.
+   * Must be called when the client is no longer needed.
+   */
+  public close(): void {
+    if (this.ptr) {
+      lib.symbols.zclient_free(this.ptr);
+      this.ptr = null;
+    }
+  }
+
+  /**
+   * Warm up connections to URLs (DNS resolve + QUIC handshake).
+   * 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 {
+    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);
+    }
+  }
+
+  /**
+   * @deprecated Use warmup() instead
+   */
+  public prefetch(urls: string[]): void {
+    this.warmup(urls);
+  }
+
+  /**
+   * Perform a generic HTTP request.
+   * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
+   * @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 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 ||
+        "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;
+        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>;
+      }
+    }
+
+    const methodBuffer = Buffer.from(method + "\0");
+    const urlBuffer = Buffer.from(url + "\0");
+
+    let bodyBuffer: Buffer | null = null;
+    if (body) {
+      bodyBuffer = Buffer.from(body + "\0");
+    }
+
+    let headersBuffer: Buffer | null = null;
+    const defaultHeaders: Record<string, string> = {
+      "user-agent":
+        "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",
+      "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 };
+
+    // 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");
+
+    if (headerStr.length > 0) {
+      headersBuffer = Buffer.from(headerStr + "\0");
+    }
+
+    const respPtr = lib.symbols.zclient_request(
+      this.ptr,
+      methodBuffer,
+      urlBuffer,
+      headersBuffer,
+      bodyBuffer,
+      maxRedirects,
+      antibot
+    );
+
+    const response = this.parseResponse<T>(respPtr, url);
+
+    // 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();
+    }
+
+    return response;
+  }
+
+  private parseResponse<T = any>(
+    respPtr: Pointer | null,
+    url: string
+  ): JirenResponse<T> {
+    if (!respPtr)
+      throw new Error("Native request failed (returned null pointer)");
+
+    try {
+      const status = lib.symbols.zclient_response_status(respPtr);
+      const len = Number(lib.symbols.zclient_response_body_len(respPtr));
+      const bodyPtr = lib.symbols.zclient_response_body(respPtr);
+
+      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) {
+        // 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,
+        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;
+  }
+}

package/components/index.ts

@@ -1,13 +1,23 @@
-import { isBun } from "./runtime.js";
+/**
+ * Jiren - Ultra-fast HTTP/3 client powered by native Zig + QUIC
+ *
+ * @packageDocumentation
+ */
 
-// Conditionally export the right client
-export const JirenClient = isBun
-  ? (await import("./client-bun.js")).JirenClient
-  : (await import("./client-node.js")).NodeJirenClient;
+// Main client
+export {
+  JirenClient,
+  type JirenClientOptions,
+  type UrlAccessor,
+} from "./client";
 
+// Types
 export type {
-  HttpResponse,
-  RequestOptions,
-  GetRequestOptions,
-  PostRequestOptions,
-} from "../types/index.js";
+  JirenHttpConfig,
+  ParsedUrl,
+  WarmupUrlConfig,
+  UrlRequestOptions,
+  UrlEndpoint,
+} from "./types";
+
+// Remove broken exports