rezo 1.0.0

package/dist/utils/agent-merger.cjs

@@ -0,0 +1,111 @@
+const http = require("node:http");
+const https = require("node:https");
+const { rezoProxy } = require('../proxy/index.cjs');
+
+class AgentMerger {
+  static merge(options) {
+    const { proxy, httpAgent, httpsAgent, isSecure = false, mergeOptions = {} } = options;
+    if (!proxy && !httpAgent && !httpsAgent) {
+      return;
+    }
+    if (!proxy) {
+      return isSecure ? httpsAgent : httpAgent;
+    }
+    if (!httpAgent && !httpsAgent) {
+      return this.createProxyAgent(proxy);
+    }
+    return this.mergeProxyWithCustomAgent(proxy, isSecure ? httpsAgent : httpAgent, isSecure, mergeOptions);
+  }
+  static createProxyAgent(proxy) {
+    if (!proxy) {
+      throw new Error("Proxy configuration is required");
+    }
+    if (typeof proxy === "string") {
+      return rezoProxy(proxy);
+    }
+    return rezoProxy(proxy);
+  }
+  static mergeProxyWithCustomAgent(proxy, customAgent, isSecure, mergeOptions = {}) {
+    if (!customAgent) {
+      return this.createProxyAgent(proxy);
+    }
+    const customOptions = this.extractAgentOptions(customAgent);
+    const proxyAgent = this.createProxyAgent(proxy);
+    const proxyOptions = this.extractAgentOptions(proxyAgent);
+    const mergedOptions = {
+      ...proxyOptions,
+      ...customOptions,
+      ...mergeOptions,
+      proxy: this.extractProxyConfig(proxyAgent)
+    };
+    if (isSecure) {
+      return new https.Agent(mergedOptions);
+    } else {
+      return new http.Agent(mergedOptions);
+    }
+  }
+  static extractAgentOptions(agent) {
+    const options = {};
+    if (agent.keepAlive !== undefined)
+      options.keepAlive = agent.keepAlive;
+    if (agent.keepAliveMsecs !== undefined)
+      options.keepAliveMsecs = agent.keepAliveMsecs;
+    if (agent.maxSockets !== undefined)
+      options.maxSockets = agent.maxSockets;
+    if (agent.maxFreeSockets !== undefined)
+      options.maxFreeSockets = agent.maxFreeSockets;
+    if (agent.timeout !== undefined)
+      options.timeout = agent.timeout;
+    if (agent instanceof https.Agent) {
+      const httpsAgent = agent;
+      if (httpsAgent.options?.rejectUnauthorized !== undefined) {
+        options.rejectUnauthorized = httpsAgent.options.rejectUnauthorized;
+      }
+      if (httpsAgent.options?.ca)
+        options.ca = httpsAgent.options.ca;
+      if (httpsAgent.options?.cert)
+        options.cert = httpsAgent.options.cert;
+      if (httpsAgent.options?.key)
+        options.key = httpsAgent.options.key;
+      if (httpsAgent.options?.pfx)
+        options.pfx = httpsAgent.options.pfx;
+      if (httpsAgent.options?.passphrase)
+        options.passphrase = httpsAgent.options.passphrase;
+      if (httpsAgent.options?.ciphers)
+        options.ciphers = httpsAgent.options.ciphers;
+      if (httpsAgent.options?.secureProtocol)
+        options.secureProtocol = httpsAgent.options.secureProtocol;
+    }
+    return options;
+  }
+  static extractProxyConfig(proxyAgent) {
+    return proxyAgent.proxy || proxyAgent.proxyOptions || undefined;
+  }
+  static createMergedAgent(options) {
+    const { proxy, customAgent, isSecure = false, capabilities = {} } = options;
+    return this.merge({
+      proxy,
+      httpAgent: !isSecure ? customAgent : undefined,
+      httpsAgent: isSecure ? customAgent : undefined,
+      isSecure,
+      mergeOptions: capabilities
+    });
+  }
+  static isProxyAgent(agent) {
+    return !!agent.proxy || !!agent.proxyOptions;
+  }
+  static getProxyInfo(agent) {
+    return agent.proxy || agent.proxyOptions || null;
+  }
+}
+function mergeAgents(proxy, customAgent, isSecure = false) {
+  return AgentMerger.merge({
+    proxy,
+    httpAgent: !isSecure ? customAgent : undefined,
+    httpsAgent: isSecure ? customAgent : undefined,
+    isSecure
+  });
+}
+
+exports.AgentMerger = AgentMerger;
+exports.mergeAgents = mergeAgents;

package/dist/utils/agent-merger.js

