rezo 1.0.12 → 1.0.14

package/dist/adapters/http.js

@@ -402,6 +402,29 @@ Redirecting to: ${fetchOptions.fullUrl} using GET method`);
         options = __.options;
         continue;
       }
+      if (statusOnNext === "error") {
+        const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
+        if (config.retry && statusCodes?.includes(response.status)) {
+          if (maxRetries > retries) {
+            retries++;
+            config.retryAttempts++;
+            config.errors.push({
+              attempt: config.retryAttempts,
+              error: httpError,
+              duration: perform.now()
+            });
+            perform.reset();
+            if (config.debug) {
+              console.log(`Request failed with status code ${response.status}, retrying...${retryDelay > 0 ? " in " + (incrementDelay ? retryDelay * retries : retryDelay) + "ms" : ""}`);
+            }
+            if (retryDelay > 0) {
+              await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+            }
+            continue;
+          }
+        }
+        throw httpError;
+      }
       delete config.beforeRedirect;
       config.setSignal = () => {};
       return response;
@@ -821,10 +844,23 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
             }
           });
         });
+        req.on("error", (error) => {
+          _stats.statusOnNext = "error";
+          updateTiming(config, timing, "", 0);
+          const e = buildSmartError(config, fetchOptions, error);
+          const eventEmitter = streamResult || downloadResult || uploadResult;
+          if (eventEmitter) {
+            eventEmitter.emit("error", e);
+          }
+          resolve(e);
+          return;
+        });
+        let bodyPiped = false;
         if (body) {
           if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
             req.write(body.toString());
           } else if (body instanceof FormData || body instanceof RezoFormData) {
+            bodyPiped = true;
             if (body instanceof RezoFormData) {
               req.setHeader("Content-Type", `multipart/form-data; boundary=${body.getBoundary()}`);
               body.pipe(req);
@@ -833,24 +869,18 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
               req.setHeader("Content-Type", `multipart/form-data; boundary=${form.getBoundary()}`);
               form.pipe(req);
             }
-          } else if (typeof body === "object" && !(body instanceof Buffer) && !(body instanceof Uint8Array) && !(body instanceof Readable)) {
+          } else if (body instanceof Readable) {
+            bodyPiped = true;
+            body.pipe(req);
+          } else if (typeof body === "object" && !(body instanceof Buffer) && !(body instanceof Uint8Array)) {
             req.write(JSON.stringify(body));
           } else {
             req.write(body);
           }
         }
-        req.end();
-        req.on("error", (error) => {
-          _stats.statusOnNext = "error";
-          updateTiming(config, timing, "", 0);
-          const e = buildSmartError(config, fetchOptions, error);
-          const eventEmitter = streamResult || downloadResult || uploadResult;
-          if (eventEmitter) {
-            eventEmitter.emit("error", e);
-          }
-          resolve(e);
-          return;
-        });
+        if (!bodyPiped) {
+          req.end();
+        }
       } catch (error) {
         _stats.statusOnNext = "error";
         updateTiming(config, timing, "", 0);

package/dist/adapters/http2.cjs

@@ -4,14 +4,15 @@ const { URL } = require("node:url");
 const { Readable } = require("node:stream");
 const { RezoError } = require('../errors/rezo-error.cjs');
 const { buildSmartError, buildDecompressionError, builErrorFromResponse, buildDownloadError } = require('../responses/buildError.cjs');
-const { Cookie } = require('../utils/cookies.cjs');
+const { RezoCookieJar } = require('../utils/cookies.cjs');
 const RezoFormData = require('../utils/form-data.cjs');
 const { getDefaultConfig, prepareHTTPOptions } = require('../utils/http-config.cjs');
-const { RezoHeaders } = require('../utils/headers.cjs');
+const { RezoHeaders, sanitizeHttp2Headers } = require('../utils/headers.cjs');
 const { RezoURLSearchParams } = require('../utils/data-operations.cjs');
 const { StreamResponse } = require('../responses/stream.cjs');
 const { DownloadResponse } = require('../responses/download.cjs');
 const { UploadResponse } = require('../responses/upload.cjs');
+const { CompressionUtil } = require('../utils/compression.cjs');
 const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { ResponseCache } = require('../cache/response-cache.cjs');
 let zstdDecompressSync = null;
@@ -142,15 +143,14 @@ class Http2SessionPool {
           reject(new Error(`HTTP/2 connection timeout after ${timeout}ms`));
         }
       }, timeout) : null;
+      if (timeoutId && typeof timeoutId === "object" && "unref" in timeoutId) {
+        timeoutId.unref();
+      }
       session.on("connect", () => {
         if (!settled) {
           settled = true;
           if (timeoutId)
             clearTimeout(timeoutId);
-          const socket = session.socket;
-          if (socket && typeof socket.unref === "function") {
-            socket.unref();
-          }
           resolve(session);
         }
       });
@@ -170,6 +170,12 @@ class Http2SessionPool {
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
       entry.lastUsed = Date.now();
+      if (entry.refCount === 0) {
+        const socket = entry.session.socket;
+        if (socket && typeof socket.unref === "function") {
+          socket.unref();
+        }
+      }
     }
   }
   closeSession(url) {
@@ -275,38 +281,66 @@ function updateCookies(config, headers, url) {
   if (!setCookieHeaders)
     return;
   const cookieHeaderArray = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
-  if (!config.responseCookies) {
-    config.responseCookies = {
-      array: [],
-      serialized: [],
-      netscape: "",
-      string: "",
-      setCookiesString: []
-    };
+  if (cookieHeaderArray.length === 0)
+    return;
+  const jar = new RezoCookieJar;
+  jar.setCookiesSync(cookieHeaderArray, url);
+  if (config.enableCookieJar && config.cookieJar) {
+    config.cookieJar.setCookiesSync(cookieHeaderArray, url);
   }
-  for (const cookieStr of cookieHeaderArray) {
-    config.responseCookies.setCookiesString.push(cookieStr);
-    const parts = cookieStr.split(";");
-    const [nameValue] = parts;
-    const [name, ...valueParts] = nameValue.split("=");
-    const value = valueParts.join("=");
-    if (name && value !== undefined) {
-      const cookie = new Cookie({
-        key: name.trim(),
-        value: value.trim(),
-        domain: new URL(url).hostname,
-        path: "/",
-        httpOnly: cookieStr.toLowerCase().includes("httponly"),
-        secure: cookieStr.toLowerCase().includes("secure"),
-        sameSite: "lax"
-      });
-      config.responseCookies.array.push(cookie);
+  const cookies = jar.cookies();
+  cookies.setCookiesString = cookieHeaderArray;
+  if (config.useCookies) {
+    const existingArray = config.responseCookies?.array || [];
+    for (const cookie of cookies.array) {
+      const existingIndex = existingArray.findIndex((c) => c.key === cookie.key && c.domain === cookie.domain);
+      if (existingIndex >= 0) {
+        existingArray[existingIndex] = cookie;
+      } else {
+        existingArray.push(cookie);
+      }
+    }
+    const mergedJar = new RezoCookieJar(existingArray, url);
+    config.responseCookies = mergedJar.cookies();
+    config.responseCookies.setCookiesString = cookieHeaderArray;
+  } else {
+    config.responseCookies = cookies;
+  }
+}
+function mergeRequestAndResponseCookies(config, responseCookies, url) {
+  const mergedCookiesArray = [];
+  const cookieKeyDomainMap = new Map;
+  if (config.requestCookies && config.requestCookies.length > 0) {
+    for (const cookie of config.requestCookies) {
+      const key = `${cookie.key}|${cookie.domain || ""}`;
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
     }
   }
-  config.responseCookies.string = config.responseCookies.array.map((c) => `${c.key}=${c.value}`).join("; ");
-  config.responseCookies.serialized = config.responseCookies.array.map((c) => c.toJSON());
-  config.responseCookies.netscape = config.responseCookies.array.map((c) => c.toNetscapeFormat()).join(`
-`);
+  for (const cookie of responseCookies.array) {
+    const key = `${cookie.key}|${cookie.domain || ""}`;
+    const existingIndex = cookieKeyDomainMap.get(key);
+    if (existingIndex !== undefined) {
+      mergedCookiesArray[existingIndex] = cookie;
+    } else {
+      mergedCookiesArray.push(cookie);
+      cookieKeyDomainMap.set(key, mergedCookiesArray.length - 1);
+    }
+  }
+  if (mergedCookiesArray.length > 0) {
+    const mergedJar = new RezoCookieJar(mergedCookiesArray, url);
+    return mergedJar.cookies();
+  }
+  return {
+    array: [],
+    serialized: [],
+    netscape: `# Netscape HTTP Cookie File
+# This file was generated by Rezo HTTP client
+# Based on uniqhtt cookie implementation
+`,
+    string: "",
+    setCookiesString: []
+  };
 }
 async function executeRequest(options, defaultOptions, jar) {
   if (!options.responseType) {
@@ -484,6 +518,8 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         if (fileName && fs && fs.existsSync(fileName)) {
           fs.unlinkSync(fileName);
         }
+        if (!config.errors)
+          config.errors = [];
         config.errors.push({
           attempt: config.retryAttempts + 1,
           error: response,
@@ -524,6 +560,29 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
       if (statusOnNext === "success") {
         return response;
       }
+      if (statusOnNext === "error") {
+        const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, fetchOptions);
+        if (config.retry && statusCodes?.includes(response.status)) {
+          if (maxRetries > retries) {
+            retries++;
+            config.retryAttempts++;
+            config.errors.push({
+              attempt: config.retryAttempts,
+              error: httpError,
+              duration: perform.now()
+            });
+            perform.reset();
+            if (config.debug) {
+              console.log(`Request failed with status code ${response.status}, retrying...${retryDelay > 0 ? " in " + (incrementDelay ? retryDelay * retries : retryDelay) + "ms" : ""}`);
+            }
+            if (retryDelay > 0) {
+              await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+            }
+            continue;
+          }
+        }
+        throw httpError;
+      }
       if (statusOnNext === "redirect") {
         const location = _stats.redirectUrl;
         if (!location) {
@@ -620,6 +679,13 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       if (!headers["accept-encoding"]) {
         headers["accept-encoding"] = "gzip, deflate, br";
       }
+      if (body instanceof RezoFormData) {
+        headers["content-type"] = `multipart/form-data; boundary=${body.getBoundary()}`;
+      } else if (body instanceof FormData) {
+        const tempForm = await RezoFormData.fromNativeFormData(body);
+        headers["content-type"] = `multipart/form-data; boundary=${tempForm.getBoundary()}`;
+        fetchOptions._convertedFormData = tempForm;
+      }
       const eventEmitter = streamResult || downloadResult || uploadResult;
       if (eventEmitter && requestCount === 0) {
         const startEvent = {
@@ -735,6 +801,25 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         config.timing.endTimestamp = Date.now();
         config.timing.durationMs = performance.now() - timing.startTime;
         config.timing.transferMs = timing.firstByteTime ? performance.now() - timing.firstByteTime : config.timing.durationMs;
+        if (!config.transfer) {
+          config.transfer = { requestSize: 0, responseSize: 0, headerSize: 0, bodySize: 0 };
+        }
+        if (config.transfer.requestSize === undefined) {
+          config.transfer.requestSize = 0;
+        }
+        if (config.transfer.requestSize === 0 && body) {
+          if (typeof body === "string") {
+            config.transfer.requestSize = Buffer.byteLength(body, "utf8");
+          } else if (body instanceof Buffer || body instanceof Uint8Array) {
+            config.transfer.requestSize = body.length;
+          } else if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
+            config.transfer.requestSize = Buffer.byteLength(body.toString(), "utf8");
+          } else if (body instanceof RezoFormData) {
+            config.transfer.requestSize = body.getLengthSync();
+          } else if (typeof body === "object") {
+            config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
+          }
+        }
         config.transfer.bodySize = contentLengthCounter;
         config.transfer.responseSize = contentLengthCounter;
         (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
@@ -743,7 +828,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data: "",
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
             config,
             contentType: responseHeaders["content-type"],
@@ -756,14 +841,14 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         }
         let responseBody = Buffer.concat(chunks);
         const contentEncoding = responseHeaders["content-encoding"];
-        if (contentEncoding && contentLengthCounter > 0) {
+        if (contentEncoding && contentLengthCounter > 0 && CompressionUtil.shouldDecompress(contentEncoding, config)) {
           try {
             const decompressed = await decompressBuffer(responseBody, contentEncoding);
             responseBody = decompressed;
           } catch (err) {
             const error = buildDecompressionError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType: responseHeaders["content-type"],
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -803,24 +888,17 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             data = responseBody.toString("utf-8");
           }
         }
-        if (status >= 400) {
-          const error = builErrorFromResponse(`HTTP Error ${status}: ${statusText}`, {
-            status,
-            statusText,
-            headers: new RezoHeaders(responseHeaders),
-            data
-          }, config, fetchOptions);
-          _stats.statusOnNext = "error";
-          resolve(error);
-          return;
-        }
-        _stats.statusOnNext = "success";
+        config.status = status;
+        config.statusText = statusText;
+        _stats.statusOnNext = status >= 400 ? "error" : "success";
+        const responseCookies = config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+        const mergedCookies = mergeRequestAndResponseCookies(config, responseCookies, url.href);
         const finalResponse = {
           data,
           status,
           statusText,
-          headers: new RezoHeaders(responseHeaders),
-          cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+          headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+          cookies: mergedCookies,
           config,
           contentType,
           contentLength: contentLengthCounter,
@@ -833,11 +911,11 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             const downloadFinishEvent = {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               contentType,
               contentLength: responseBody.length,
               finalUrl: url.href,
-              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+              cookies: mergedCookies,
               urls: buildUrlTree(config, url.href),
               fileName: config.fileName,
               fileSize: responseBody.length,
@@ -858,7 +936,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           } catch (err) {
             const error = buildDownloadError({
               statusCode: status,
-              headers: responseHeaders,
+              headers: sanitizeHttp2Headers(responseHeaders),
               contentType,
               contentLength: String(contentLengthCounter),
               cookies: config.responseCookies?.setCookiesString || [],
@@ -878,7 +956,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           const streamFinishEvent = {
             status,
             statusText,
-            headers: new RezoHeaders(responseHeaders),
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
             contentType,
             contentLength: contentLengthCounter,
             finalUrl: url.href,
@@ -904,7 +982,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             response: {
               status,
               statusText,
-              headers: new RezoHeaders(responseHeaders),
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               data,
               contentType,
               contentLength: contentLengthCounter
@@ -949,7 +1027,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
             body.pipe(req);
             return;
           } else {
-            const form = await RezoFormData.fromNativeFormData(body);
+            const form = fetchOptions._convertedFormData || await RezoFormData.fromNativeFormData(body);
             form.pipe(req);
             return;
           }