hyperttp 0.2.1 → 0.2.3

package/dist/Hyperttp/Core/HttpClientImproved.js

@@ -1,750 +1,439 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const tough_cookie_1 = require("tough-cookie");
-const undici_1 = require("undici");
-const undici_2 = require("http-cookie-agent/undici");
-const zlib = __importStar(require("zlib"));
-const util_1 = require("util");
-const fast_xml_parser_1 = require("fast-xml-parser");
-const CacheManager_1 = require("./CacheManager");
-const QueueManager_1 = require("./QueueManager");
-const RateLimiter_1 = require("./RateLimiter");
-const Types_1 = require("../../Types");
-const RequestBuilder_1 = require("./RequestBuilder");
-const gunzip = (0, util_1.promisify)(zlib.gunzip);
-const inflate = (0, util_1.promisify)(zlib.inflate);
-const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
+const undici_1 = require("http-cookie-agent/undici");
+const CacheManager_js_1 = require("./CacheManager.js");
+const QueueManager_js_1 = require("./QueueManager.js");
+const RateLimiter_js_1 = require("./RateLimiter.js");
+const MetricsManager_js_1 = require("./MetricsManager.js");
+const RequestBuilder_js_1 = require("./RequestBuilder.js");
+const InterceptorManager_js_1 = require("./InterceptorManager.js");
+const ResponseTransformer_js_1 = require("./ResponseTransformer.js");
+const RequestExecutor_js_1 = require("./RequestExecutor.js");
+const index_js_1 = require("../../Types/index.js");
 /**
- * Advanced HTTP client with built-in caching, rate limiting, request queuing,
- * automatic retries, cookie management, and response decompression.
+ * @class HttpClientImproved
+ * @en High-performance HTTP client with built-in caching, queuing, rate limiting, and metrics.
+ * @ru Высокопроизводительный HTTP-клиент со встроенным кэшированием, очередями, лимитами и метриками.
  */
 class HttpClientImproved {
-    cookieJar = new tough_cookie_1.CookieJar();
     agent;
+    options;
     cache;
     queue;
     limiter;
-    inflight = new Map();
-    retryOptions;
-    defaultHeaders = {};
-    options;
-    requestInterceptors = [];
-    responseInterceptors = [];
-    requestMetrics = new Map();
+    metricsManager;
+    interceptors;
+    transformer;
+    executor;
     /**
-     * Creates a new instance of HttpClientImproved.
-     * @param options Optional configuration options for the HTTP client
+     * @en Internal map to track active requests for deduplication and cancellation.
+     * @ru Внутренняя карта для отслеживания активных запросов (дедупликация и отмена).
      */
+    inflight = new Map();
+    defaultHeaders = {};
     constructor(options) {
-        this.options = {
-            timeout: options?.timeout ?? 15000,
-            maxConcurrent: options?.maxConcurrent ?? 50,
-            maxRetries: options?.maxRetries ?? 3,
-            cacheTTL: options?.cacheTTL ?? 300000,
-            cacheMaxSize: options?.cacheMaxSize ?? 500,
-            followRedirects: options?.followRedirects ?? true,
-            maxRedirects: options?.maxRedirects ?? 5,
-            validateStatus: options?.validateStatus ??
-                ((status) => status >= 200 && status < 300),
-            cacheMethods: options?.cacheMethods ?? ["GET", "HEAD"],
-            maxMetricsSize: options?.maxMetricsSize ?? 1000,
-            rateLimit: options?.rateLimit ?? { maxRequests: 100, windowMs: 60000 },
-            userAgent: options?.userAgent ?? "Hyperttp/0.1.0 Node.js",
-            logger: options?.logger ??
-                ((level, message, meta) => {
-                    const methods = {
-                        debug: console.debug,
-                        info: console.info,
-                        warn: console.warn,
-                        error: console.error,
-                    };
-                    (methods[level] || console.log)(`[${level.toUpperCase()}] ${message}`, meta || "");
-                }),
-            retryOptions: options?.retryOptions ?? {},
-            maxResponseBytes: options?.maxResponseBytes ?? 1024 * 1024,
-            verbose: false,
-            enableQueue: options?.enableQueue ?? false,
-            enableRateLimit: options?.enableRateLimit ?? false,
-            enableCache: options?.enableCache ?? true,
-        };
+        this.options = this.applyDefaultOptions(options);
+        this.metricsManager = new MetricsManager_js_1.MetricsManager({
+            maxHistory: this.options.maxMetricsSize,
+        });
+        this.interceptors = new InterceptorManager_js_1.InterceptorManager();
+        this.transformer = new ResponseTransformer_js_1.ResponseTransformer(this.options.maxResponseBytes, this.options.logger);
         if (this.options.enableCache) {
-            this.cache = new CacheManager_1.CacheManager({
+            this.cache = new CacheManager_js_1.CacheManager({
                 cacheTTL: this.options.cacheTTL,
                 cacheMaxSize: this.options.cacheMaxSize,
             });
         }
         if (this.options.enableQueue) {
-            this.queue = new QueueManager_1.QueueManager(this.options.maxConcurrent ?? 500);
+            this.queue = new QueueManager_js_1.QueueManager(this.options.maxConcurrent ?? 500);
         }
         if (this.options.enableRateLimit) {
-            this.limiter = new RateLimiter_1.RateLimiter(this.options.rateLimit);
+            this.limiter = new RateLimiter_js_1.RateLimiter(this.options.rateLimit);
         }
-        this.retryOptions = {
-            maxRetries: this.options.maxRetries ?? 5,
-            baseDelay: this.options.retryOptions?.baseDelay ?? 1000,
-            maxDelay: this.options.retryOptions?.maxDelay ?? 30000,
-            retryStatusCodes: this.options.retryOptions?.retryStatusCodes ?? [
-                408, 429, 500, 502, 503, 504,
-            ],
-            jitter: this.options.retryOptions?.jitter ?? true,
-        };
-        this.defaultHeaders = {
-            Accept: "application/json, text/plain, */*",
-            "Accept-Encoding": "gzip, deflate, br",
-            "User-Agent": this.options.userAgent ?? "Hyperttp/0.1.0 Node.js",
-        };
-        this.agent = new undici_1.Agent({
+        this.agent = new undici_1.CookieAgent({
             connections: 1000,
             pipelining: 10,
             keepAliveTimeout: 60000,
-            keepAliveMaxTimeout: 600000,
-            interceptors: {
-                Client: [(0, undici_2.cookie)({ jar: this.cookieJar })],
-            },
         });
+        this.executor = new RequestExecutor_js_1.RequestExecutor(this.agent, this.interceptors, {
+            timeout: this.options.timeout,
+            maxRetries: this.options.maxRetries,
+            followRedirects: this.options.followRedirects,
+            maxRedirects: this.options.maxRedirects,
+            retryOptions: this.options.retryOptions,
+            verbose: this.options.verbose,
+            logger: this.options.logger,
+        });
+        this.defaultHeaders = {
+            Accept: "application/json, text/plain, */*",
+            "Accept-Encoding": "gzip, deflate, br",
+            "User-Agent": this.options.userAgent,
+        };
     }
     /**
-     * Sets default headers that will be applied to all outgoing requests.
-     * @param headers An object containing header names and values
-     */
-    setDefaultHeaders(headers) {
-        Object.assign(this.defaultHeaders, headers);
-    }
-    /**
-     * Returns the cookie jar used for managing HTTP cookies.
-     * @returns The CookieJar instance
-     */
-    getCookieJar() {
-        return this.cookieJar;
-    }
-    /**
-     * Adds a request interceptor to modify requests before they are sent.
-     * @param interceptor The interceptor function to add
-     */
-    addRequestInterceptor(interceptor) {
-        this.requestInterceptors.push(interceptor);
-    }
-    /**
-     * Adds a response interceptor to modify responses after they are received.
-     * @param interceptor The interceptor function to add
+     * @en Core internal method for handling all HTTP requests.
+     * @ru Основной внутренний метод для обработки всех HTTP-запросов.
+     * @param method HTTP method (GET, POST, etc.)
+     * @param req Request object
+     * @param useCache Whether to use caching for this request
+     * @param responseType Expected response format
      */
-    addResponseInterceptor(interceptor) {
-        this.responseInterceptors.push(interceptor);
-    }
-    /** Closes the HTTP agent to properly terminate keep-alive connections. */
-    close() {
-        this.agent.close();
-    }
-    log(level, msg, meta) {
-        if (this.options.verbose) {
-            if (this.options.logger)
-                this.options.logger(level, msg, meta);
-        }
-    }
-    async decompress(buf, enc, charset = "utf-8") {
-        if (!enc)
-            return buf.toString(charset);
-        try {
-            switch (enc.toLowerCase()) {
-                case "gzip":
-                    return (await gunzip(buf)).toString(charset);
-                case "deflate":
-                    return (await inflate(buf)).toString(charset);
-                case "br":
-                    return (await brotliDecompress(buf)).toString(charset);
-                default:
-                    return buf.toString(charset);
-            }
-        }
-        catch (error) {
-            this.log("error", `Decompression failed for encoding ${enc}`, error);
-            return buf.toString(charset);
-        }
-    }
-    calcDelay(attempt) {
-        const base = Math.min(this.retryOptions.baseDelay * 2 ** attempt, this.retryOptions.maxDelay);
-        return this.retryOptions.jitter
-            ? base * (0.75 + Math.random() * 0.5)
-            : base;
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    async applyRequestInterceptors(config) {
-        let result = config;
-        for (const interceptor of this.requestInterceptors)
-            result = await interceptor(result);
-        return result;
-    }
-    async applyResponseInterceptors(response) {
-        let result = response;
-        for (const interceptor of this.responseInterceptors)
-            result = await interceptor(result);
-        return result;
-    }
-    resolveRedirect(location, baseUrl) {
-        try {
-            return new URL(location, baseUrl).toString();
-        }
-        catch {
-            return location;
-        }
-    }
-    parseRetryAfterMs(retryAfterHeader) {
-        if (!retryAfterHeader)
-            return undefined;
-        const raw = Array.isArray(retryAfterHeader)
-            ? retryAfterHeader[0]
-            : String(retryAfterHeader);
-        const asSeconds = Number(raw);
-        if (Number.isFinite(asSeconds))
-            return Math.max(0, Math.floor(asSeconds * 1000));
-        const asDate = Date.parse(raw);
-        if (!Number.isNaN(asDate))
-            return Math.max(0, asDate - Date.now());
-        return undefined;
-    }
-    async readBodyWithLimit(body) {
-        const buf = Buffer.from(await body.arrayBuffer());
-        const limit = this.options.maxResponseBytes;
-        if (typeof limit === "number" && limit > 0 && buf.length > limit) {
-            throw new Types_1.HttpClientError(`Response too large (${buf.length} bytes), limit is ${limit}`, 0);
-        }
-        return buf;
-    }
-    async sendWithRetry(method, url, headers, body, metrics, redirects = 0) {
-        let lastError;
-        for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) {
-            try {
-                if (this.limiter && this.options.enableRateLimit) {
-                    await this.limiter.wait();
-                }
-                const finalConfig = await this.applyRequestInterceptors({
-                    url,
-                    method,
-                    headers,
-                    body,
-                });
-                const controller = new AbortController();
-                const timeout = this.options.timeout ?? 15000;
-                const timer = setTimeout(() => controller.abort(), timeout);
-                try {
-                    const res = await (0, undici_1.request)(finalConfig.url, {
-                        method: finalConfig.method,
-                        headers: finalConfig.headers,
-                        body: finalConfig.body,
-                        dispatcher: this.agent,
-                        signal: controller.signal,
-                    });
-                    clearTimeout(timer);
-                    const buf = await this.readBodyWithLimit(res.body);
-                    let response = await this.applyResponseInterceptors({
-                        status: res.statusCode,
-                        headers: res.headers,
-                        body: buf,
-                        url: finalConfig.url,
-                    });
-                    // Redirects
-                    if (this.options.followRedirects &&
-                        [301, 302, 303, 307, 308].includes(response.status) &&
-                        redirects < (this.options.maxRedirects ?? 5)) {
-                        const location = response.headers.location;
-                        if (location) {
-                            const nextUrl = this.resolveRedirect(location, finalConfig.url);
-                            const redirectMethod = response.status === 303 ? "GET" : method;
-                            const nextHeaders = { ...headers };
-                            let nextBody = body;
-                            // If switching to GET, drop body-related headers.
-                            if (redirectMethod === "GET") {
-                                nextBody = undefined;
-                                delete nextHeaders["content-type"];
-                                delete nextHeaders["Content-Type"];
-                                delete nextHeaders["content-length"];
-                                delete nextHeaders["Content-Length"];
-                            }
-                            this.log("debug", `Redirecting to ${nextUrl}`, {
-                                originalUrl: finalConfig.url,
-                                status: response.status,
-                            });
-                            return this.sendWithRetry(redirectMethod, nextUrl, nextHeaders, nextBody, metrics, redirects + 1);
-                        }
-                    }
-                    // Retry by status
-                    if (this.retryOptions.retryStatusCodes.includes(response.status)) {
-                        metrics && (metrics.retries += 1);
-                        if (response.status === 429) {
-                            const ra = this.parseRetryAfterMs(response.headers["retry-after"]);
-                            if (ra !== undefined) {
-                                this.log("warn", `429 Rate limited, waiting Retry-After ${ra}ms`, { url: finalConfig.url });
-                                if (attempt < this.retryOptions.maxRetries) {
-                                    await this.sleep(ra);
-                                    continue;
-                                }
-                                throw new Types_1.RateLimitError(finalConfig.url, ra);
-                            }
-                        }
-                        this.log("warn", `Retrying ${method} ${finalConfig.url} due to status ${response.status}`, {
-                            attempt: attempt + 1,
-                            maxRetries: this.retryOptions.maxRetries,
-                        });
-                        if (attempt < this.retryOptions.maxRetries) {
-                            await this.sleep(this.calcDelay(attempt));
-                            continue;
-                        }
-                    }
-                    return response;
-                }
-                catch (timeoutErr) {
-                    clearTimeout(timer);
-                    if (timeoutErr?.name === "AbortError")
-                        throw new Types_1.TimeoutError(url, timeout);
-                    throw timeoutErr;
-                }
-                finally {
-                    clearTimeout(timer);
-                }
-            }
-            catch (err) {
-                lastError = err;
-                this.log("error", `Request error ${method} ${url}: ${err?.message ?? String(err)}`, {
-                    attempt: attempt + 1,
-                    error: err,
-                });
-                metrics && (metrics.retries += 1);
-                if (attempt < this.retryOptions.maxRetries) {
-                    await this.sleep(this.calcDelay(attempt));
-                    continue;
-                }
-            }
-        }
-        if (lastError instanceof Types_1.HttpClientError)
-            throw lastError;
-        throw new Types_1.HttpClientError(`Request failed after ${this.retryOptions.maxRetries + 1} attempts`, undefined, lastError instanceof Error ? lastError : undefined, url, method);
-    }
-    parseContentType(contentType) {
-        if (!contentType)
-            return { type: "text/plain", charset: "utf-8" };
-        const parts = contentType.split(";");
-        const type = parts[0].trim();
-        const rawCharset = parts
-            .map((p) => p.trim())
-            .find((p) => p.toLowerCase().startsWith("charset="))
-            ?.split("=")[1]
-            ?.trim() || "utf-8";
-        const normalized = rawCharset.toLowerCase();
-        const allowed = [
-            "utf8",
-            "utf-8",
-            "latin1",
-            "ucs2",
-            "ucs-2",
-            "utf16le",
-            "utf-16le",
-            "ascii",
-            "base64",
-            "hex",
-        ];
-        const charset = (allowed.includes(normalized)
-            ? normalized
-            : "utf-8");
-        return { type, charset };
-    }
-    xmlParser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        allowBooleanAttributes: true,
-    });
-    async parseResponse(res, responseType) {
-        try {
-            const contentType = res.headers["content-type"] || "";
-            const text = await this.decompress(res.body, res.headers["content-encoding"]);
-            const finalType = responseType ?? "json";
-            switch (finalType) {
-                case "json": {
-                    if (contentType.includes("json")) {
-                        return JSON.parse(text);
-                    }
-                    if (text.trim().startsWith("<")) {
-                        return this.xmlParser.parse(text);
-                    }
-                    return { text };
-                }
-                case "xml": {
-                    const text = await this.decompress(res.body, res.headers["content-encoding"]);
-                    if (text.trim().startsWith("<")) {
-                        return text;
-                    }
-                    try {
-                        const json = JSON.parse(text);
-                        return new fast_xml_parser_1.XMLBuilder({ format: true }).build({ root: json });
-                    }
-                    catch {
-                        return String(text);
-                    }
-                }
-                case "text":
-                    return text;
-                case "buffer":
-                    return res.body;
-                case "stream":
-                    return res.body;
-                default:
-                    return text;
-            }
-        }
-        catch (error) {
-            this.log("error", "Failed to parse response", {
-                error,
-                status: res.status,
-                contentType: res.headers["content-type"],
-            });
-            throw new Types_1.HttpClientError(`Response parsing failed: ${error instanceof Error ? error.message : String(error)}`, res.status);
-        }
-    }
-    async requestInternal(method, req, useCache = true, responseType) {
+    async requestInternal(method, req, useCache = true, responseType = "auto") {
         const url = req.getURL();
-        const rawBody = req.getBodyData();
-        const headers = {
-            ...this.defaultHeaders,
-            ...req.getHeaders(),
-        };
-        const isBodyAllowed = ["POST", "PUT", "PATCH", "DELETE"].includes(method);
-        let body;
-        const contentType = headers["content-type"] || headers["Content-Type"] || "";
-        if (isBodyAllowed && rawBody !== undefined && rawBody !== null) {
-            if (Buffer.isBuffer(rawBody)) {
-                body = rawBody;
-            }
-            else if (typeof rawBody === "string") {
-                body = rawBody;
-            }
-            else if (contentType.includes("application/x-www-form-urlencoded")) {
-                body = new URLSearchParams(rawBody).toString();
-            }
-            else {
-                body = JSON.stringify(rawBody);
-                if (!contentType) {
-                    headers["Content-Type"] = "application/json; charset=utf-8";
-                }
-            }
+        if (this.metricsManager.isCircuitOpen(url)) {
+            throw new index_js_1.HttpClientError(`Circuit Breaker is OPEN`, "CIRCUIT_OPEN", 503, undefined, url, method);
+        }
+        if (this.limiter && this.options.enableRateLimit) {
+            await this.limiter.wait();
         }
-        const key = `${method}:${url}:${body ?? ""}`;
+        const { body, headers } = this.prepareRequestData(method, req);
+        const key = method === "GET"
+            ? `GET:${url}`
+            : `${method}:${url}:${body ? JSON.stringify(body) : ""}`;
         if (method === "GET" && useCache && this.cache) {
             const cached = await this.cache.get(key);
-            if (cached) {
-                this.log("debug", `Cache hit for ${url}`);
+            if (cached)
                 return cached;
-            }
         }
-        if (this.inflight.has(key)) {
-            this.log("debug", `Deduplicating request for ${url}`);
-            return this.inflight.get(key);
+        if (this.inflight.has(key))
+            return this.inflight.get(key).promise;
+        const internalController = new AbortController();
+        const userSignal = req.getSignal?.();
+        const abortHandler = () => internalController.abort();
+        if (userSignal) {
+            userSignal.addEventListener("abort", abortHandler, { once: true });
         }
-        const promise = (async () => {
-            const metrics = {
-                startTime: Date.now(),
-                endTime: 0,
-                duration: 0,
-                bytesReceived: 0,
-                bytesSent: 0,
-                retries: 0,
-                cached: false,
-                url,
-                method,
-            };
+        const executeAction = async () => {
+            const metrics = this.createInitialMetrics(url, method);
             try {
-                let result;
-                const res = await this.sendWithRetry(method, url, headers, body, metrics);
-                metrics.statusCode = res.status;
-                metrics.bytesReceived = res.body.length;
-                metrics.bytesSent =
-                    body instanceof Buffer ? body.length : Buffer.byteLength(body || "");
-                if (method === "HEAD") {
-                    metrics.endTime = Date.now();
-                    metrics.duration = metrics.endTime - metrics.startTime;
-                    this.requestMetrics.set(key, metrics);
-                    this.log("info", `${method} ${url} completed in ${metrics.duration}ms`, metrics);
+                const rawResponse = await this.executor.execute(method, url, headers, body, metrics, internalController.signal);
+                const bufferBody = await this.transformer.readBodyWithLimit(rawResponse.body);
+                this.metricsManager.recordBytes(bufferBody.length);
+                const parsed = await this.transformer.parseResponse({ ...rawResponse, body: bufferBody }, responseType);
+                if (method === "HEAD")
                     return {
-                        status: res.status,
-                        headers: res.headers,
+                        status: rawResponse.status,
+                        headers: rawResponse.headers,
                     };
-                }
-                const parsed = await this.parseResponse(res, responseType);
-                if (method === "GET" && useCache && this.cache) {
+                if (method === "GET" &&
+                    useCache &&
+                    this.cache &&
+                    parsed !== undefined) {
                     this.cache.set(key, parsed);
-                    metrics.cached = true;
                 }
-                result = parsed;
-                metrics.endTime = Date.now();
-                metrics.duration = metrics.endTime - metrics.startTime;
-                this.requestMetrics.set(key, metrics);
-                this.log("info", `${method} ${url} completed in ${metrics.duration}ms`, metrics);
-                return result;
+                this.recordSuccess(metrics, rawResponse.status);
+                return parsed;
             }
             catch (error) {
-                metrics.endTime = Date.now();
-                metrics.duration = metrics.endTime - metrics.startTime;
-                this.requestMetrics.set(key, metrics);
+                this.recordError(metrics, error);
                 throw error;
             }
             finally {
+                if (userSignal)
+                    userSignal.removeEventListener("abort", abortHandler);
                 this.inflight.delete(key);
             }
-        })();
-        this.inflight.set(key, promise);
+        };
+        const promise = this.options.enableQueue && this.queue
+            ? this.queue.enqueue(() => executeAction())
+            : executeAction();
+        this.inflight.set(key, { promise, controller: internalController });
         return promise;
     }
     /**
-     * Performs an HTTP GET request.
-     * @param req The request object containing URL and headers
-     * @param responseType Optional response parsing type
-     * @returns A promise that resolves to the parsed response
-     * @template T The expected response type
+     * @en Performs an HTTP GET request.
+     * @ru Выполняет HTTP GET запрос.
+     * @param req Request URL or Request object
+     * @param responseType Expected response format
      */
-    get(req, responseType = "json") {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
-            };
-            return this.requestInternal("GET", simpleReq, true, responseType);
-        }
-        else {
-            return this.requestInternal("GET", req, true, responseType);
-        }
+    get(req, responseType = "auto") {
+        const requestObj = this.normalizeRequest(req);
+        return this.requestInternal("GET", requestObj, true, responseType);
     }
     /**
-     * Performs an HTTP POST request.
-     * @param req The request object containing URL, body, and headers
-     * @param responseType Optional response parsing type
-     * @returns A promise that resolves to the parsed response
-     * @template T The expected response type
+     * @en Performs an HTTP POST request.
+     * @ru Выполняет HTTP POST запрос.
+     * @param req Request URL or Request object
+     * @param body Request body data
+     * @param responseType Expected response format
      */
-    post(req, body, responseType = "json") {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => body,
-                getHeaders: () => ({ "Content-Type": "application/json" }),
-            };
-            return this.requestInternal("POST", simpleReq, false, responseType);
-        }
-        else {
-            return this.requestInternal("POST", req, false, responseType);
-        }
+    post(req, body, responseType = "auto") {
+        const requestObj = this.normalizeRequest(req, body);
+        return this.requestInternal("POST", requestObj, false, responseType);
     }
     /**
-     * Performs an HTTP PUT request.
-     * @param req The request object containing URL, body, and headers
-     * @param responseType Optional response parsing type
-     * @returns A promise that resolves to the parsed response
-     * @template T The expected response type
+     * @en Performs an HTTP PUT request.
+     * @ru Выполняет HTTP PUT запрос.
      */
-    put(req, body, responseType = "json") {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => body,
-                getHeaders: () => ({ "Content-Type": "application/json" }),
-            };
-            return this.requestInternal("PUT", simpleReq, false, responseType);
-        }
-        return this.requestInternal("PUT", req, false, responseType);
+    put(req, body, responseType = "auto") {
+        const requestObj = this.normalizeRequest(req, body);
+        return this.requestInternal("PUT", requestObj, false, responseType);
     }
     /**
-     * Performs an HTTP DELETE request.
-     * @param req The request object containing URL and headers
-     * @param responseType Optional response parsing type
-     * @returns A promise that resolves to the parsed response
-     * @template T The expected response type
+     * @en Performs an HTTP DELETE request.
+     * @ru Выполняет HTTP DELETE запрос.
      */
-    delete(req, responseType = "json") {
-        if (typeof req === "string") {
-            const client = new HttpClientImproved();
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
-            };
-            return client.delete(simpleReq, responseType);
-        }
-        return this.requestInternal("DELETE", req, false, responseType);
+    delete(req, responseType = "auto") {
+        const requestObj = this.normalizeRequest(req);
+        return this.requestInternal("DELETE", requestObj, false, responseType);
     }
     /**
-     * Performs an HTTP PATCH request.
-     * @param req The request object containing URL, body, and headers
-     * @param responseType Optional response parsing type
-     * @returns A promise that resolves to the parsed response
-     * @template T The expected response type
+     * @en Performs an HTTP PATCH request.
+     * @ru Выполняет HTTP PATCH запрос.
      */
-    patch(req, body, responseType = "json") {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => body,
-                getHeaders: () => ({ "Content-Type": "application/json" }),
-            };
-            return this.requestInternal("PATCH", simpleReq, false, responseType);
-        }
-        return this.requestInternal("PATCH", req, false, responseType);
+    patch(req, body, responseType = "auto") {
+        const requestObj = this.normalizeRequest(req, body);
+        return this.requestInternal("PATCH", requestObj, false, responseType);
     }
     /**
-     * @ru Получает потоковый ответ (для SSE, больших файлов).
-     * @en Gets streaming response (for SSE, large files).
+     * @en Creates a RequestBuilder for a fluent API approach.
+     * @ru Создает RequestBuilder для использования Fluent API.
+     * @example client.request('url').get().send();
      */
-    stream(req) {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
-            };
-            return this.stream(simpleReq);
+    request(url) {
+        return new RequestBuilder_js_1.RequestBuilder(url, this);
+    }
+    /**
+     * @en Releases all resources, aborts active requests, and closes connections.
+     * @ru Освобождает ресурсы клиента, отменяет активные запросы и закрывает соединения.
+     */
+    async destroy() {
+        if (this.inflight.size > 0) {
+            if (this.options.verbose) {
+                this.options.logger?.("info", `Aborting ${this.inflight.size} active requests...`);
+            }
+            for (const { controller } of this.inflight.values()) {
+                controller.abort();
+            }
+            this.inflight.clear();
         }
-        return (this.queue && this.options.enableQueue
-            ? this.queue.enqueue(async function () {
-                const url = req.getURL();
-                const headers = {
-                    ...this.defaultHeaders,
-                    ...req.getHeaders(),
-                };
-                const response = await (0, undici_1.request)(url, {
-                    method: "GET",
-                    headers,
-                    dispatcher: this.agent,
-                });
-                return {
-                    status: response.statusCode,
-                    headers: response.headers,
-                    body: response.body,
-                    url,
-                };
-            }.bind(this))
-            : async function () {
-                const url = req.getURL();
-                const headers = Object.assign({}, this.defaultHeaders, req.getHeaders());
-                const response = await (0, undici_1.request)(url, {
-                    method: "GET",
-                    headers,
-                    dispatcher: this.agent,
-                });
-                return {
-                    status: response.statusCode,
-                    headers: response.headers,
-                    body: response.body,
-                    url,
-                };
-            }.bind(this)());
+        if (this.agent) {
+            try {
+                if (typeof this.agent.destroy === "function") {
+                    await this.agent.destroy();
+                }
+                else if (typeof this.agent.close === "function") {
+                    await this.agent.close();
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (this.cache)
+            this.cache.clear();
     }
     /**
-     * Performs an HTTP HEAD request.
-     * @param req The request object containing URL and headers
-     * @returns A promise that resolves when the request completes
+     * @en Performs an HTTP HEAD request.
+     * @ru Выполняет HTTP HEAD запрос.
      */
     async head(req) {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
+        const requestObj = this.normalizeRequest(req);
+        return this.requestInternal("HEAD", requestObj, false);
+    }
+    /**
+     * @en Executes a request and returns an AsyncIterable stream.
+     * @ru Выполняет запрос и возвращает итерируемый поток данных.
+     */
+    async stream(req) {
+        const requestObj = this.normalizeRequest(req);
+        const url = requestObj.getURL();
+        const { body, headers } = this.prepareRequestData("GET", requestObj);
+        const key = `STREAM:GET:${url}`;
+        const internalController = new AbortController();
+        const userSignal = requestObj.getSignal?.();
+        const abortHandler = () => internalController.abort();
+        if (userSignal) {
+            userSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+        try {
+            const rawResponse = await this.executor.execute("GET", url, headers, body, undefined, internalController.signal);
+            this.inflight.set(key, {
+                promise: Promise.resolve(),
+                controller: internalController,
+            });
+            const cleanup = () => {
+                if (userSignal)
+                    userSignal.removeEventListener("abort", abortHandler);
+                this.inflight.delete(key);
+            };
+            rawResponse.body.on("close", cleanup);
+            rawResponse.body.on("error", cleanup);
+            return {
+                status: rawResponse.status,
+                headers: rawResponse.headers,
+                body: rawResponse.body,
+                url: rawResponse.url,
             };
-            return this.requestInternal("HEAD", simpleReq, false);
         }
-        return this.requestInternal("HEAD", req, false);
+        catch (error) {
+            if (userSignal)
+                userSignal.removeEventListener("abort", abortHandler);
+            throw error;
+        }
     }
     /**
-     * Clears the request cache.
+     * @en Clears the internal cache.
+     * @ru Полностью очищает внутренний кэш клиента.
      */
-    async clearCache() {
+    clearCache() {
         if (this.cache) {
-            await this.cache.clear();
-            this.log("info", "Cache cleared");
+            this.cache.clear();
         }
     }
     /**
-     * Clears all collected request metrics.
-     * Removes performance and timing data from memory.
+     * @en Clears all collected performance metrics.
+     * @ru Очищает все собранные метрики производительности.
      */
     clearMetrics() {
-        this.requestMetrics.clear();
-        this.log("info", "Metrics cleared");
+        this.metricsManager.clear();
+        this.options.logger?.("info", "Metrics cleared");
     }
     /**
-     * Retrieves metrics for a specific request by its URL.
-     * @param key - The URL or cache key to retrieve metrics for
-     * @returns Metrics object if found, undefined otherwise
+     * @en Retrieves metrics for a specific URL.
+     * @ru Получает метрики для конкретного URL.
      */
     getMetrics(key) {
-        return this.requestMetrics.get(key);
+        return this.metricsManager.get(key);
     }
     /**
-     * Retrieves all collected request metrics.
-     * @returns Array of all metrics objects
+     * @en Retrieves all stored request metrics.
+     * @ru Получает список всех сохраненных метрик.
      */
     getAllMetrics() {
-        return Array.from(this.requestMetrics.values());
+        return Array.from(this.metricsManager.getAll());
     }
     /**
-     * Creates a fluent request builder for making HTTP requests.
-     * Provides a chainable API for building and sending requests.
-     * @param url - The target URL for the request
-     * @returns RequestBuilder instance for chaining
-     */
-    request(url) {
-        return new RequestBuilder_1.RequestBuilder(url);
-    }
-    /**
-     * Returns current statistics about the HTTP client's state.
-     * @returns An object containing cache size, request counts, and rate limit information
+     * @en Returns real-time statistics about the client's internal state.
+     * @ru Возвращает статистику состояния клиента в реальном времени.
+     * @returns Cache size, active requests, queue state, etc.
      */
     getStats() {
         return {
             cacheSize: this.cache?.size ?? 0,
             inflightRequests: this.inflight.size,
-            queuedRequests: this.queue && this.options.enableQueue
+            queuedRequests: this.options.enableQueue && this.queue
                 ? (this.queue.queuedCount ?? 0)
                 : 0,
-            activeRequests: this.queue && this.options.enableQueue
+            activeRequests: this.options.enableQueue && this.queue
                 ? (this.queue.activeCount ?? 0)
                 : 0,
-            currentRateLimit: this.limiter && this.options.enableRateLimit
+            currentRateLimit: this.options.enableRateLimit && this.limiter
                 ? (this.limiter.currentCount ?? 0)
                 : 0,
         };
     }
+    normalizeRequest(req, body) {
+        if (typeof req === "string") {
+            return {
+                getURL: () => req,
+                getBodyData: () => body,
+                getHeaders: () => ({}),
+            };
+        }
+        return req;
+    }
+    applyDefaultOptions(opt) {
+        const defaults = {
+            timeout: 30000,
+            maxRetries: 3,
+            followRedirects: true,
+            maxRedirects: 5,
+            userAgent: "Hyperttp/2.0",
+            maxResponseBytes: 10 * 1024 * 1024, // 10MB
+            cacheTTL: 1000 * 60 * 5,
+            cacheMaxSize: 500,
+            enableCache: true,
+            enableQueue: true,
+            enableRateLimit: true,
+            retryOptions: {
+                maxRetries: 3,
+                baseDelay: 1000,
+                maxDelay: 10000,
+                retryStatusCodes: [408, 429, 500, 502, 503, 504],
+                jitter: true,
+            },
+        };
+        return { ...defaults, ...opt };
+    }
+    prepareRequestData(method, req) {
+        const headers = { ...this.defaultHeaders, ...req.getHeaders() };
+        let rawBody = req.getBodyData();
+        const methodsWithBody = ["POST", "PUT", "PATCH", "DELETE"];
+        if (!methodsWithBody.includes(method)) {
+            return { body: undefined, headers };
+        }
+        if (rawBody &&
+            typeof rawBody === "object" &&
+            !(rawBody instanceof Buffer)) {
+            const contentType = (headers["content-type"] ||
+                headers["Content-Type"] ||
+                "").toLowerCase();
+            if (contentType.includes("application/x-www-form-urlencoded")) {
+                const params = new URLSearchParams();
+                for (const [key, value] of Object.entries(rawBody)) {
+                    const finalValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+                    params.append(key, finalValue);
+                }
+                rawBody = params.toString();
+            }
+            else {
+                try {
+                    rawBody = JSON.stringify(rawBody);
+                    if (!headers["content-type"]) {
+                        headers["content-type"] = "application/json; charset=utf-8";
+                    }
+                }
+                catch {
+                    this.options.logger?.("error", `Serialization failed for ${method}`, {
+                        url: req.getURL(),
+                    });
+                    rawBody = String(rawBody);
+                }
+            }
+        }
+        return {
+            body: rawBody === null || rawBody === undefined ? undefined : rawBody,
+            headers,
+        };
+    }
+    createInitialMetrics(url, method) {
+        return {
+            startTime: Date.now(),
+            endTime: 0,
+            duration: 0,
+            bytesReceived: 0,
+            bytesSent: 0,
+            retries: 0,
+            cached: false,
+            url,
+            method,
+        };
+    }
+    recordSuccess(metrics, status) {
+        metrics.endTime = Date.now();
+        metrics.duration = metrics.endTime - metrics.startTime;
+        metrics.statusCode = status;
+        this.metricsManager.record(metrics);
+        if (this.options.verbose && this.options.logger) {
+            this.options.logger("info", `Request successful: ${metrics.method} ${metrics.url}`, {
+                duration: metrics.duration,
+                status: metrics.statusCode,
+            });
+        }
+    }
+    recordError(metrics, error) {
+        metrics.endTime = Date.now();
+        metrics.duration = metrics.endTime - metrics.startTime;
+        metrics.statusCode = error.statusCode || 0;
+        this.metricsManager.record(metrics);
+        if (this.options.verbose && this.options.logger) {
+            this.options.logger("error", `Request failed: ${metrics.method} ${metrics.url}`, {
+                error: error.message,
+                code: error.code,
+            });
+        }
+    }
 }
 exports.default = HttpClientImproved;
 //# sourceMappingURL=HttpClientImproved.js.map