@@ -0,0 +1,108 @@
+import * as http from "node:http";
+import * as https from "node:https";
+import { rezoProxy } from '../proxy/index.js';
+
+export class AgentMerger {
+  static merge(options) {
+    const { proxy, httpAgent, httpsAgent, isSecure = false, mergeOptions = {} } = options;
+    if (!proxy && !httpAgent && !httpsAgent) {
+      return;
+    }
+    if (!proxy) {
+      return isSecure ? httpsAgent : httpAgent;
+    }
+    if (!httpAgent && !httpsAgent) {
+      return this.createProxyAgent(proxy);
+    }
+    return this.mergeProxyWithCustomAgent(proxy, isSecure ? httpsAgent : httpAgent, isSecure, mergeOptions);
+  }
+  static createProxyAgent(proxy) {
+    if (!proxy) {
+      throw new Error("Proxy configuration is required");
+    }
+    if (typeof proxy === "string") {
+      return rezoProxy(proxy);
+    }
+    return rezoProxy(proxy);
+  }
+  static mergeProxyWithCustomAgent(proxy, customAgent, isSecure, mergeOptions = {}) {
+    if (!customAgent) {
+      return this.createProxyAgent(proxy);
+    }
+    const customOptions = this.extractAgentOptions(customAgent);
+    const proxyAgent = this.createProxyAgent(proxy);
+    const proxyOptions = this.extractAgentOptions(proxyAgent);
+    const mergedOptions = {
+      ...proxyOptions,
+      ...customOptions,
+      ...mergeOptions,
+      proxy: this.extractProxyConfig(proxyAgent)
+    };
+    if (isSecure) {
+      return new https.Agent(mergedOptions);
+    } else {
+      return new http.Agent(mergedOptions);
+    }
+  }
+  static extractAgentOptions(agent) {
+    const options = {};
+    if (agent.keepAlive !== undefined)
+      options.keepAlive = agent.keepAlive;
+    if (agent.keepAliveMsecs !== undefined)
+      options.keepAliveMsecs = agent.keepAliveMsecs;
+    if (agent.maxSockets !== undefined)
+      options.maxSockets = agent.maxSockets;
+    if (agent.maxFreeSockets !== undefined)
+      options.maxFreeSockets = agent.maxFreeSockets;
+    if (agent.timeout !== undefined)
+      options.timeout = agent.timeout;
+    if (agent instanceof https.Agent) {
+      const httpsAgent = agent;
+      if (httpsAgent.options?.rejectUnauthorized !== undefined) {
+        options.rejectUnauthorized = httpsAgent.options.rejectUnauthorized;
+      }
+      if (httpsAgent.options?.ca)
+        options.ca = httpsAgent.options.ca;
+      if (httpsAgent.options?.cert)
+        options.cert = httpsAgent.options.cert;
+      if (httpsAgent.options?.key)
+        options.key = httpsAgent.options.key;
+      if (httpsAgent.options?.pfx)
+        options.pfx = httpsAgent.options.pfx;
+      if (httpsAgent.options?.passphrase)
+        options.passphrase = httpsAgent.options.passphrase;
+      if (httpsAgent.options?.ciphers)
+        options.ciphers = httpsAgent.options.ciphers;
+      if (httpsAgent.options?.secureProtocol)
+        options.secureProtocol = httpsAgent.options.secureProtocol;
+    }
+    return options;
+  }
+  static extractProxyConfig(proxyAgent) {
+    return proxyAgent.proxy || proxyAgent.proxyOptions || undefined;
+  }
+  static createMergedAgent(options) {
+    const { proxy, customAgent, isSecure = false, capabilities = {} } = options;
+    return this.merge({
+      proxy,
+      httpAgent: !isSecure ? customAgent : undefined,
+      httpsAgent: isSecure ? customAgent : undefined,
+      isSecure,
+      mergeOptions: capabilities
+    });
+  }
+  static isProxyAgent(agent) {
+    return !!agent.proxy || !!agent.proxyOptions;
+  }
+  static getProxyInfo(agent) {
+    return agent.proxy || agent.proxyOptions || null;
+  }
+}
+export function mergeAgents(proxy, customAgent, isSecure = false) {
+  return AgentMerger.merge({
+    proxy,
+    httpAgent: !isSecure ? customAgent : undefined,
+    httpsAgent: isSecure ? customAgent : undefined,
+    isSecure
+  });
+}

package/dist/utils/compression.cjs

