rezo 1.0.36 → 1.0.37

package/dist/adapters/curl.cjs

@@ -16,6 +16,251 @@ const { StreamResponse } = require('../responses/stream.cjs');
 const { DownloadResponse } = require('../responses/download.cjs');
 const { UploadResponse } = require('../responses/upload.cjs');
 const { RezoPerformance } = require('../utils/tools.cjs');
+const { ResponseCache } = require('../cache/response-cache.cjs');
+const debugLog = {
+  requestStart: (config, url, method) => {
+    if (config.debug) {
+      console.log(`
+[Rezo Debug] ─────────────────────────────────────`);
+      console.log(`[Rezo Debug] ${method} ${url}`);
+      console.log(`[Rezo Debug] Request ID: ${config.requestId}`);
+      if (config.originalRequest?.headers) {
+        const headers = config.originalRequest.headers instanceof RezoHeaders ? config.originalRequest.headers.toObject() : config.originalRequest.headers;
+        console.log(`[Rezo Debug] Request Headers:`, JSON.stringify(headers, null, 2));
+      }
+      if (config.proxy && typeof config.proxy === "object") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy.protocol}://${config.proxy.host}:${config.proxy.port}`);
+      } else if (config.proxy && typeof config.proxy === "string") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy}`);
+      }
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] → ${method} ${url}`);
+    }
+  },
+  redirect: (config, fromUrl, toUrl, statusCode, method) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Redirect ${statusCode}: ${fromUrl}`);
+      console.log(`[Rezo Debug]        → ${toUrl} (${method})`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ↳ ${statusCode} → ${toUrl}`);
+    }
+  },
+  retry: (config, attempt, maxRetries, statusCode, delay) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Retry ${attempt}/${maxRetries} after status ${statusCode}${delay > 0 ? ` (waiting ${delay}ms)` : ""}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ⟳ Retry ${attempt}/${maxRetries} (status ${statusCode})`);
+    }
+  },
+  maxRetries: (config, maxRetries) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Max retries (${maxRetries}) reached, throwing error`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Max retries reached`);
+    }
+  },
+  response: (config, status, statusText, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] ✓ ${status} ${statusText}`);
+    }
+  },
+  responseHeaders: (config, headers) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response Headers:`, JSON.stringify(headers, null, 2));
+    }
+  },
+  cookies: (config, cookieCount) => {
+    if (config.debug && cookieCount > 0) {
+      console.log(`[Rezo Debug] Cookies received: ${cookieCount}`);
+    }
+  },
+  timing: (config, timing) => {
+    if (config.debug) {
+      const parts = [];
+      if (timing.dns)
+        parts.push(`DNS: ${timing.dns.toFixed(2)}ms`);
+      if (timing.connect)
+        parts.push(`Connect: ${timing.connect.toFixed(2)}ms`);
+      if (timing.tls)
+        parts.push(`TLS: ${timing.tls.toFixed(2)}ms`);
+      if (timing.ttfb)
+        parts.push(`TTFB: ${timing.ttfb.toFixed(2)}ms`);
+      if (timing.total)
+        parts.push(`Total: ${timing.total.toFixed(2)}ms`);
+      if (parts.length > 0) {
+        console.log(`[Rezo Debug] Timing: ${parts.join(" | ")}`);
+      }
+    }
+  },
+  complete: (config, finalUrl, redirectCount, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Complete: ${finalUrl}`);
+      if (redirectCount > 0) {
+        console.log(`[Rezo Debug] Redirects: ${redirectCount}`);
+      }
+      console.log(`[Rezo Debug] Total Duration: ${duration.toFixed(2)}ms`);
+      console.log(`[Rezo Debug] ─────────────────────────────────────
+`);
+    }
+  }
+};
+const responseCacheInstances = new Map;
+function getCacheConfigKey(option) {
+  if (option === true)
+    return "default";
+  if (option === false)
+    return "disabled";
+  const cfg = option;
+  return JSON.stringify({
+    cacheDir: cfg.cacheDir || null,
+    ttl: cfg.ttl || 300000,
+    maxEntries: cfg.maxEntries || 500,
+    methods: cfg.methods || ["GET", "HEAD"],
+    respectHeaders: cfg.respectHeaders !== false
+  });
+}
+function getResponseCache(option) {
+  const key = getCacheConfigKey(option);
+  let cache = responseCacheInstances.get(key);
+  if (!cache) {
+    cache = new ResponseCache(option);
+    const existing = responseCacheInstances.get(key);
+    if (existing) {
+      return existing;
+    }
+    responseCacheInstances.set(key, cache);
+  }
+  return cache;
+}
+function parseCacheControlFromHeaders(headers) {
+  const cacheControl = headers["cache-control"] || "";
+  return {
+    noCache: cacheControl.includes("no-cache"),
+    mustRevalidate: cacheControl.includes("must-revalidate")
+  };
+}
+function buildCachedRezoResponse(cached, config) {
+  const headers = new RezoHeaders(cached.headers);
+  return {
+    data: cached.data,
+    status: cached.status,
+    statusText: cached.statusText,
+    headers,
+    finalUrl: cached.url,
+    urls: [cached.url],
+    contentType: cached.headers["content-type"],
+    contentLength: parseInt(cached.headers["content-length"] || "0", 10) || 0,
+    cookies: {
+      array: [],
+      serialized: [],
+      netscape: "",
+      string: "",
+      setCookiesString: []
+    },
+    config: {
+      ...config,
+      url: cached.url,
+      method: "GET",
+      headers,
+      adapterUsed: "curl",
+      fromCache: true
+    }
+  };
+}
+function buildUrlTree(config, finalUrl) {
+  const urls = [];
+  if (config.rawUrl) {
+    urls.push(config.rawUrl);
+  } else if (config.url) {
+    const urlStr = typeof config.url === "string" ? config.url : config.url.toString();
+    urls.push(urlStr);
+  }
+  if (config.redirectHistory && config.redirectHistory.length > 0) {
+    for (const redirect of config.redirectHistory) {
+      const redirectUrl = typeof redirect.url === "string" ? redirect.url : redirect.url?.toString?.() || "";
+      if (redirectUrl && urls[urls.length - 1] !== redirectUrl) {
+        urls.push(redirectUrl);
+      }
+    }
+  }
+  if (finalUrl && (urls.length === 0 || urls[urls.length - 1] !== finalUrl)) {
+    urls.push(finalUrl);
+  }
+  return urls.length > 0 ? urls : [finalUrl];
+}
+async function updateCookies(config, cookieStrings, url) {
+  if (!cookieStrings || cookieStrings.length === 0)
+    return;
+  const tempJar = new RezoCookieJar;
+  tempJar.setCookiesSync(cookieStrings, url);
+  const parsedCookies = tempJar.cookies();
+  const acceptedCookies = [];
+  let hookError = null;
+  if (config.hooks?.beforeCookie && config.hooks.beforeCookie.length > 0) {
+    for (const cookie of parsedCookies.array) {
+      let shouldAccept = true;
+      for (const hook of config.hooks.beforeCookie) {
+        try {
+          const result = await hook({
+            cookie,
+            source: "response",
+            url,
+            isValid: true
+          }, config);
+          if (result === false) {
+            shouldAccept = false;
+            break;
+          }
+        } catch (err) {
+          hookError = err;
+          if (config.debug) {
+            console.log("[Rezo Debug] beforeCookie hook error:", err);
+          }
+        }
+      }
+      if (shouldAccept) {
+        acceptedCookies.push(cookie);
+      }
+    }
+  } else {
+    acceptedCookies.push(...parsedCookies.array);
+  }
+  const acceptedCookieStrings = acceptedCookies.map((c) => c.toSetCookieString());
+  if (!config.disableCookieJar && config.cookieJar) {
+    config.cookieJar.setCookiesSync(acceptedCookieStrings, url);
+  }
+  if (config.useCookies) {
+    const existingArray = config.responseCookies?.array || [];
+    for (const cookie of acceptedCookies) {
+      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();
+  }
+  if (!hookError && config.hooks?.afterCookie && config.hooks.afterCookie.length > 0) {
+    for (const hook of config.hooks.afterCookie) {
+      try {
+        await hook(acceptedCookies, config);
+      } catch (err) {
+        if (config.debug) {
+          console.log("[Rezo Debug] afterCookie hook error:", err);
+        }
+      }
+    }
+  }
+}
 function mergeRequestAndResponseCookies(requestCookies, responseCookies) {
   if (!requestCookies || requestCookies.length === 0) {
     return responseCookies;
@@ -1282,7 +1527,7 @@ class CurlCommandBuilder {
     }
   }
   buildCookieConfig(config) {
-    if (!config.enableCookieJar) {
+    if (config.disableCookieJar) {
       return;
     }
     const cookieJarFile = this.tempFiles.createTempFile("cookies", ".txt");
@@ -1483,10 +1728,18 @@ class CurlResponseParser {
     config.transfer.bodySize = responseBody.length;
     config.transfer.headerSize = headerSection.length;
     config.responseCookies = cookies;
-    const urls = [config.url];
-    if (stats["redirect_url"]) {
-      urls.push(stats["redirect_url"]);
-    }
+    const finalUrl = stats["redirect_url"] || config.url || "";
+    const urls = buildUrlTree(config, finalUrl);
+    const timingDurations = getTimingDurations(config);
+    debugLog.responseHeaders(config, headers);
+    debugLog.timing(config, {
+      dns: timingDurations.dns,
+      connect: timingDurations.tcp,
+      tls: timingDurations.tls,
+      ttfb: timingDurations.firstByte,
+      total: timingDurations.total
+    });
+    debugLog.cookies(config, cookies.array?.length || 0);
     return {
       data,
       status,
@@ -1496,7 +1749,7 @@ class CurlResponseParser {
       config,
       contentType: contentType || undefined,
       contentLength: parseInt(stats["size_download"]) || responseBody.length,
-      finalUrl: stats["redirect_url"] || config.url,
+      finalUrl,
       urls
     };
   }
@@ -1859,9 +2112,43 @@ async function executeRequest(options, defaultOptions, jar) {
       throw new RezoError("No proxy available: All proxies exhausted or URL did not match whitelist/blacklist", config, "UNQ_NO_PROXY_AVAILABLE", originalRequest);
     }
   }
-  const isStream = options._isStream;
-  const isDownload = options._isDownload || !!options.fileName || !!options.saveTo;
-  const isUpload = options._isUpload;
+  const cacheOption = options.cache;
+  const method = (options.method || "GET").toUpperCase();
+  const requestUrl = typeof originalRequest.url === "string" ? originalRequest.url : originalRequest.url?.toString() || "";
+  let cache;
+  let requestHeaders;
+  let cachedEntry;
+  let needsRevalidation = false;
+  const isStream = options._isStream || options.responseType === "stream";
+  const isDownload = options._isDownload || !!options.fileName || !!options.saveTo || options.responseType === "download";
+  const isUpload = options._isUpload || options.responseType === "upload";
+  if (cacheOption && !isStream && !isDownload && !isUpload) {
+    cache = getResponseCache(cacheOption);
+    requestHeaders = originalRequest.headers instanceof RezoHeaders ? Object.fromEntries(originalRequest.headers.entries()) : originalRequest.headers;
+    cachedEntry = cache.get(method, requestUrl, requestHeaders);
+    if (cachedEntry) {
+      const cacheControl = parseCacheControlFromHeaders(cachedEntry.headers);
+      if (cacheControl.noCache || cacheControl.mustRevalidate) {
+        needsRevalidation = true;
+      } else {
+        return buildCachedRezoResponse(cachedEntry, config);
+      }
+    }
+    const conditionalHeaders = cache.getConditionalHeaders(method, requestUrl, requestHeaders);
+    if (conditionalHeaders) {
+      if (originalRequest.headers instanceof RezoHeaders) {
+        for (const [key, value] of Object.entries(conditionalHeaders)) {
+          originalRequest.headers.set(key, value);
+        }
+      } else {
+        originalRequest.headers = {
+          ...originalRequest.headers,
+          ...conditionalHeaders
+        };
+      }
+    }
+  }
+  debugLog.requestStart(config, requestUrl, method);
   let streamResponse;
   let downloadResponse;
   let uploadResponse;
@@ -1911,6 +2198,23 @@ async function executeRequest(options, defaultOptions, jar) {
       if (proxyManager && selectedProxy) {
         proxyManager.reportSuccess(selectedProxy);
       }
+      const duration = perform.now();
+      debugLog.response(config, response.status, response.statusText, duration);
+      debugLog.cookies(config, response.cookies?.array?.length || 0);
+      if (cache) {
+        if (response.status === 304 && cachedEntry) {
+          const responseHeaders = response.headers instanceof RezoHeaders ? Object.fromEntries(response.headers.entries()) : response.headers;
+          const updatedCached = cache.updateRevalidated(method, requestUrl, responseHeaders, requestHeaders);
+          if (updatedCached) {
+            return buildCachedRezoResponse(updatedCached, config);
+          }
+          return buildCachedRezoResponse(cachedEntry, config);
+        }
+        if (response.status >= 200 && response.status < 300) {
+          cache.set(method, requestUrl, response, requestHeaders);
+        }
+      }
+      debugLog.complete(config, response.finalUrl || requestUrl, config.redirectHistory?.length || 0, duration);
       if (response.status >= 400) {
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, originalRequest);
         if (config.retry) {
@@ -1920,12 +2224,19 @@ async function executeRequest(options, defaultOptions, jar) {
             const retryDelay = config.retry.retryDelay || 0;
             const incrementDelay = config.retry.incrementDelay || false;
             const delay = incrementDelay ? retryDelay * (config.retryAttempts + 1) : retryDelay;
+            debugLog.retry(config, config.retryAttempts + 1, maxRetries, response.status, delay);
+            if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
+              for (const hook of config.hooks.beforeRetry) {
+                await hook(config, httpError, config.retryAttempts + 1);
+              }
+            }
             if (delay > 0) {
               await new Promise((resolve) => setTimeout(resolve, delay));
             }
             config.retryAttempts++;
             return executeRequest(options, defaultOptions, jar);
           }
+          debugLog.maxRetries(config, maxRetries);
         }
         throw httpError;
       }