rezo 1.0.41 → 1.0.43

package/dist/index.cjs

@@ -1,27 +1,30 @@
-const _mod_0ynvco = require('./core/rezo.cjs');
-exports.Rezo = _mod_0ynvco.Rezo;
-exports.createRezoInstance = _mod_0ynvco.createRezoInstance;
-exports.createDefaultInstance = _mod_0ynvco.createDefaultInstance;;
-const _mod_bgvlss = require('./errors/rezo-error.cjs');
-exports.RezoError = _mod_bgvlss.RezoError;
-exports.RezoErrorCode = _mod_bgvlss.RezoErrorCode;;
-const _mod_z9q7ik = require('./utils/headers.cjs');
-exports.RezoHeaders = _mod_z9q7ik.RezoHeaders;;
-const _mod_dxoi53 = require('./utils/form-data.cjs');
-exports.RezoFormData = _mod_dxoi53.RezoFormData;;
-const _mod_axqg2d = require('./utils/cookies.cjs');
-exports.RezoCookieJar = _mod_axqg2d.RezoCookieJar;
-exports.Cookie = _mod_axqg2d.Cookie;;
-const _mod_0g7fzx = require('./core/hooks.cjs');
-exports.createDefaultHooks = _mod_0g7fzx.createDefaultHooks;
-exports.mergeHooks = _mod_0g7fzx.mergeHooks;;
-const _mod_ncim1p = require('./proxy/manager.cjs');
-exports.ProxyManager = _mod_ncim1p.ProxyManager;;
-const _mod_gcfuln = require('./queue/index.cjs');
-exports.RezoQueue = _mod_gcfuln.RezoQueue;
-exports.HttpQueue = _mod_gcfuln.HttpQueue;
-exports.Priority = _mod_gcfuln.Priority;
-exports.HttpMethodPriority = _mod_gcfuln.HttpMethodPriority;;
+const _mod_ez6b8t = require('./core/rezo.cjs');
+exports.Rezo = _mod_ez6b8t.Rezo;
+exports.createRezoInstance = _mod_ez6b8t.createRezoInstance;
+exports.createDefaultInstance = _mod_ez6b8t.createDefaultInstance;;
+const _mod_3tc7ap = require('./errors/rezo-error.cjs');
+exports.RezoError = _mod_3tc7ap.RezoError;
+exports.RezoErrorCode = _mod_3tc7ap.RezoErrorCode;;
+const _mod_43q7ms = require('./utils/headers.cjs');
+exports.RezoHeaders = _mod_43q7ms.RezoHeaders;;
+const _mod_g1j1lv = require('./utils/form-data.cjs');
+exports.RezoFormData = _mod_g1j1lv.RezoFormData;;
+const _mod_uvyhfd = require('./utils/cookies.cjs');
+exports.RezoCookieJar = _mod_uvyhfd.RezoCookieJar;
+exports.Cookie = _mod_uvyhfd.Cookie;;
+const _mod_u7n5iq = require('./utils/curl.cjs');
+exports.toCurl = _mod_u7n5iq.toCurl;
+exports.fromCurl = _mod_u7n5iq.fromCurl;;
+const _mod_dk9wem = require('./core/hooks.cjs');
+exports.createDefaultHooks = _mod_dk9wem.createDefaultHooks;
+exports.mergeHooks = _mod_dk9wem.mergeHooks;;
+const _mod_pe26um = require('./proxy/manager.cjs');
+exports.ProxyManager = _mod_pe26um.ProxyManager;;
+const _mod_zl76ch = require('./queue/index.cjs');
+exports.RezoQueue = _mod_zl76ch.RezoQueue;
+exports.HttpQueue = _mod_zl76ch.HttpQueue;
+exports.Priority = _mod_zl76ch.Priority;
+exports.HttpMethodPriority = _mod_zl76ch.HttpMethodPriority;;
 const { RezoError } = require('./errors/rezo-error.cjs');
 const isRezoError = exports.isRezoError = RezoError.isRezoError;
 const Cancel = exports.Cancel = RezoError;