@@ -0,0 +1,84 @@
+const { createGunzip, createInflate, createBrotliDecompress } = require("node:zlib");
+const { Transform } = require("node:stream");
+let createZstdDecompress = null;
+let zstdAvailable = null;
+function getZstdDecompressor() {
+  if (zstdAvailable === null) {
+    try {
+      const zlib = require("node:zlib");
+      if (typeof zlib.createZstdDecompress === "function") {
+        createZstdDecompress = zlib.createZstdDecompress;
+        zstdAvailable = true;
+      } else {
+        zstdAvailable = false;
+      }
+    } catch {
+      zstdAvailable = false;
+    }
+  }
+  return createZstdDecompress;
+}
+
+class CompressionUtil {
+  static decompressStream(response, contentEncoding, config) {
+    if (!contentEncoding) {
+      return response;
+    }
+    if (!this.shouldDecompress(contentEncoding, config)) {
+      return response;
+    }
+    const encoding = contentEncoding.toLowerCase();
+    switch (encoding) {
+      case "gzip":
+      case "x-gzip":
+        return response.pipe(createGunzip());
+      case "deflate":
+      case "x-deflate":
+        return response.pipe(createInflate());
+      case "gzip-raw":
+        return response.pipe(createInflate({ windowBits: 15 }));
+      case "br":
+      case "brotli":
+        return response.pipe(createBrotliDecompress());
+      case "zstd":
+        return this.createZstdDecompressStream(response);
+      default:
+        return response;
+    }
+  }
+  static shouldDecompress(contentEncoding, config) {
+    if (!config) {
+      return true;
+    }
+    if (config.compression?.enabled === false) {
+      return false;
+    }
+    if (config.compression?.enabled === undefined) {
+      if (config.compression?.algorithms) {
+        return config.compression.algorithms.includes(contentEncoding.toLowerCase());
+      }
+      return true;
+    }
+    return config.compression.enabled;
+  }
+  static createZstdDecompressStream(response) {
+    const decompressor = getZstdDecompressor();
+    if (!decompressor) {
+      const passthrough = new Transform({
+        transform(chunk, encoding, callback) {
+          callback(new Error("zstd decompression not available: requires Node.js 22.15+ with native zstd support"));
+        }
+      });
+      return response.pipe(passthrough);
+    }
+    return response.pipe(decompressor());
+  }
+  static getSupportedAlgorithms() {
+    return ["gzip", "x-gzip", "deflate", "x-deflate", "gzip-raw", "br", "brotli", "zstd"];
+  }
+  static isSupported(contentEncoding) {
+    return this.getSupportedAlgorithms().includes(contentEncoding.toLowerCase());
+  }
+}
+
+exports.CompressionUtil = CompressionUtil;

package/dist/utils/compression.js

@@ -0,0 +1,82 @@
+import { createGunzip, createInflate, createBrotliDecompress } from "node:zlib";
+import { Transform } from "node:stream";
+let createZstdDecompress = null;
+let zstdAvailable = null;
+function getZstdDecompressor() {
+  if (zstdAvailable === null) {
+    try {
+      const zlib = require("node:zlib");
+      if (typeof zlib.createZstdDecompress === "function") {
+        createZstdDecompress = zlib.createZstdDecompress;
+        zstdAvailable = true;
+      } else {
+        zstdAvailable = false;
+      }
+    } catch {
+      zstdAvailable = false;
+    }
+  }
+  return createZstdDecompress;
+}
+
+export class CompressionUtil {
+  static decompressStream(response, contentEncoding, config) {
+    if (!contentEncoding) {
+      return response;
+    }
+    if (!this.shouldDecompress(contentEncoding, config)) {
+      return response;
+    }
+    const encoding = contentEncoding.toLowerCase();
+    switch (encoding) {
+      case "gzip":
+      case "x-gzip":
+        return response.pipe(createGunzip());
+      case "deflate":
+      case "x-deflate":
+        return response.pipe(createInflate());
+      case "gzip-raw":
+        return response.pipe(createInflate({ windowBits: 15 }));
+      case "br":
+      case "brotli":
+        return response.pipe(createBrotliDecompress());
+      case "zstd":
+        return this.createZstdDecompressStream(response);
+      default:
+        return response;
+    }
+  }
+  static shouldDecompress(contentEncoding, config) {
+    if (!config) {
+      return true;
+    }
+    if (config.compression?.enabled === false) {
+      return false;
+    }
+    if (config.compression?.enabled === undefined) {
+      if (config.compression?.algorithms) {
+        return config.compression.algorithms.includes(contentEncoding.toLowerCase());
+      }
+      return true;
+    }
+    return config.compression.enabled;
+  }
+  static createZstdDecompressStream(response) {
+    const decompressor = getZstdDecompressor();
+    if (!decompressor) {
+      const passthrough = new Transform({
+        transform(chunk, encoding, callback) {
+          callback(new Error("zstd decompression not available: requires Node.js 22.15+ with native zstd support"));
+        }
+      });
+      return response.pipe(passthrough);
+    }
+    return response.pipe(decompressor());
+  }
+  static getSupportedAlgorithms() {
+    return ["gzip", "x-gzip", "deflate", "x-deflate", "gzip-raw", "br", "brotli", "zstd"];
+  }
+  static isSupported(contentEncoding) {
+    return this.getSupportedAlgorithms().includes(contentEncoding.toLowerCase());
+  }
+}