jiren 3.1.0 → 3.2.0

package/components/client-node-native.ts

@@ -43,7 +43,7 @@ const STATUS_TEXT: Record<number, string> = {
 };
 
 export function defineUrls<const T extends readonly TargetUrlConfig[]>(
-  urls: T
+  urls: T,
 ): T {
   return urls;
 }
@@ -59,9 +59,8 @@ const clientRegistry = new FinalizationRegistry<any>((ptr) => {
 export class JirenClient<
   T extends readonly TargetUrlConfig[] | Record<string, UrlConfig> =
     | readonly TargetUrlConfig[]
-    | Record<string, UrlConfig>
-> implements Disposable
-{
+    | Record<string, UrlConfig>,
+> implements Disposable {
   private ptr: any = null; // Koffi pointer
   private urlMap: Map<string, string> = new Map();
   private cacheConfig: Map<string, { enabled: boolean; ttl: number }> =
@@ -101,7 +100,6 @@ export class JirenClient<
   /** Type-safe URL accessor for warmed-up URLs */
   public readonly url: UrlAccessor<T>;
   /** Alias for url property */
-  public readonly targets: UrlAccessor<T>;
 
   private metricsCollector: MetricsCollector;
   public readonly metrics: MetricsAPI;
@@ -150,7 +148,7 @@ export class JirenClient<
     }
 
     // Process target URLs
-    const targets = options?.urls ?? (options as any)?.targets;
+    const targets = options?.urls;
     if (targets) {
       const urls: string[] = [];
 
@@ -179,7 +177,7 @@ export class JirenClient<
       } else {
         for (const [key, urlConfig] of Object.entries(targets) as [
           string,
-          UrlConfig
+          UrlConfig,
         ][]) {
           if (typeof urlConfig === "string") {
             urls.push(urlConfig);
@@ -203,7 +201,7 @@ export class JirenClient<
         }
       }
 
-      if (urls.length > 0 && (options as any)?.preconnect !== false) {
+      if (urls.length > 0 && options?.preconnect !== false) {
         this.targetsPromise = this.preconnect(urls).then(() => {
           urls.forEach((url) => this.targetsComplete.add(url));
           this.targetsPromise = null;
@@ -223,8 +221,6 @@ export class JirenClient<
 
     // Create proxy for type-safe URL access
     this.url = this.createUrlAccessor();
-    // Alias for targets
-    this.targets = this.url;
 
     // Store global retry config
     if (options?.retry) {
@@ -263,8 +259,8 @@ export class JirenClient<
         if (!baseUrl) {
           throw new Error(
             `URL key "${prop}" not found. Available keys: ${Array.from(
-              self.urlMap.keys()
-            ).join(", ")}`
+              self.urlMap.keys(),
+            ).join(", ")}`,
           );
         }
 
@@ -275,7 +271,7 @@ export class JirenClient<
 
         return {
           get: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             if (self.targetsPromise) {
               await self.targetsPromise;
@@ -330,7 +326,7 @@ export class JirenClient<
 
             // Deduplication
             const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(
-              options?.headers || {}
+              options?.headers || {},
             )}`;
 
             if (self.inflightRequests.has(dedupKey)) {
@@ -369,7 +365,7 @@ export class JirenClient<
                     responseType: options?.responseType,
                     antibot: useAntibot,
                     timeout: options?.timeout,
-                  }
+                  },
                 );
 
                 if (
@@ -382,7 +378,7 @@ export class JirenClient<
                     response as JirenResponse,
                     cacheConfig.ttl,
                     options?.path,
-                    options
+                    options,
                   );
                 }
 
@@ -440,7 +436,7 @@ export class JirenClient<
 
           post: async <R = any>(
             body?: any,
-            options?: UrlRequestOptions & { responseType?: "json" }
+            options?: UrlRequestOptions & { responseType?: "json" },
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers: preparedHeaders, serializedBody } =
               self.prepareBody(body, options?.headers);
@@ -454,13 +450,13 @@ export class JirenClient<
                 responseType: options?.responseType,
                 antibot: options?.antibot,
                 timeout: options?.timeout,
-              }
+              },
             );
           },
 
           put: async <R = any>(
             body?: any,
-            options?: UrlRequestOptions & { responseType?: "json" }
+            options?: UrlRequestOptions & { responseType?: "json" },
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers: preparedHeaders, serializedBody } =
               self.prepareBody(body, options?.headers);
@@ -474,13 +470,13 @@ export class JirenClient<
                 responseType: options?.responseType,
                 antibot: options?.antibot,
                 timeout: options?.timeout,
-              }
+              },
             );
           },
 
           patch: async <R = any>(
             body?: any,
-            options?: UrlRequestOptions & { responseType?: "json" }
+            options?: UrlRequestOptions & { responseType?: "json" },
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers: preparedHeaders, serializedBody } =
               self.prepareBody(body, options?.headers);