package/dist/index.d.ts

@@ -4217,6 +4217,14 @@ export interface httpAdapterPutOverloads {
 		responseType: "upload";
 	}): Promise<RezoUploadResponse>;
 }
+/**
+ * Convert a Rezo request configuration to a cURL command string.
+ */
+export declare function toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+/**
+ * Parse a cURL command string into a Rezo request configuration.
+ */
+export declare function fromCurl(curlCommand: string): RezoRequestOptions;
 /**
  * Adapter function type - all adapters must implement this signature
  */
@@ -4500,6 +4508,71 @@ export declare class Rezo {
 	 * @see {@link cookieJar} - Access the underlying RezoCookieJar for more control
 	 */
 	clearCookies(): void;
+	/**
+	 * Convert a Rezo request configuration to a cURL command string.
+	 *
+	 * Generates a valid cURL command that can be executed in a terminal to
+	 * reproduce the same HTTP request. Useful for:
+	 * - Debugging and sharing requests
+	 * - Documentation and examples
+	 * - Testing requests outside of Node.js
+	 * - Exporting requests to other tools
+	 *
+	 * @param config - Request configuration object
+	 * @returns A cURL command string
+	 *
+	 * @example
+	 * ```typescript
+	 * const curl = Rezo.toCurl({
+	 *   url: 'https://api.example.com/users',
+	 *   method: 'POST',
+	 *   headers: { 'Content-Type': 'application/json' },
+	 *   body: { name: 'John', email: 'john@example.com' }
+	 * });
+	 * // Output: curl -X POST -H 'content-type: application/json' --data-raw '{"name":"John","email":"john@example.com"}' -L --compressed 'https://api.example.com/users'
+	 * ```
+	 */
+	static toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+	/**
+	 * Parse a cURL command string into a Rezo request configuration.
+	 *
+	 * Converts a cURL command into a configuration object that can be
+	 * passed directly to Rezo request methods. Useful for:
+	 * - Importing requests from browser DevTools
+	 * - Converting curl examples from API documentation
+	 * - Migrating scripts from curl to Rezo
+	 *
+	 * Supports common cURL options:
+	 * - `-X, --request` - HTTP method
+	 * - `-H, --header` - Request headers
+	 * - `-d, --data, --data-raw, --data-binary` - Request body
+	 * - `-u, --user` - Basic authentication
+	 * - `-x, --proxy` - Proxy configuration
+	 * - `--socks5, --socks4` - SOCKS proxy
+	 * - `-L, --location` - Follow redirects
+	 * - `--max-redirs` - Maximum redirects
+	 * - `--max-time` - Request timeout
+	 * - `-k, --insecure` - Skip TLS verification
+	 * - `-A, --user-agent` - User agent header
+	 *
+	 * @param curlCommand - A cURL command string
+	 * @returns A request configuration object
+	 *
+	 * @example
+	 * ```typescript
+	 * // From browser DevTools "Copy as cURL"
+	 * const config = Rezo.fromCurl(`
+	 *   curl 'https://api.example.com/data' \\
+	 *     -H 'Authorization: Bearer token123' \\
+	 *     -H 'Content-Type: application/json'
+	 * `);
+	 *
+	 * // Use with Rezo
+	 * const rezo = new Rezo();
+	 * const response = await rezo.request(config);
+	 * ```
+	 */
+	static fromCurl(curlCommand: string): RezoRequestOptions;
 }
 /**
  * Extended Rezo instance with Axios-compatible static helpers.

package/dist/index.js

@@ -7,6 +7,7 @@ export { RezoError, RezoErrorCode } from './errors/rezo-error.js';
 export { RezoHeaders } from './utils/headers.js';
 export { RezoFormData } from './utils/form-data.js';
 export { RezoCookieJar, Cookie } from './utils/cookies.js';
+export { toCurl, fromCurl } from './utils/curl.js';
 export { createDefaultHooks, mergeHooks } from './core/hooks.js';
 export { ProxyManager } from './proxy/manager.js';
 export { RezoQueue, HttpQueue, Priority, HttpMethodPriority } from './queue/index.js';

package/dist/internal/agents/base.cjs

@@ -0,0 +1,113 @@
+const net = require("node:net");
+const http = require("node:http");
+const https = require("node:https");
+const INTERNAL = Symbol("AgentBaseInternalState");
+
+class Agent extends http.Agent {
+  [INTERNAL] = {};
+  constructor(opts) {
+    super(opts);
+  }
+  isSecureEndpoint(options) {
+    if (options) {
+      if (typeof options.secureEndpoint === "boolean") {
+        return options.secureEndpoint;
+      }
+      if (typeof options.protocol === "string") {
+        return options.protocol === "https:";
+      }
+    }
+    const { stack } = new Error;
+    if (typeof stack !== "string")
+      return false;
+    return stack.split(`
+`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+  }
+  incrementSockets(name) {
+    if (this.maxSockets === 1 / 0 && this.maxTotalSockets === 1 / 0) {
+      return null;
+    }
+    if (!this.sockets[name]) {
+      this.sockets[name] = [];
+    }
+    const fakeSocket = new net.Socket({ writable: false });
+    this.sockets[name].push(fakeSocket);
+    this.totalSocketCount++;
+    return fakeSocket;
+  }
+  decrementSockets(name, socket) {
+    if (!this.sockets[name] || socket === null) {
+      return;
+    }
+    const sockets = this.sockets[name];
+    const index = sockets.indexOf(socket);
+    if (index !== -1) {
+      sockets.splice(index, 1);
+      this.totalSocketCount--;
+      if (sockets.length === 0) {
+        delete this.sockets[name];
+      }
+    }
+  }
+  getName(options) {
+    const secureEndpoint = this.isSecureEndpoint(options);
+    if (secureEndpoint) {
+      return https.Agent.prototype.getName.call(this, options);
+    }
+    return http.Agent.prototype.getName.call(this, options);
+  }
+  createSocket(req, options, cb) {
+    const connectOpts = {
+      ...options,
+      secureEndpoint: this.isSecureEndpoint(options)
+    };
+    const name = this.getName(connectOpts);
+    const fakeSocket = this.incrementSockets(name);
+    Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+      this.decrementSockets(name, fakeSocket);
+      if (socket instanceof http.Agent) {
+        try {
+          return socket.addRequest(req, connectOpts);
+        } catch (err) {
+          return cb(err);
+        }
+      }
+      this[INTERNAL].currentSocket = socket;
+      http.Agent.prototype.createSocket.call(this, req, options, cb);
+    }, (err) => {
+      this.decrementSockets(name, fakeSocket);
+      cb(err);
+    });
+  }
+  createConnection() {
+    const socket = this[INTERNAL].currentSocket;
+    this[INTERNAL].currentSocket = undefined;
+    if (!socket) {
+      throw new Error("No socket was returned in the `connect()` function");
+    }
+    return socket;
+  }
+  async connect(_req, _opts) {
+    throw new Error("`connect()` must be implemented by a subclass of `Agent`");
+  }
+  get defaultPort() {
+    return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+  }
+  set defaultPort(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].defaultPort = v;
+    }
+  }
+  get protocol() {
+    return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+  }
+  set protocol(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].protocol = v;
+    }
+  }
+}
+
+exports.Agent = Agent;
+exports.default = Agent;
+module.exports = Object.assign(Agent, exports);

package/dist/internal/agents/base.js

@@ -0,0 +1,110 @@
+import * as net from "node:net";
+import * as http from "node:http";
+import * as https from "node:https";
+const INTERNAL = Symbol("AgentBaseInternalState");
+
+export class Agent extends http.Agent {
+  [INTERNAL] = {};
+  constructor(opts) {
+    super(opts);
+  }
+  isSecureEndpoint(options) {
+    if (options) {
+      if (typeof options.secureEndpoint === "boolean") {
+        return options.secureEndpoint;
+      }
+      if (typeof options.protocol === "string") {
+        return options.protocol === "https:";
+      }
+    }
+    const { stack } = new Error;
+    if (typeof stack !== "string")
+      return false;
+    return stack.split(`
+`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+  }
+  incrementSockets(name) {
+    if (this.maxSockets === 1 / 0 && this.maxTotalSockets === 1 / 0) {
+      return null;
+    }
+    if (!this.sockets[name]) {
+      this.sockets[name] = [];
+    }
+    const fakeSocket = new net.Socket({ writable: false });
+    this.sockets[name].push(fakeSocket);
+    this.totalSocketCount++;
+    return fakeSocket;
+  }
+  decrementSockets(name, socket) {
+    if (!this.sockets[name] || socket === null) {
+      return;
+    }
+    const sockets = this.sockets[name];
+    const index = sockets.indexOf(socket);
+    if (index !== -1) {
+      sockets.splice(index, 1);
+      this.totalSocketCount--;
+      if (sockets.length === 0) {
+        delete this.sockets[name];
+      }
+    }
+  }
+  getName(options) {
+    const secureEndpoint = this.isSecureEndpoint(options);
+    if (secureEndpoint) {
+      return https.Agent.prototype.getName.call(this, options);
+    }
+    return http.Agent.prototype.getName.call(this, options);
+  }
+  createSocket(req, options, cb) {
+    const connectOpts = {
+      ...options,
+      secureEndpoint: this.isSecureEndpoint(options)
+    };
+    const name = this.getName(connectOpts);
+    const fakeSocket = this.incrementSockets(name);
+    Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+      this.decrementSockets(name, fakeSocket);
+      if (socket instanceof http.Agent) {
+        try {
+          return socket.addRequest(req, connectOpts);
+        } catch (err) {
+          return cb(err);
+        }
+      }
+      this[INTERNAL].currentSocket = socket;
+      http.Agent.prototype.createSocket.call(this, req, options, cb);
+    }, (err) => {
+      this.decrementSockets(name, fakeSocket);
+      cb(err);
+    });
+  }
+  createConnection() {
+    const socket = this[INTERNAL].currentSocket;
+    this[INTERNAL].currentSocket = undefined;
+    if (!socket) {
+      throw new Error("No socket was returned in the `connect()` function");
+    }
+    return socket;
+  }
+  async connect(_req, _opts) {
+    throw new Error("`connect()` must be implemented by a subclass of `Agent`");
+  }
+  get defaultPort() {
+    return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+  }
+  set defaultPort(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].defaultPort = v;
+    }
+  }
+  get protocol() {
+    return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+  }
+  set protocol(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].protocol = v;
+    }
+  }
+}
+export default Agent;

package/dist/internal/agents/http-proxy.cjs

@@ -0,0 +1,89 @@
+const net = require("node:net");
+const tls = require("node:tls");
+const http = require("node:http");
+const { once } = require("node:events");
+const { Agent } = require('./base.cjs');
+function omit(obj, ...keys) {
+  const ret = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+
+class HttpProxyAgent extends Agent {
+  static protocols = ["http", "https"];
+  proxy;
+  proxyHeaders;
+  connectOpts;
+  constructor(proxy, opts) {
+    super(opts);
+    this.proxy = typeof proxy === "string" ? new URL(proxy) : proxy;
+    this.proxyHeaders = opts?.headers ?? {};
+    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+    this.connectOpts = {
+      ...opts ? omit(opts, "headers") : {},
+      host,
+      port
+    };
+  }
+  addRequest(req, opts) {
+    req._header = null;
+    this.setRequestProps(req, opts);
+    http.Agent.prototype.addRequest.call(this, req, opts);
+  }
+  setRequestProps(req, opts) {
+    const { proxy } = this;
+    const protocol = opts.secureEndpoint ? "https:" : "http:";
+    const hostname = req.getHeader("host") || "localhost";
+    const base = `${protocol}//${hostname}`;
+    const url = new URL(req.path, base);
+    if (opts.port !== 80) {
+      url.port = String(opts.port);
+    }
+    req.path = String(url);
+    const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+    if (proxy.username || proxy.password) {
+      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+    }
+    if (!headers["Proxy-Connection"]) {
+      headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+    }
+    for (const name of Object.keys(headers)) {
+      const value = headers[name];
+      if (value) {
+        req.setHeader(name, value);
+      }
+    }
+  }
+  async connect(req, opts) {
+    req._header = null;
+    if (!req.path.includes("://")) {
+      this.setRequestProps(req, opts);
+    }
+    req._implicitHeader();
+    if (req.outputData && req.outputData.length > 0) {
+      const first = req.outputData[0].data;
+      const endOfHeaders = first.indexOf(`\r
+\r
+`) + 4;
+      req.outputData[0].data = req._header + first.substring(endOfHeaders);
+    }
+    let socket;
+    if (this.proxy.protocol === "https:") {
+      socket = tls.connect(this.connectOpts);
+    } else {
+      socket = net.connect(this.connectOpts);
+    }
+    await once(socket, "connect");
+    return socket;
+  }
+}
+
+exports.HttpProxyAgent = HttpProxyAgent;
+exports.default = HttpProxyAgent;
+module.exports = Object.assign(HttpProxyAgent, exports);

package/dist/internal/agents/http-proxy.js

@@ -0,0 +1,86 @@
+import * as net from "node:net";
+import * as tls from "node:tls";
+import * as http from "node:http";
+import { once } from "node:events";
+import { Agent } from './base.js';
+function omit(obj, ...keys) {
+  const ret = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+
+export class HttpProxyAgent extends Agent {
+  static protocols = ["http", "https"];
+  proxy;
+  proxyHeaders;
+  connectOpts;
+  constructor(proxy, opts) {
+    super(opts);
+    this.proxy = typeof proxy === "string" ? new URL(proxy) : proxy;
+    this.proxyHeaders = opts?.headers ?? {};
+    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+    this.connectOpts = {
+      ...opts ? omit(opts, "headers") : {},
+      host,
+      port
+    };
+  }
+  addRequest(req, opts) {
+    req._header = null;
+    this.setRequestProps(req, opts);
+    http.Agent.prototype.addRequest.call(this, req, opts);
+  }
+  setRequestProps(req, opts) {
+    const { proxy } = this;
+    const protocol = opts.secureEndpoint ? "https:" : "http:";
+    const hostname = req.getHeader("host") || "localhost";
+    const base = `${protocol}//${hostname}`;
+    const url = new URL(req.path, base);
+    if (opts.port !== 80) {
+      url.port = String(opts.port);
+    }
+    req.path = String(url);
+    const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+    if (proxy.username || proxy.password) {
+      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+    }
+    if (!headers["Proxy-Connection"]) {
+      headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+    }
+    for (const name of Object.keys(headers)) {
+      const value = headers[name];
+      if (value) {
+        req.setHeader(name, value);
+      }
+    }
+  }
+  async connect(req, opts) {
+    req._header = null;
+    if (!req.path.includes("://")) {
+      this.setRequestProps(req, opts);
+    }
+    req._implicitHeader();
+    if (req.outputData && req.outputData.length > 0) {
+      const first = req.outputData[0].data;
+      const endOfHeaders = first.indexOf(`\r
+\r
+`) + 4;
+      req.outputData[0].data = req._header + first.substring(endOfHeaders);
+    }
+    let socket;
+    if (this.proxy.protocol === "https:") {
+      socket = tls.connect(this.connectOpts);
+    } else {
+      socket = net.connect(this.connectOpts);
+    }
+    await once(socket, "connect");
+    return socket;
+  }
+}
+export default HttpProxyAgent;