rezo 1.0.43 → 1.0.45

package/dist/utils/rate-limit-wait.js

@@ -0,0 +1,208 @@
+import { RezoHeaders } from './headers.js';
+export const DEFAULT_WAIT_STATUS_CODES = [429];
+export const DEFAULT_MAX_WAIT_TIME = 60000;
+export const DEFAULT_WAIT_TIME = 1000;
+export const DEFAULT_MAX_WAIT_ATTEMPTS = 3;
+export function shouldWaitOnStatus(status, waitOnStatus) {
+  if (!waitOnStatus)
+    return false;
+  if (waitOnStatus === true) {
+    return DEFAULT_WAIT_STATUS_CODES.includes(status);
+  }
+  if (Array.isArray(waitOnStatus)) {
+    return waitOnStatus.includes(status);
+  }
+  return false;
+}
+export function parseRetryAfterHeader(value) {
+  if (!value)
+    return null;
+  const trimmed = value.trim();
+  const seconds = parseInt(trimmed, 10);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return seconds * 1000;
+  }
+  const date = new Date(trimmed);
+  if (!isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return delayMs > 0 ? delayMs : 0;
+  }
+  return null;
+}
+export function getNestedValue(obj, path) {
+  if (!obj || typeof path !== "string")
+    return;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[part];
+  }
+  return current;
+}
+export function extractWaitTime(response, options) {
+  const source = options.waitTimeSource ?? "retry-after";
+  const defaultWaitTime = options.defaultWaitTime ?? DEFAULT_WAIT_TIME;
+  if (typeof source === "function") {
+    try {
+      const seconds = source(response);
+      if (seconds !== null && seconds !== undefined && seconds > 0) {
+        return {
+          waitTimeMs: seconds * 1000,
+          source: "function"
+        };
+      }
+    } catch {}
+    return {
+      waitTimeMs: defaultWaitTime,
+      source: "default"
+    };
+  }
+  if (source === "retry-after") {
+    const headerValue = response.headers?.get?.("retry-after") ?? response.headers?.get?.("Retry-After") ?? response.headers?.["retry-after"] ?? response.headers?.["Retry-After"];
+    const waitTimeMs = parseRetryAfterHeader(headerValue);
+    if (waitTimeMs !== null) {
+      return {
+        waitTimeMs,
+        source: "header",
+        sourcePath: "retry-after"
+      };
+    }
+    return {
+      waitTimeMs: defaultWaitTime,
+      source: "default"
+    };
+  }
+  if (typeof source === "object" && "header" in source) {
+    const headerName = source.header;
+    const headerValue = response.headers?.get?.(headerName) ?? response.headers?.get?.(headerName.toLowerCase()) ?? response.headers?.[headerName] ?? response.headers?.[headerName.toLowerCase()];
+    if (headerValue) {
+      const numValue = parseInt(headerValue, 10);
+      if (!isNaN(numValue)) {
+        const now = Math.floor(Date.now() / 1000);
+        if (numValue > now && numValue < now + 86400 * 365) {
+          const waitTimeMs = (numValue - now) * 1000;
+          return {
+            waitTimeMs: waitTimeMs > 0 ? waitTimeMs : defaultWaitTime,
+            source: "header",
+            sourcePath: headerName
+          };
+        }
+        return {
+          waitTimeMs: numValue * 1000,
+          source: "header",
+          sourcePath: headerName
+        };
+      }
+      const waitTimeMs = parseRetryAfterHeader(headerValue);
+      if (waitTimeMs !== null) {
+        return {
+          waitTimeMs,
+          source: "header",
+          sourcePath: headerName
+        };
+      }
+    }
+    return {
+      waitTimeMs: defaultWaitTime,
+      source: "default"
+    };
+  }
+  if (typeof source === "object" && "body" in source) {
+    const bodyPath = source.body;
+    const value = getNestedValue(response.data, bodyPath);
+    if (value !== null && value !== undefined) {
+      const numValue = typeof value === "number" ? value : parseInt(String(value), 10);
+      if (!isNaN(numValue) && numValue > 0) {
+        return {
+          waitTimeMs: numValue * 1000,
+          source: "body",
+          sourcePath: bodyPath
+        };
+      }
+    }
+    return {
+      waitTimeMs: defaultWaitTime,
+      source: "default"
+    };
+  }
+  return {
+    waitTimeMs: defaultWaitTime,
+    source: "default"
+  };
+}
+export function createRateLimitWaitEvent(status, waitTimeMs, attempt, maxAttempts, source, sourcePath, url, method) {
+  return {
+    status,
+    waitTime: waitTimeMs,
+    attempt,
+    maxAttempts,
+    source,
+    sourcePath,
+    url,
+    method,
+    timestamp: Date.now()
+  };
+}
+export async function executeRateLimitWaitHooks(event, config) {
+  const hooks = config.hooks?.onRateLimitWait;
+  if (!hooks || hooks.length === 0)
+    return;
+  for (const hook of hooks) {
+    try {
+      await hook(event, config);
+    } catch (err) {
+      if (config.debug) {
+        console.log("[Rezo Debug] onRateLimitWait hook error:", err);
+      }
+    }
+  }
+}
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeHeaders(headers) {
+  if (!headers)
+    return new RezoHeaders;
+  if (headers instanceof RezoHeaders)
+    return headers;
+  if (typeof headers.get === "function")
+    return headers;
+  try {
+    return new RezoHeaders(headers);
+  } catch {
+    return new RezoHeaders;
+  }
+}
+export async function handleRateLimitWait(ctx) {
+  const { status, headers, data, url, method, config, options, currentWaitAttempt } = ctx;
+  if (!shouldWaitOnStatus(status, options.waitOnStatus)) {
+    return { shouldRetry: false, waitAttempt: currentWaitAttempt, waitedMs: 0 };
+  }
+  const maxAttempts = options.maxWaitAttempts ?? DEFAULT_MAX_WAIT_ATTEMPTS;
+  const maxWaitTime = options.maxWaitTime ?? DEFAULT_MAX_WAIT_TIME;
+  const nextAttempt = currentWaitAttempt + 1;
+  if (nextAttempt > maxAttempts) {
+    return { shouldRetry: false, waitAttempt: currentWaitAttempt, waitedMs: 0 };
+  }
+  const normalizedHeaders = normalizeHeaders(headers);
+  const extracted = extractWaitTime({ status, headers: normalizedHeaders, data }, options);
+  let waitTimeMs = extracted.waitTimeMs;
+  if (maxWaitTime > 0 && waitTimeMs > maxWaitTime) {
+    return { shouldRetry: false, waitAttempt: currentWaitAttempt, waitedMs: 0 };
+  }
+  const event = createRateLimitWaitEvent(status, waitTimeMs, nextAttempt, maxAttempts, extracted.source, extracted.sourcePath, url, method);
+  await executeRateLimitWaitHooks(event, config);
+  if (config.debug) {
+    console.log(`[Rezo Debug] Rate limit (${status}) - waiting ${waitTimeMs}ms (attempt ${nextAttempt}/${maxAttempts}, source: ${extracted.source}${extracted.sourcePath ? `:${extracted.sourcePath}` : ""})`);
+  }
+  await sleep(waitTimeMs);
+  return {
+    shouldRetry: true,
+    waitAttempt: nextAttempt,
+    waitedMs: waitTimeMs
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rezo",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "Lightning-fast, enterprise-grade HTTP client for modern JavaScript. Full HTTP/2 support, intelligent cookie management, multiple adapters (HTTP, Fetch, cURL, XHR), streaming, proxy support (HTTP/HTTPS/SOCKS), and cross-environment compatibility.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -62,11 +62,7 @@
   },
   "dependencies": {
     "tough-cookie": "^5.1.2",
-    "http-proxy-agent": "^7.0.2",
-    "https-proxy-agent": "^7.0.6",
-    "socks-proxy-agent": "^8.0.5",
-    "linkedom": "^0.18.11",
-    "agent-base": "^7.1.4"
+    "linkedom": "^0.18.11"
   },
   "typesVersions": {
     "*": {

package/dist/cache/file-cacher.cjs

@@ -1,270 +0,0 @@
-const fs = require("node:fs");
-const path = require("node:path");
-const { createHash } = require("node:crypto");
-function detectRuntime() {
-  if (typeof globalThis.Bun !== "undefined") {
-    return "bun";
-  }
-  if (typeof globalThis.Deno !== "undefined") {
-    return "deno";
-  }
-  return "node";
-}
-async function createDatabase(dbPath) {
-  const runtime = detectRuntime();
-  if (runtime === "bun") {
-    const { Database } = await import("bun:sqlite");
-    const db = new Database(dbPath);
-    return {
-      run: (sql, ...params) => db.run(sql, ...params),
-      get: (sql, ...params) => db.query(sql).get(...params),
-      all: (sql, ...params) => db.query(sql).all(...params),
-      close: () => db.close()
-    };
-  }
-  if (runtime === "deno") {
-    try {
-      const { Database } = await import("node:sqlite");
-      const db = new Database(dbPath);
-      return {
-        run: (sql, ...params) => db.exec(sql, params),
-        get: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.get(...params);
-        },
-        all: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.all(...params);
-        },
-        close: () => db.close()
-      };
-    } catch {
-      throw new Error("Deno SQLite support requires Node.js compatibility mode");
-    }
-  }
-  const { DatabaseSync } = await import("node:sqlite");
-  const db = new DatabaseSync(dbPath);
-  return {
-    run: (sql, ...params) => {
-      if (params.length === 0) {
-        db.exec(sql);
-      } else {
-        db.prepare(sql).run(...params);
-      }
-    },
-    get: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.get(...params);
-    },
-    all: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.all(...params);
-    },
-    close: () => db.close()
-  };
-}
-async function compressData(data) {
-  try {
-    const zlib = await import("node:zlib");
-    if (typeof zlib.zstdCompressSync === "function") {
-      return zlib.zstdCompressSync(data);
-    }
-    return data;
-  } catch {
-    return data;
-  }
-}
-async function decompressData(data) {
-  try {
-    const zlib = await import("node:zlib");
-    if (typeof zlib.zstdDecompressSync === "function") {
-      return zlib.zstdDecompressSync(data);
-    }
-    return data;
-  } catch {
-    return data;
-  }
-}
-
-class FileCacher {
-  databases = new Map;
-  options;
-  cacheDir;
-  closed = false;
-  constructor(options = {}) {
-    this.options = {
-      cacheDir: options.cacheDir || "./cache",
-      ttl: options.ttl || 604800000,
-      compression: options.compression ?? false,
-      softDelete: options.softDelete ?? false,
-      encryptNamespace: options.encryptNamespace ?? false,
-      maxEntries: options.maxEntries ?? 0
-    };
-    this.cacheDir = path.resolve(this.options.cacheDir);
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-    }
-  }
-  static async create(options = {}) {
-    const cacher = new FileCacher(options);
-    return cacher;
-  }
-  async getDatabase(namespace) {
-    const nsKey = this.options.encryptNamespace ? createHash("md5").update(namespace).digest("hex") : namespace.replace(/[^a-zA-Z0-9_-]/g, "_");
-    if (this.databases.has(nsKey)) {
-      return this.databases.get(nsKey);
-    }
-    const dbPath = path.join(this.cacheDir, `${nsKey}.db`);
-    const db = await createDatabase(dbPath);
-    db.run(`
-      CREATE TABLE IF NOT EXISTS cache (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        expiresAt INTEGER NOT NULL,
-        createdAt INTEGER NOT NULL,
-        compressed INTEGER DEFAULT 0,
-        deleted INTEGER DEFAULT 0
-      )
-    `);
-    db.run("CREATE INDEX IF NOT EXISTS idx_expires ON cache(expiresAt)");
-    db.run("CREATE INDEX IF NOT EXISTS idx_deleted ON cache(deleted)");
-    this.databases.set(nsKey, db);
-    return db;
-  }
-  async set(key, value, ttl, namespace = "default") {
-    if (this.closed)
-      throw new Error("FileCacher is closed");
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const expiresAt = now + (ttl ?? this.options.ttl);
-    let serialized = JSON.stringify(value);
-    let compressed = 0;
-    if (this.options.compression) {
-      try {
-        const compressedData = await compressData(Buffer.from(serialized, "utf-8"));
-        serialized = compressedData.toString("base64");
-        compressed = 1;
-      } catch {}
-    }
-    db.run(`
-      INSERT OR REPLACE INTO cache (key, value, expiresAt, createdAt, compressed, deleted)
-      VALUES (?, ?, ?, ?, ?, 0)
-    `, key, serialized, expiresAt, now, compressed);
-    if (this.options.maxEntries > 0) {
-      const count = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 0");
-      if (count && count.cnt > this.options.maxEntries) {
-        const excess = count.cnt - this.options.maxEntries;
-        db.run(`
-          DELETE FROM cache WHERE key IN (
-            SELECT key FROM cache WHERE deleted = 0 ORDER BY createdAt ASC LIMIT ?
-          )
-        `, excess);
-      }
-    }
-  }
-  async get(key, namespace = "default") {
-    if (this.closed)
-      throw new Error("FileCacher is closed");
-    const db = await this.getDatabase(namespace);
-    const entry = db.get("SELECT * FROM cache WHERE key = ? AND deleted = 0", key);
-    if (!entry)
-      return null;
-    if (entry.expiresAt < Date.now()) {
-      if (this.options.softDelete) {
-        db.run("UPDATE cache SET deleted = 1 WHERE key = ?", key);
-      } else {
-        db.run("DELETE FROM cache WHERE key = ?", key);
-      }
-      return null;
-    }
-    let value = entry.value;
-    if (entry.compressed) {
-      try {
-        const decompressed = await decompressData(Buffer.from(value, "base64"));
-        value = decompressed.toString("utf-8");
-      } catch {
-        return null;
-      }
-    }
-    try {
-      return JSON.parse(value);
-    } catch {
-      return null;
-    }
-  }
-  async has(key, namespace = "default") {
-    if (this.closed)
-      return false;
-    const db = await this.getDatabase(namespace);
-    const entry = db.get("SELECT key, expiresAt FROM cache WHERE key = ? AND deleted = 0", key);
-    if (!entry)
-      return false;
-    return entry.expiresAt >= Date.now();
-  }
-  async delete(key, namespace = "default") {
-    if (this.closed)
-      return false;
-    const db = await this.getDatabase(namespace);
-    if (this.options.softDelete) {
-      db.run("UPDATE cache SET deleted = 1 WHERE key = ?", key);
-    } else {
-      db.run("DELETE FROM cache WHERE key = ?", key);
-    }
-    return true;
-  }
-  async clear(namespace = "default") {
-    if (this.closed)
-      return;
-    const db = await this.getDatabase(namespace);
-    if (this.options.softDelete) {
-      db.run("UPDATE cache SET deleted = 1");
-    } else {
-      db.run("DELETE FROM cache");
-    }
-  }
-  async cleanup(namespace = "default") {
-    if (this.closed)
-      return 0;
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const countBefore = db.get("SELECT COUNT(*) as cnt FROM cache");
-    db.run("DELETE FROM cache WHERE expiresAt < ? OR deleted = 1", now);
-    const countAfter = db.get("SELECT COUNT(*) as cnt FROM cache");
-    return (countBefore?.cnt || 0) - (countAfter?.cnt || 0);
-  }
-  async stats(namespace = "default") {
-    if (this.closed)
-      return { count: 0, expired: 0, deleted: 0 };
-    const db = await this.getDatabase(namespace);
-    const now = Date.now();
-    const total = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 0");
-    const expired = db.get("SELECT COUNT(*) as cnt FROM cache WHERE expiresAt < ? AND deleted = 0", now);
-    const deleted = db.get("SELECT COUNT(*) as cnt FROM cache WHERE deleted = 1");
-    return {
-      count: total?.cnt || 0,
-      expired: expired?.cnt || 0,
-      deleted: deleted?.cnt || 0
-    };
-  }
-  async close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    for (const db of this.databases.values()) {
-      try {
-        db.close();
-      } catch {}
-    }
-    this.databases.clear();
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  get directory() {
-    return this.cacheDir;
-  }
-}
-
-exports.FileCacher = FileCacher;
-exports.default = FileCacher;
-module.exports = Object.assign(FileCacher, exports);