@@ -494,12 +490,12 @@ export class JirenClient<
                 responseType: options?.responseType,
                 antibot: options?.antibot,
                 timeout: options?.timeout,
-              }
+              },
             );
           },
 
           delete: async <R = any>(
-            options?: UrlRequestOptions & { responseType?: "json" }
+            options?: UrlRequestOptions & { responseType?: "json" },
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers: preparedHeaders, serializedBody } =
               self.prepareBody(options?.body, options?.headers);
@@ -513,12 +509,12 @@ export class JirenClient<
                 responseType: options?.responseType,
                 antibot: options?.antibot,
                 timeout: options?.timeout,
-              }
+              },
             );
           },
 
           head: async (
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<any>> => {
             return self._request("HEAD", buildUrl(options?.path), null, {
               headers: options?.headers,
@@ -529,7 +525,7 @@ export class JirenClient<
           },
 
           options: async (
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<any>> => {
             return self._request("OPTIONS", buildUrl(options?.path), null, {
               headers: options?.headers,
@@ -540,7 +536,7 @@ export class JirenClient<
           },
 
           trace: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             // Trace method
             return self._request<R>("TRACE", buildUrl(options?.path), null, {
@@ -565,31 +561,6 @@ export class JirenClient<
             }
           },
 
-          getJsonFields: async <T extends Record<string, any>>(
-            fields: (keyof T)[],
-            options?: UrlRequestOptions
-          ): Promise<Partial<T>> => {
-            const { headers: preparedHeaders } = self.prepareBody(
-              options?.body,
-              options?.headers
-            );
-
-            const response = (await self._request<any>(
-              "GET",
-              buildUrl(options?.path),
-              null,
-              {
-                headers: preparedHeaders,
-                maxRedirects: options?.maxRedirects,
-                antibot: options?.antibot,
-                timeout: options?.timeout,
-                retry: options?.retry ?? self.globalRetry,
-              }
-            )) as JirenResponse<any>;
-
-            return response.body.jsonFields(fields);
-          },
-
           /**
            * Download with progress tracking
            * Note: For Node.js, HTTPS uses fetch-based streaming. HTTP uses native streaming.
@@ -602,7 +573,7 @@ export class JirenClient<
            * });
            */
           download: async <R = any>(
-            options?: ProgressRequestOptions
+            options?: ProgressRequestOptions,
           ): Promise<JirenResponse<R>> => {
             const url = buildUrl(options?.path);
 
@@ -617,132 +588,34 @@ export class JirenClient<
             const isHttps = url.startsWith("https://");
 
             if (isHttps) {
-              // Use Node.js fetch with streaming
-              const fetchOptions: RequestInit = {
-                method: "GET",
+              // HTTPS: Fall back to buffered request with simulated progress
+              // (Native streaming for HTTPS requires more work on HTTP/2 layer)
+              const response = await self._request<R>("GET", url, null, {
                 headers: options?.headers,
-              };
-
-              const response = await fetch(url, fetchOptions);
-              const contentLength = parseInt(
-                response.headers.get("content-length") || "0",
-                10
-              );
-              const reader = response.body?.getReader();
-
-              if (!reader) {
-                throw new Error("Failed to get response reader");
-              }
-
-              const chunks: Uint8Array[] = [];
-              let loaded = 0;
-              const startTime = performance.now();
-              let lastLoaded = 0;
-              let lastTime = startTime;
-
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-
-                chunks.push(value);
-                loaded += value.length;
-
-                // Calculate progress
-                const now = performance.now();
-                const elapsed = now - lastTime;
-                const bytesThisInterval = loaded - lastLoaded;
-                const speed =
-                  elapsed > 0 ? (bytesThisInterval / elapsed) * 1000 : 0;
-                const remaining =
-                  contentLength > 0 ? contentLength - loaded : 0;
-                const eta = speed > 0 ? (remaining / speed) * 1000 : 0;
-
-                options.onDownloadProgress({
-                  loaded,
-                  total: contentLength,
-                  percent:
-                    contentLength > 0
-                      ? Math.round((loaded / contentLength) * 100)
-                      : 0,
-                  speed: Math.round(speed),
-                  eta: Math.round(eta),
-                });
-
-                lastLoaded = loaded;
-                lastTime = now;
-              }
+              });
 
-              // Final progress
+              // Fire final progress event
+              const bodyText = await response.body.text();
+              const bodySize = Buffer.byteLength(bodyText);
               options.onDownloadProgress({
-                loaded,
-                total: contentLength || loaded,
+                loaded: bodySize,
+                total: bodySize,
                 percent: 100,
                 speed: 0,
                 eta: 0,
               });
 
-              // Combine chunks
-              const totalLength = chunks.reduce(
-                (acc, chunk) => acc + chunk.length,
-                0
-              );
-              const buffer = new Uint8Array(totalLength);
-              let offset = 0;
-              for (const chunk of chunks) {
-                buffer.set(chunk, offset);
-                offset += chunk.length;
-              }
-
-              // Parse headers
-              const headersObj: Record<string, string> = {};
-              response.headers.forEach((value, key) => {
-                headersObj[key.toLowerCase()] = value;
-              });
-
-              // Build response
-              const decoder = new TextDecoder();
-              let bodyUsed = false;
-
-              const bodyObj: JirenResponseBody<R> = {
-                bodyUsed: false,
-                arrayBuffer: async () => buffer.buffer as ArrayBuffer,
-                blob: async () => new Blob([buffer]),
-                text: async () => {
-                  bodyUsed = true;
-                  return decoder.decode(buffer);
-                },
-                json: async <T = R>(): Promise<T> => {
-                  bodyUsed = true;
-                  return JSON.parse(decoder.decode(buffer));
-                },
-                jsonFields: async <T extends Record<string, any> = any>(
-                  fields: (keyof T)[]
-                ): Promise<Partial<T>> => {
-                  bodyUsed = true;
-                  const fullObj = JSON.parse(decoder.decode(buffer));
-                  const result: Partial<T> = {};
-                  for (const field of fields) {
-                    if (field in fullObj) {
-                      result[field] = fullObj[field];
-                    }
-                  }
-                  return result;
-                },
-              };
-
-              Object.defineProperty(bodyObj, "bodyUsed", {
-                get: () => bodyUsed,
-              });
-
+              // Recreate response with body
               return {
-                url,
-                status: response.status,
-                statusText: response.statusText,
-                headers: headersObj,
-                ok: response.ok,
-                redirected: response.redirected,
-                type: "basic",
-                body: bodyObj,
+                ...response,
+                body: {
+                  ...response.body,
+                  text: async () => bodyText,
+                  json: async () => JSON.parse(bodyText),
+                  arrayBuffer: async () => Buffer.from(bodyText).buffer,
+                  blob: async () => new Blob([bodyText]),
+                  bodyUsed: true,
+                },
               } as JirenResponse<R>;
             }
 
@@ -770,40 +643,14 @@ export class JirenClient<
                 arrayBuffer: async () => Buffer.from(bodyText).buffer,
                 blob: async () => new Blob([bodyText]),
                 bodyUsed: true,
-                jsonFields: async <T extends Record<string, any> = any>(
-                  fields: (keyof T)[]
-                ): Promise<Partial<T>> => {
-                  const fullObj = JSON.parse(bodyText);
-                  const result: Partial<T> = {};
-                  for (const field of fields) {
-                    if (field in fullObj) {
-                      result[field] = fullObj[field];
-                    }
-                  }
-                  return result;
-                },
               },
             } as JirenResponse<R>;
           },
-
-          /**
-           * Upload with progress tracking
-           * @param options - Request options with onUploadProgress callback
-           * @example
-           * await client.url.api.upload({
-           *   method: 'POST',
-           *   path: '/upload',
-           *   body: largeData,
-           *   onUploadProgress: (progress) => {
-           *     console.log(`${progress.percent}%`);
-           *   }
-           * });
-           */
           upload: async <R = any>(
             options?: ProgressRequestOptions & {
               method?: "POST" | "PUT" | "PATCH";
               body?: string | object | null;
-            }
+            },
           ): Promise<JirenResponse<R>> => {
             const url = buildUrl(options?.path);
             const method = options?.method || "POST";
@@ -841,86 +688,110 @@ export class JirenClient<
             });
 
             // Prepare headers
-            const { headers: preparedHeaders } = self.prepareBody(
-              options.body,
-              options.headers
-            );
+            // HTTPS: Use fast path with simulated progress
+            // (Native layer handles the upload in one call)
+            const { headers: preparedHeaders, serializedBody } =
+              self.prepareBody(options.body, options.headers);
 
-            // For Node.js, use fetch with manual progress tracking
-            // Since fetch doesn't support upload progress natively, we simulate it
-            const response = await fetch(url, {
+            const response = await self._request<R>(
               method,
-              headers: preparedHeaders,
-              body: bodyStr,
-            });
+              url,
+              serializedBody,
+              {
+                headers: preparedHeaders,
+              },
+            );
 
-            // Fire final progress (100%)
-            const elapsed = performance.now() - startTime;
-            const speed = elapsed > 0 ? (bodyLength / elapsed) * 1000 : 0;
+            // Fire final progress event (100%)
             options.onUploadProgress({
               loaded: bodyLength,
               total: bodyLength,
               percent: 100,
-              speed: Math.round(speed),
+              speed: 0,
               eta: 0,
             });
 
-            // Parse response
-            const headersObj: Record<string, string> = {};
-            response.headers.forEach((value, key) => {
-              headersObj[key.toLowerCase()] = value;
-            });
+            return response;
+          },
+          getJsonFields: async <R = any>(
+            fields: string[],
+            options?: UrlRequestOptions,
+          ): Promise<R> => {
+            if (fields.length > 8) {
+              throw new Error("Maximum 8 fields supported per call");
+            }
 
-            const responseBody = await response.text();
-            let bodyUsed = false;
+            const url = buildUrl(options?.path);
 
-            const bodyObj: JirenResponseBody<R> = {
-              bodyUsed: false,
-              text: async () => {
-                bodyUsed = true;
-                return responseBody;
-              },
-              json: async <T = R>(): Promise<T> => {
-                bodyUsed = true;
-                return JSON.parse(responseBody);
-              },
-              jsonFields: async <T extends Record<string, any> = any>(
-                fields: (keyof T)[]
-              ): Promise<Partial<T>> => {
-                bodyUsed = true;
-                const fullObj = JSON.parse(responseBody);
-                const result: Partial<T> = {};
-                for (const field of fields) {
-                  if (field in fullObj) {
-                    result[field] = fullObj[field];
-                  }
-                }
-                return result;
-              },
-              arrayBuffer: async () => {
-                bodyUsed = true;
-                return Buffer.from(responseBody).buffer as ArrayBuffer;
-              },
-              blob: async () => {
-                bodyUsed = true;
-                return new Blob([responseBody]);
-              },
-            };
+            let resultPtr: any = null;
 
-            Object.defineProperty(bodyObj, "bodyUsed", {
-              get: () => bodyUsed,
-            });
+            if (options?.headers || options?.body) {
+              const { headers, serializedBody } = self.prepareBody(
+                options.body,
+                options.headers,
+              );
+              const headersStr = Object.entries({
+                ...self.defaultHeaders,
+                ...headers,
+              })
+                .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+                .join("\r\n");
+
+              resultPtr = lib.symbols.zclient_request_json_fields(
+                self.ptr,
+                "GET", // Default to GET
+                url,
+                headersStr,
+                serializedBody,
+                fields,
+                fields.length,
+              );
+            } else {
+              resultPtr = lib.symbols.zclient_get_json_fields(
+                self.ptr,
+                url,
+                fields,
+                fields.length,
+              );
+            }
 
-            return {
-              url,
-              status: response.status,
-              statusText: response.statusText,
-              headers: headersObj,
-              ok: response.ok,
-              redirected: response.redirected,
-              type: "basic",
-              body: bodyObj,
-            } as JirenResponse<R>;
+            if (!resultPtr) {
+              throw new Error("Native getJsonFields failed");
+            }
+
+            try {
+              const result: any = {};
+              const decoder = new TextDecoder();
+
+              for (let i = 0; i < fields.length; i++) {
+                const key = fields[i]!;
+                const type = lib.symbols.zjson_field_type(resultPtr, i);
+
+                if (type === 0) {
+                  result[key] = null;
+                } else if (type === 1) {
+                  const len = Number(lib.symbols.zjson_field_len(resultPtr, i));
+                  result[key] = len === 1;
+                } else if (type === 2) {
+                  const len = Number(lib.symbols.zjson_field_len(resultPtr, i));
+                  result[key] = len;
+                } else if (type === 3) {
+                  const ptrVal = lib.symbols.zjson_field_str(resultPtr, i);
+                  const lenVal = Number(
+                    lib.symbols.zjson_field_len(resultPtr, i),
+                  );
+                  if (ptrVal && lenVal > 0) {
+                    const bytes = koffi.decode(ptrVal, "uint8_t", lenVal);
+                    result[key] = decoder.decode(bytes);
+                  } else {
+                    result[key] = "";
+                  }
+                }
+              }
+              return result as R;
+            } finally {
+              lib.symbols.zclient_json_fields_free(resultPtr);
+            }
           },
         } as UrlEndpoint;
       },
