hyperttp 0.2.2 → 0.2.3

package/dist/Hyperttp/Core/HttpClientImproved.js

@@ -1,757 +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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 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 fast_xml_builder_1 = __importDefault(require("fast-xml-builder"));
-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 MetricsManager_1 = require("./MetricsManager");
-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 = [];
     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.metricsManager = new MetricsManager_1.MetricsManager({
+        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_2.CookieAgent({
+        this.agent = new undici_1.CookieAgent({
             connections: 1000,
             pipelining: 10,
             keepAliveTimeout: 60000,
-            keepAliveMaxTimeout: 600000,
         });
+        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
-     */
-    addResponseInterceptor(interceptor) {
-        this.responseInterceptors.push(interceptor);
-    }
-    /**
-     * @ru Закрывает агент и освобождает ресурсы (keep-alive соединения).
-     * @en Closes the HTTP agent and terminates keep-alive connections.
+     * @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
      */
-    close() {
-        if (this.agent && typeof this.agent.destroy === "function") {
-            this.agent.destroy();
-        }
-    }
-    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 limit = this.options.maxResponseBytes;
-        const chunks = [];
-        let receivedBytes = 0;
-        for await (const chunk of body) {
-            receivedBytes += chunk.length;
-            if (typeof limit === "number" && limit > 0 && receivedBytes > limit) {
-                if (typeof body.destroy === "function")
-                    body.destroy();
-                throw new Types_1.HttpClientError(`Response too large`, "HTTP_ERROR", 0);
-            }
-            chunks.push(Buffer.from(chunk));
-        }
-        return Buffer.concat(chunks);
-    }
-    async sendWithRetry(method, url, headers, body, metrics, signal, redirects = 0) {
-        let lastError;
-        for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) {
-            const timeoutController = new AbortController();
-            const timeout = this.options.timeout ?? 15000;
-            const timer = setTimeout(() => timeoutController.abort(), timeout);
-            const abortHandler = () => timeoutController.abort();
-            if (signal) {
-                if (signal.aborted) {
-                    clearTimeout(timer);
-                    throw new Types_1.HttpClientError("Request aborted by user", "ABORTED", 0, undefined, url, method);
-                }
-                signal.addEventListener("abort", abortHandler);
-            }
-            try {
-                if (this.limiter && this.options.enableRateLimit) {
-                    await this.limiter.wait();
-                }
-                const finalConfig = await this.applyRequestInterceptors({
-                    url,
-                    method,
-                    headers,
-                    body,
-                });
-                try {
-                    const res = await (0, undici_1.request)(finalConfig.url, {
-                        method: finalConfig.method,
-                        headers: finalConfig.headers,
-                        body: finalConfig.body,
-                        dispatcher: this.agent,
-                        signal: timeoutController.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,
-                    });
-                    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 (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}`);
-                            return this.sendWithRetry(redirectMethod, nextUrl, nextHeaders, nextBody, metrics, signal, redirects + 1);
-                        }
-                    }
-                    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) {
-                                if (attempt < this.retryOptions.maxRetries) {
-                                    await this.sleep(ra);
-                                    continue;
-                                }
-                                throw new Types_1.RateLimitError(finalConfig.url, ra);
-                            }
-                        }
-                        if (attempt < this.retryOptions.maxRetries) {
-                            await this.sleep(this.calcDelay(attempt));
-                            continue;
-                        }
-                    }
-                    return response;
-                }
-                catch (innerErr) {
-                    clearTimeout(timer);
-                    if (innerErr.name === "AbortError") {
-                        if (signal?.aborted) {
-                            throw new Types_1.HttpClientError("Request aborted by user", "ABORTED", 0, innerErr, url, method);
-                        }
-                        else {
-                            throw new Types_1.TimeoutError(url, timeout);
-                        }
-                    }
-                    throw innerErr;
-                }
-            }
-            catch (err) {
-                lastError = err;
-                if (err.code === 'ECONNREFUSED') {
-                    this.log("error", `Соединение отклонено: проверьте, запущен ли сервер на ${url}`);
-                    throw new Types_1.HttpClientError(`Request failed: ${err.message}`, 'REQUEST_FAILED', undefined, err, url, method);
-                }
-                if (err.code === "ABORTED" || err instanceof Types_1.TimeoutError) {
-                    throw err;
-                }
-                this.log("error", `Request error ${method} ${url}: ${err?.message}`);
-                metrics && (metrics.retries += 1);
-                if (attempt < this.retryOptions.maxRetries) {
-                    await this.sleep(this.calcDelay(attempt));
-                    continue;
-                }
-            }
-            finally {
-                clearTimeout(timer);
-                if (signal) {
-                    signal.removeEventListener("abort", abortHandler);
-                }
-            }
-        }
-        if (lastError instanceof Types_1.HttpClientError)
-            throw lastError;
-        throw new Types_1.HttpClientError(`Request failed after ${this.retryOptions.maxRetries + 1} attempts`, "REQUEST_FAILED", undefined, lastError instanceof Error ? lastError : undefined, url, method);
-    }
-    xmlParser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        allowBooleanAttributes: true,
-    });
-    async parseResponse(res, responseType = "auto") {
-        try {
-            const text = await this.decompress(res.body, res.headers["content-encoding"]);
-            const trimmed = text.trim();
-            switch (responseType) {
-                case "json": {
-                    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-                        return JSON.parse(trimmed);
-                    }
-                    if (trimmed.startsWith("<")) {
-                        return this.xmlParser.parse(trimmed);
-                    }
-                    return { data: trimmed };
-                }
-                case "xml": {
-                    if (trimmed.startsWith("<"))
-                        return trimmed;
-                    try {
-                        const obj = JSON.parse(trimmed);
-                        const builder = new fast_xml_builder_1.default({
-                            format: true,
-                            indentBy: "  ",
-                            ignoreAttributes: false,
-                        });
-                        return builder.build(obj);
-                    }
-                    catch {
-                        return text;
-                    }
-                }
-                case "text":
-                    return text;
-                case "buffer":
-                    return res.body;
-                case "auto":
-                default: {
-                    const contentType = (res.headers["content-type"] || "").toLowerCase();
-                    if (contentType.includes("json") ||
-                        trimmed.startsWith("{") ||
-                        trimmed.startsWith("[")) {
-                        try {
-                            return JSON.parse(trimmed);
-                        }
-                        catch {
-                            return text;
-                        }
-                    }
-                    return text;
-                }
-            }
-        }
-        catch (err) {
-            throw new Types_1.HttpClientError(`Parsing failed: ${err?.message ?? String(err)}`, "PARSING_ERROR", res.status);
-        }
-    }
-    async requestInternal(method, req, useCache = true, responseType) {
+    async requestInternal(method, req, useCache = true, responseType = "auto") {
         const url = req.getURL();
         if (this.metricsManager.isCircuitOpen(url)) {
-            throw new Types_1.HttpClientError(`Circuit Breaker is OPEN for host: ${new URL(url).host}`, "CIRCUIT_OPEN", 503, undefined, url, method);
+            throw new index_js_1.HttpClientError(`Circuit Breaker is OPEN`, "CIRCUIT_OPEN", 503, undefined, url, method);
         }
-        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.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", `Memory 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);
         }
-        const signal = req.getSignal?.();
-        if (signal?.aborted) {
-            throw new Types_1.HttpClientError("Aborted before execution", "ABORTED", 0, undefined, url, method);
+        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 executeRequest = 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 {
-                const res = await this.sendWithRetry(method, url, headers, body, metrics, signal);
-                if (method === "HEAD") {
-                    metrics.endTime = Date.now();
-                    metrics.duration = metrics.endTime - metrics.startTime;
-                    this.metricsManager.record(metrics);
-                    return { status: res.status, headers: res.headers };
-                }
-                const parsed = await this.parseResponse(res, responseType);
-                if (method === "GET" && useCache && this.cache) {
+                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: rawResponse.status,
+                        headers: rawResponse.headers,
+                    };
+                if (method === "GET" &&
+                    useCache &&
+                    this.cache &&
+                    parsed !== undefined) {
                     this.cache.set(key, parsed);
                 }
-                metrics.endTime = Date.now();
-                metrics.duration = metrics.endTime - metrics.startTime;
-                metrics.statusCode = res.status;
-                this.metricsManager.record(metrics);
+                this.recordSuccess(metrics, rawResponse.status);
                 return parsed;
             }
             catch (error) {
-                metrics.endTime = Date.now();
-                metrics.duration = metrics.endTime - metrics.startTime;
-                this.metricsManager.record(metrics);
+                this.recordError(metrics, error);
                 throw error;
             }
             finally {
+                if (userSignal)
+                    userSignal.removeEventListener("abort", abortHandler);
                 this.inflight.delete(key);
             }
         };
-        const promise = this.options.enableQueue
-            ? this.queue.enqueue(() => executeRequest())
-            : executeRequest();
-        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 = "auto") {
-        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);
-        }
+        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 = "auto") {
-        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);
-        }
+        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 = "auto") {
-        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);
+        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 = "auto") {
-        if (typeof req === "string") {
-            const simpleReq = {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
-            };
-            return this.requestInternal("DELETE", simpleReq, false, responseType);
-        }
-        return this.requestInternal("DELETE", req, false, responseType);
+        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 = "auto") {
-        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);
+        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();
      */
