jiren 1.2.6 → 1.2.8

package/components/client-node-native.ts

@@ -1,6 +1,7 @@
 import { nativeLib as lib } from "./native-node";
 import { ResponseCache } from "./cache";
 import koffi from "koffi";
+import zlib from "zlib";
 import type {
   RequestOptions,
   JirenResponse,
@@ -533,6 +534,34 @@ export class JirenClient<
       if (len > 0 && bodyPtr) {
         // Copy body content
         buffer = Buffer.from(koffi.decode(bodyPtr, "uint8_t", len));
+
+        // Handle GZIP compression
+        const contentEncoding = headersProxy["content-encoding"]?.toLowerCase();
+
+        // DEBUG LOGS
+        if (len > 0) {
+          console.log(`[Jiren] Body len: ${len}, Encoding: ${contentEncoding}`);
+          if (buffer.length > 2) {
+            console.log(
+              `[Jiren] Bytes: 0x${buffer[0]?.toString(
+                16
+              )} 0x${buffer[1]?.toString(16)} 0x${buffer[2]?.toString(16)}`
+            );
+          }
+        }
+
+        if (
+          contentEncoding === "gzip" ||
+          (buffer.length > 2 && buffer[0] === 0x1f && buffer[1] === 0x8b)
+        ) {
+          try {
+            console.log("[Jiren] Attempting gunzip...");
+            buffer = zlib.gunzipSync(buffer);
+            console.log("[Jiren] Gunzip success!");
+          } catch (e) {
+            console.warn("Failed to gunzip response body:", e);
+          }
+        }
       }
 
       let bodyUsed = false;

package/components/client.ts

@@ -9,6 +9,7 @@ import type {
   UrlRequestOptions,
   UrlEndpoint,
   CacheConfig,
+  RetryConfig,
 } from "./types";
 
 const STATUS_TEXT: Record<number, string> = {
@@ -40,6 +41,9 @@ export interface JirenClientOptions<
 
   /** Enable benchmark mode (Force HTTP/2, disable probing) */
   benchmark?: boolean;
+
+  /** Global retry configuration */
+  retry?: number | RetryConfig;
 }
 
 /** Helper to extract keys from Warmup Config */
@@ -93,6 +97,8 @@ export class JirenClient<
   private cacheConfig: Map<string, { enabled: boolean; ttl: number }> =
     new Map();
   private cache: ResponseCache;
+  private inflightRequests: Map<string, Promise<any>> = new Map();
+  private globalRetry?: RetryConfig;
 
   /** Type-safe URL accessor for warmed-up URLs */
   public readonly url: UrlAccessor<T>;
@@ -165,6 +171,18 @@ export class JirenClient<
 
     // Create proxy for type-safe URL access
     this.url = this.createUrlAccessor();
+
+    // Store global retry config
+    if (options?.retry) {
+      this.globalRetry =
+        typeof options.retry === "number"
+          ? { count: options.retry, delay: 100, backoff: 2 }
+          : options.retry;
+    }
+  }
+
+  private async waitFor(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   /**
@@ -206,47 +224,74 @@ export class JirenClient<
               }
             }
 
-            // 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,
-              }
-            );
+            // ** Deduplication Logic **
+            // Create a unique key for this request based on URL and critical options
+            const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(
+              options?.headers || {}
+            )}`;
 
-            // 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
-              );
+            // Check if there is already an identical request in flight
+            if (self.inflightRequests.has(dedupKey)) {
+              return self.inflightRequests.get(dedupKey);
             }
 
-            return response;
+            // Create the request promise
+            const requestPromise = (async () => {
+              try {
+                // 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;
+              } finally {
+                // Remove from inflight map when done (success or failure)
+                self.inflightRequests.delete(dedupKey);
+              }
+            })();
+
+            // Store the promise in the map
+            self.inflightRequests.set(dedupKey, requestPromise);
+
+            return requestPromise;
           },
 
           post: async <R = any>(
-            body?: string | null,
             options?: UrlRequestOptions
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            const { headers, serializedBody } = self.prepareBody(
+              options?.body,
+              options?.headers
+            );
             return self.request<R>(
               "POST",
               buildUrl(options?.path),
-              body || null,
+              serializedBody,
               {
-                headers: options?.headers,
+                headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
               }
@@ -254,15 +299,18 @@ export class JirenClient<
           },
 
           put: async <R = any>(
-            body?: string | null,
             options?: UrlRequestOptions
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            const { headers, serializedBody } = self.prepareBody(
+              options?.body,
+              options?.headers
+            );
             return self.request<R>(
               "PUT",
               buildUrl(options?.path),
-              body || null,
+              serializedBody,
               {
-                headers: options?.headers,
+                headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
               }
@@ -270,15 +318,18 @@ export class JirenClient<
           },
 
           patch: async <R = any>(
-            body?: string | null,
             options?: UrlRequestOptions
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            const { headers, serializedBody } = self.prepareBody(
+              options?.body,
+              options?.headers
+            );
             return self.request<R>(
               "PATCH",
               buildUrl(options?.path),
-              body || null,
+              serializedBody,
               {
-                headers: options?.headers,
+                headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
               }
@@ -286,15 +337,18 @@ export class JirenClient<
           },
 
           delete: async <R = any>(
-            body?: string | null,
             options?: UrlRequestOptions
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            const { headers, serializedBody } = self.prepareBody(
+              options?.body,
+              options?.headers
+            );
             return self.request<R>(
               "DELETE",
               buildUrl(options?.path),
-              body || null,
+              serializedBody,
               {
-                headers: options?.headers,
+                headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
               }
@@ -523,27 +577,74 @@ export class JirenClient<
       headersBuffer = Buffer.from(headerStr + "\0");
     }
 
-    const respPtr = lib.symbols.zclient_request(
-      this.ptr,
-      methodBuffer,
-      urlBuffer,
-      headersBuffer,
-      bodyBuffer,
-      maxRedirects,
-      antibot
-    );
+    // Determine retry configuration
+    let retryConfig = this.globalRetry;
+    // Check if options is RequestOptions (has 'retry' property and is not just a header map)
+    // We already normalized this earlier, but let's be safe.
+    // If it has 'responseType', 'method', etc., it's RequestOptions.
+    // Simpler: Just check if 'retry' is number or object.
+    if (options && typeof options === "object" && "retry" in options) {
+      const userRetry = (options as any).retry;
+      if (typeof userRetry === "number") {
+        retryConfig = { count: userRetry, delay: 100, backoff: 2 };
+      } else if (typeof userRetry === "object") {
+        retryConfig = userRetry;
+      }
+    }
 
-    const response = this.parseResponse<T>(respPtr, url);
+    let attempts = 0;
+    // Default to 1 attempt (0 retries) if no config
+    const maxAttempts = (retryConfig?.count || 0) + 1;
+    let currentDelay = retryConfig?.delay || 100;
+    const backoff = retryConfig?.backoff || 2;
+
+    let lastError: any;
+
+    while (attempts < maxAttempts) {
+      attempts++;
+      try {
+        const respPtr = lib.symbols.zclient_request(
+          this.ptr,
+          methodBuffer,
+          urlBuffer,
+          headersBuffer,
+          bodyBuffer,
+          maxRedirects,
+          antibot
+        );
+
+        if (!respPtr) {
+          throw new Error("Native request failed (returned null pointer)");
+        }
 
-    // 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();
+        const response = this.parseResponse<T>(respPtr, url);
+
+        // Optional: Retry on specific status codes (e.g., 500, 502, 503, 504)
+        // For now, we only retry on actual exceptions/network failures (null ptr)
+        // or if we decide to throw on 5xx here.
+        // Let's stick to "Network Failure" retries for now as per plan.
+
+        // 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;
+      } catch (err) {
+        lastError = err;
+        if (attempts < maxAttempts) {
+          // Wait before retrying
+          await this.waitFor(currentDelay);
+          currentDelay *= backoff;
+        }
+      }
     }
 
-    return response;
+    throw lastError || new Error("Request failed after retries");
   }
 
   private parseResponse<T = any>(
@@ -652,6 +753,35 @@ export class JirenClient<
       lib.symbols.zclient_response_free(respPtr);
     }
   }
+
+  /**
+   * Helper to prepare body and headers for requests.
+   * Handles JSON stringification and Content-Type header.
+   */
+  private prepareBody(
+    body: string | object | null | undefined,
+    userHeaders?: Record<string, string>
+  ): { headers: Record<string, string>; serializedBody: string | null } {
+    let serializedBody: string | null = null;
+    const headers = { ...userHeaders };
+
+    if (body !== null && body !== undefined) {
+      if (typeof body === "object") {
+        serializedBody = JSON.stringify(body);
+        // Add Content-Type if not present (case-insensitive check)
+        const hasContentType = Object.keys(headers).some(
+          (k) => k.toLowerCase() === "content-type"
+        );
+        if (!hasContentType) {
+          headers["Content-Type"] = "application/json";
+        }
+      } else {
+        serializedBody = String(body);
+      }
+    }
+
+    return { headers, serializedBody };
+  }
 }
 
 class NativeHeaders {

package/components/types.ts

@@ -108,18 +108,32 @@ export interface CacheConfig {
   maxSize?: number;
 }
 
+/** Configuration for automatic request retries */
+export interface RetryConfig {
+  /** Number of retry attempts (default: 0) */
+  count?: number;
+  /** Initial delay in milliseconds before first retry (default: 100) */
+  delay?: number;
+  /** Backoff multiplier for subsequent retries (2 = double delay each time) (default: 2) */
+  backoff?: number;
+}
+
 /** Options for URL endpoint requests */
 export interface UrlRequestOptions {
   /** Request headers */
   headers?: Record<string, string>;
   /** Path to append to the base URL */
   path?: string;
+  /** Request body (for POST, PUT, PATCH, DELETE) - Auto-stringifies objects */
+  body?: string | object | null;
   /** Maximum number of redirects to follow */
   maxRedirects?: number;
   /** Automatically parse response body */
   responseType?: "json" | "text" | "arraybuffer" | "blob";
   /** Enable anti-bot protection (using curl-impersonate) */
   antibot?: boolean;
+  /** Retry configuration for this request */
+  retry?: number | RetryConfig;
 }
 
 /** Interface for a URL endpoint with HTTP method helpers */
@@ -134,42 +148,26 @@ export interface UrlEndpoint {
   ): Promise<string>;
 
   /** POST request */
+  post<T = any>(options?: UrlRequestOptions): Promise<JirenResponse<T>>;
   post<T = any>(
-    body?: string | null,
-    options?: UrlRequestOptions
-  ): Promise<JirenResponse<T>>;
-  post<T = any>(
-    body?: string | null,
     options?: UrlRequestOptions & { responseType: "json" }
   ): Promise<T>;
 
   /** PUT request */
+  put<T = any>(options?: UrlRequestOptions): Promise<JirenResponse<T>>;
   put<T = any>(
-    body?: string | null,
-    options?: UrlRequestOptions
-  ): Promise<JirenResponse<T>>;
-  put<T = any>(
-    body?: string | null,
     options?: UrlRequestOptions & { responseType: "json" }
   ): Promise<T>;
 
   /** PATCH request */
+  patch<T = any>(options?: UrlRequestOptions): Promise<JirenResponse<T>>;
   patch<T = any>(
-    body?: string | null,
-    options?: UrlRequestOptions
-  ): Promise<JirenResponse<T>>;
-  patch<T = any>(
-    body?: string | null,
     options?: UrlRequestOptions & { responseType: "json" }
   ): Promise<T>;
 
   /** DELETE request */
+  delete<T = any>(options?: UrlRequestOptions): Promise<JirenResponse<T>>;
   delete<T = any>(
-    body?: string | null,
-    options?: UrlRequestOptions
-  ): Promise<JirenResponse<T>>;
-  delete<T = any>(
-    body?: string | null,
     options?: UrlRequestOptions & { responseType: "json" }
   ): Promise<T>;