@@ -960,8 +831,8 @@ export class JirenClient<
           new Promise<void>((resolve) => {
             lib.symbols.zclient_prefetch(this.ptr, url);
             resolve();
-          })
-      )
+          }),
+      ),
     );
   }
 
@@ -977,37 +848,37 @@ export class JirenClient<
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "json" }
+    options?: RequestOptions & { responseType: "json" },
   ): Promise<T>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "text" }
+    options?: RequestOptions & { responseType: "text" },
   ): Promise<string>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "arraybuffer" }
+    options?: RequestOptions & { responseType: "arraybuffer" },
   ): Promise<ArrayBuffer>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "blob" }
+    options?: RequestOptions & { responseType: "blob" },
   ): Promise<Blob>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<JirenResponse<T>>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions | Record<string, string> | null
+    options?: RequestOptions | Record<string, string> | null,
   ): Promise<JirenResponse<T> | T | string | ArrayBuffer | Blob> {
     if (!this.ptr) throw new Error("Client is closed");
 
@@ -1095,7 +966,7 @@ export class JirenClient<
     // Retry logic
     let retryConfig = this.globalRetry;
     if (options && typeof options === "object" && "retry" in options) {
-      const userRetry = (options as any).retry;
+      const userRetry = options?.retry;
       if (typeof userRetry === "number") {
         retryConfig = { count: userRetry, delay: 100, backoff: 2 };
       } else if (typeof userRetry === "object") {
@@ -1123,7 +994,7 @@ export class JirenClient<
             headerStr.length > 0 ? headerStr : null,
             body || null,
             maxRedirects,
-            antibot
+            antibot,
           );
 
           if (!respPtr) {
@@ -1203,7 +1074,7 @@ export class JirenClient<
       const bodyPtr = lib.symbols.zclient_response_body(respPtr);
 
       const headersLen = Number(
-        lib.symbols.zclient_response_headers_len(respPtr)
+        lib.symbols.zclient_response_headers_len(respPtr),
       );
       let headersObj: Record<string, string> | NativeHeaders = {};
 
@@ -1211,7 +1082,7 @@ export class JirenClient<
         const rawHeadersPtr = lib.symbols.zclient_response_headers(respPtr);
         if (rawHeadersPtr) {
           const raw = Buffer.from(
-            koffi.decode(rawHeadersPtr, "uint8_t", headersLen)
+            koffi.decode(rawHeadersPtr, "uint8_t", headersLen),
           );
           headersObj = new NativeHeaders(raw);
         }
@@ -1228,7 +1099,7 @@ export class JirenClient<
             }
             return Reflect.get(target, prop);
           },
-        }
+        },
       ) as unknown as Record<string, string>;
 
       let buffer: Buffer = Buffer.alloc(0);