-    async stream(req) {
-        const requestObj = typeof req === "string"
-            ? {
-                getURL: () => req,
-                getBodyData: () => undefined,
-                getHeaders: () => ({}),
-                getSignal: () => undefined,
+    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...`);
             }
-            : req;
-        const url = requestObj.getURL();
-        const signal = requestObj.getSignal?.();
-        if (signal?.aborted) {
-            throw new Types_1.HttpClientError("Request aborted before execution", "ABORTED", 0, undefined, url, "GET");
+            for (const { controller } of this.inflight.values()) {
+                controller.abort();
+            }
+            this.inflight.clear();
         }
-        const executeStream = async () => {
-            const headers = {
-                ...this.defaultHeaders,
-                ...requestObj.getHeaders(),
-            };
+        if (this.agent) {
             try {
-                const response = await (0, undici_1.request)(url, {
-                    method: "GET",
-                    headers,
-                    dispatcher: this.agent,
-                    signal,
-                    bodyTimeout: this.options.timeout,
-                    headersTimeout: this.options.timeout,
-                });
-                return {
-                    status: response.statusCode,
-                    headers: response.headers,
-                    body: response.body,
-                    url,
-                };
-            }
-            catch (err) {
-                if (err.name === "AbortError") {
-                    throw new Types_1.HttpClientError("Stream aborted by user", "ABORTED", 0, err, url, "GET");
+                if (typeof this.agent.destroy === "function") {
+                    await this.agent.destroy();
+                }
+                else if (typeof this.agent.close === "function") {
+                    await this.agent.close();
                 }
-                throw err;
             }
-        };
-        if (this.queue && this.options.enableQueue) {
-            return this.queue.enqueue(() => executeStream());
+            catch {
+                /* ignore */
+            }
         }
-        return executeStream();
+        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.metricsManager.clear();
-        this.log("info", "Metrics cleared");
+        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.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.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, this);
-    }
-    /**
-     * 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