@@ -1267,7 +1138,7 @@ export class JirenClient<
           consumeBody();
           return buffer.buffer.slice(
             buffer.byteOffset,
-            buffer.byteOffset + buffer.byteLength
+            buffer.byteOffset + buffer.byteLength,
           ) as ArrayBuffer;
         },
         blob: async () => {
@@ -1282,19 +1153,6 @@ export class JirenClient<
           consumeBody();
           return JSON.parse(buffer.toString("utf-8"));
         },
-        jsonFields: async <T extends Record<string, any> = any>(
-          fields: (keyof T)[]
-        ): Promise<Partial<T>> => {
-          consumeBody();
-          const fullObj = JSON.parse(buffer.toString("utf-8"));
-          const result: Partial<T> = {};
-          for (const field of fields) {
-            if (field in fullObj) {
-              result[field] = fullObj[field];
-            }
-          }
-          return result;
-        },
       };
 
       Object.defineProperty(bodyObj, "bodyUsed", {
@@ -1321,7 +1179,7 @@ export class JirenClient<
    */
   private prepareBody(
     body: string | object | null | undefined,
-    userHeaders?: Record<string, string>
+    userHeaders?: Record<string, string>,
   ): { headers: Record<string, string>; serializedBody: string | null } {
     let serializedBody: string | null = null;
     const headers = { ...userHeaders };
@@ -1330,7 +1188,7 @@ export class JirenClient<
       if (typeof body === "object") {
         serializedBody = JSON.stringify(body);
         const hasContentType = Object.keys(headers).some(
-          (k) => k.toLowerCase() === "content-type"
+          (k) => k.toLowerCase() === "content-type",
         );
         if (!hasContentType) {
           headers["Content-Type"] = "application/json";