hyperttp 0.1.7 → 0.1.9

package/dist/Hyperttp/Core/HttpClientImproved.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitError = exports.TimeoutError = exports.HttpClientError = void 0;
 const tough_cookie_1 = require("tough-cookie");
 const undici_1 = require("undici");
 const undici_2 = require("http-cookie-agent/undici");
@@ -10,53 +9,8 @@ const crypto_1 = require("crypto");
 const CacheManager_1 = require("./CacheManager");
 const QueueManager_1 = require("./QueueManager");
 const RateLimiter_1 = require("./RateLimiter");
+const Types_1 = require("../../Types");
 let defaultClient = null;
-/**
- * Base error class for HTTP client operations.
- * Contains additional context about the failed request including status code, URL, and method.
- */
-class HttpClientError extends Error {
-    statusCode;
-    originalError;
-    url;
-    method;
-    constructor(message, statusCode, originalError, url, method) {
-        super(message);
-        this.statusCode = statusCode;
-        this.originalError = originalError;
-        this.url = url;
-        this.method = method;
-        this.name = "HttpClientError";
-        Object.setPrototypeOf(this, HttpClientError.prototype);
-    }
-}
-exports.HttpClientError = HttpClientError;
-/**
- * Error thrown when an HTTP request exceeds the configured timeout duration.
- * Contains information about the URL and timeout value that caused the failure.
- */
-class TimeoutError extends HttpClientError {
-    constructor(url, timeout) {
-        super(`Request timeout after ${timeout}ms for ${url}`);
-        this.name = "TimeoutError";
-        Object.setPrototypeOf(this, TimeoutError.prototype);
-    }
-}
-exports.TimeoutError = TimeoutError;
-/**
- * Error thrown when an HTTP request is rate limited by the server.
- * Contains information about the URL and optional retry-after duration.
- */
-class RateLimitError extends HttpClientError {
-    retryAfter;
-    constructor(url, retryAfter) {
-        super(`Rate limited for ${url}${retryAfter ? `, retry after ${retryAfter}ms` : ""}`);
-        this.retryAfter = retryAfter;
-        this.name = "RateLimitError";
-        Object.setPrototypeOf(this, RateLimitError.prototype);
-    }
-}
-exports.RateLimitError = RateLimitError;
 /**
  * @ru
  * Улучшенный HTTP-клиент с кэшированием, ограничением скорости, логикой повторных попыток и расширенными функциями.
@@ -119,7 +73,10 @@ class HttpClientImproved {
     limiter;
     inflight = new Map();
     retryOptions;
-    defaultHeaders = {};
+    baseHeaders = Object.freeze({
+        Accept: "application/json, text/plain, */*",
+        "User-Agent": "Hyperttp/0.1.0 Node.js",
+    });
     options;
     requestInterceptors = [];
     responseInterceptors = [];
@@ -136,7 +93,7 @@ class HttpClientImproved {
             validateStatus: options?.validateStatus ??
                 ((status) => status >= 200 && status < 300),
             cacheMethods: options?.cacheMethods ?? ["GET", "HEAD"],
-            maxMetricsSize: options?.maxMetricsSize ?? 10000,
+            maxMetricsSize: options?.maxMetricsSize ?? 1000,
             rateLimit: options?.rateLimit ?? { maxRequests: 100, windowMs: 60000 },
             userAgent: options?.userAgent ?? "Hyperttp/0.1.0 Node.js",
             logger: options?.logger ??
@@ -152,13 +109,22 @@ class HttpClientImproved {
             retryOptions: options?.retryOptions ?? {},
             maxResponseBytes: options?.maxResponseBytes ?? 1024 * 1024,
             verbose: false,
+            enableQueue: options?.enableQueue ?? false,
+            enableRateLimit: options?.enableRateLimit ?? false,
+            enableCache: options?.enableCache ?? true,
         };
-        this.cache = new CacheManager_1.CacheManager({
-            cacheTTL: this.options.cacheTTL,
-            cacheMaxSize: this.options.cacheMaxSize,
-        });
-        this.queue = new QueueManager_1.QueueManager(this.options.maxConcurrent ?? 100);
-        this.limiter = new RateLimiter_1.RateLimiter(this.options.rateLimit);
+        if (this.options.enableCache) {
+            this.cache = new CacheManager_1.CacheManager({
+                cacheTTL: this.options.cacheTTL,
+                cacheMaxSize: this.options.cacheMaxSize,
+            });
+        }
+        if (this.options.enableQueue) {
+            this.queue = new QueueManager_1.QueueManager(this.options.maxConcurrent ?? 500);
+        }
+        if (this.options.enableRateLimit) {
+            this.limiter = new RateLimiter_1.RateLimiter(this.options.rateLimit);
+        }
         this.retryOptions = {
             maxRetries: this.options.maxRetries,
             baseDelay: this.options.retryOptions?.baseDelay ?? 1000,
@@ -168,13 +134,11 @@ class HttpClientImproved {
             ],
             jitter: this.options.retryOptions?.jitter ?? true,
         };
-        this.defaultHeaders = {
-            Accept: "application/json, text/plain, */*",
-            "User-Agent": this.options.userAgent ?? "Hyperttp/0.1.0 Node.js",
-        };
         this.agent = new undici_1.Agent({
-            connections: 256,
-            pipelining: 1,
+            connections: 1000,
+            pipelining: 10,
+            keepAliveTimeout: 60000,
+            keepAliveMaxTimeout: 600000,
             interceptors: {
                 Client: [(0, undici_2.cookie)({ jar: this.cookieJar })],
             },
@@ -305,31 +269,45 @@ class HttpClientImproved {
      * @param body - Async iterable of response chunks
      * @returns Complete response body as a Buffer
      */
-    async readBodyWithLimit(body) {
-        const chunks = [];
-        const limit = this.options.maxResponseBytes;
-        let total = 0;
-        for await (const chunk of body) {
-            const buf = Buffer.from(chunk);
-            total += buf.length;
-            if (limit && total > limit) {
-                throw new HttpClientError(`Response too large (${total} bytes), limit is ${limit}`, 0);
+    async readBodyWithLimit(body, maxBytes = this.options.maxResponseBytes) {
+        if (!body)
+            return Buffer.alloc(0);
+        // ⚡ максимально быстрый парсинг через arrayBuffer
+        if (body?.arrayBuffer) {
+            const arrayBuffer = await body.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        if (body[Symbol.asyncIterator]) {
+            const chunks = [];
+            let total = 0;
+            for await (const chunk of body) {
+                chunks.push(Buffer.from(chunk));
+                total += chunk.length;
+                if (total > maxBytes)
+                    break;
             }
-            chunks.push(buf);
+            return Buffer.concat(chunks);
         }
-        return Buffer.concat(chunks, total);
+        if (Buffer.isBuffer(body))
+            return body.subarray(0, maxBytes);
+        if (typeof body === "string")
+            return Buffer.from(body);
+        throw new TypeError(`Unsupported body type: ${typeof body}`);
     }
     /**
      * Removes old metrics entries to prevent memory leaks.
      * Keeps only metrics from the last 24 hours.
      */
     trimMetrics() {
-        if (this.requestMetrics.size > this.options.maxMetricsSize) {
-            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-            for (const [key, metrics] of this.requestMetrics) {
-                if (metrics.endTime < cutoff) {
-                    this.requestMetrics.delete(key);
-                }
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        for (const [key, metrics] of this.requestMetrics) {
+            if (metrics.endTime && metrics.endTime < cutoff) {
+                this.requestMetrics.delete(key);
+            }
+        }
+        for (const key of this.inflight.keys()) {
+            if (this.inflight.size > 1000) {
+                this.inflight.delete(key);
             }
         }
     }
@@ -344,11 +322,105 @@ class HttpClientImproved {
      * @param redirects - Number of redirects followed so far
      * @returns Promise resolving to the response data
      */
+    async sendOnce(method, url, headers, body, metrics, redirects = 0) {
+        let lastError;
+        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;
+            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,
+                });
+                if (method === "HEAD") {
+                    clearTimeout(timer);
+                    return {
+                        status: res.statusCode,
+                        headers: res.headers,
+                        body: Buffer.alloc(0),
+                        url: finalConfig.url,
+                    };
+                }
+                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.validateStatus(response.status)) {
+                    throw new Types_1.HttpClientError(`Request failed with status ${response.status}`, response.status, undefined, finalConfig.url, finalConfig.method);
+                }
+                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}`, {
+                            originalUrl: finalConfig.url,
+                            status: response.status,
+                        });
+                        return this.sendOnce(redirectMethod, nextUrl, nextHeaders, nextBody, metrics, redirects + 1);
+                    }
+                }
+                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)}`, {
+                error: err,
+            });
+            metrics && (metrics.retries += 1);
+        }
+        if (lastError instanceof Types_1.HttpClientError)
+            throw lastError;
+        throw new Types_1.HttpClientError(`Request failed after 1 attempt`, undefined, lastError instanceof Error ? lastError : undefined, url, method);
+    }
     async sendWithRetry(method, url, headers, body, metrics, redirects = 0) {
         let lastError;
+        if (this.retryOptions.maxRetries === 0) {
+            return this.sendOnce(method, url, headers, body, metrics, redirects);
+        }
         for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) {
             try {
-                await this.limiter.wait();
+                if (this.limiter && this.options.enableRateLimit) {
+                    await this.limiter.wait();
+                }
                 const finalConfig = await this.applyRequestInterceptors({
                     url,
                     method,
@@ -366,6 +438,15 @@ class HttpClientImproved {
                         dispatcher: this.agent,
                         signal: controller.signal,
                     });
+                    if (method === "HEAD") {
+                        clearTimeout(timer);
+                        return {
+                            status: res.statusCode,
+                            headers: res.headers,
+                            body: Buffer.alloc(0),
+                            url: finalConfig.url,
+                        };
+                    }
                     clearTimeout(timer);
                     const buf = await this.readBodyWithLimit(res.body);
                     let response = await this.applyResponseInterceptors({
@@ -375,7 +456,7 @@ class HttpClientImproved {
                         url: finalConfig.url,
                     });
                     if (!this.options.validateStatus(response.status)) {
-                        throw new HttpClientError(`Request failed with status ${response.status}`, response.status, undefined, finalConfig.url, finalConfig.method);
+                        throw new Types_1.HttpClientError(`Request failed with status ${response.status}`, response.status, undefined, finalConfig.url, finalConfig.method);
                     }
                     if (this.options.followRedirects &&
                         [301, 302, 303, 307, 308].includes(response.status) &&
@@ -410,7 +491,7 @@ class HttpClientImproved {
                                     await this.sleep(ra);
                                     continue;
                                 }
-                                throw new RateLimitError(finalConfig.url, ra);
+                                throw new Types_1.RateLimitError(finalConfig.url, ra);
                             }
                         }
                         this.log("warn", `Retrying ${method} ${finalConfig.url} due to status ${response.status}`, {
@@ -427,7 +508,7 @@ class HttpClientImproved {
                 catch (timeoutErr) {
                     clearTimeout(timer);
                     if (timeoutErr?.name === "AbortError")
-                        throw new TimeoutError(url, timeout);
+                        throw new Types_1.TimeoutError(url, timeout);
                     throw timeoutErr;
                 }
                 finally {
@@ -447,9 +528,9 @@ class HttpClientImproved {
                 }
             }
         }
-        if (lastError instanceof HttpClientError)
+        if (lastError instanceof Types_1.HttpClientError)
             throw lastError;
-        throw new HttpClientError(`Request failed after ${this.retryOptions.maxRetries + 1} attempts`, undefined, lastError instanceof Error ? lastError : undefined, url, method);
+        throw new Types_1.HttpClientError(`Request failed after ${this.retryOptions.maxRetries + 1} attempts`, undefined, lastError instanceof Error ? lastError : undefined, url, method);
     }
     /**
      * Parses the Content-Type header to extract MIME type and character encoding.
@@ -494,43 +575,33 @@ class HttpClientImproved {
      * @returns Parsed response data
      */
     async parseResponse(res, responseType) {
-        const { type, charset } = this.parseContentType(res.headers["content-type"]);
-        const text = res.body.toString(charset);
+        const { type } = this.parseContentType(res.headers["content-type"]);
         const finalType = responseType ?? (type.includes("application/json") ? "json" : "text");
         try {
             switch (finalType) {
-                case "json": {
-                    try {
-                        return JSON.parse(text);
-                    }
-                    catch {
-                        try {
-                            return new fast_xml_parser_1.XMLParser({ ignoreAttributes: false }).parse(text);
-                        }
-                        catch {
-                            return { data: text };
-                        }
-                    }
-                }
+                case "json":
+                    return JSON.parse(res.body.toString("utf8"));
                 case "xml": {
                     try {
-                        const jsonData = JSON.parse(text);
+                        const jsonData = JSON.parse(res.body.toString("utf8"));
                         return new fast_xml_parser_1.XMLBuilder({ format: true }).build({ root: jsonData });
                     }
                     catch {
-                        return text;
+                        return res.body.toString("utf8");
                     }
                 }
                 case "text":
-                    return text;
+                    return res.body.toString("utf8");
                 case "buffer":
                     return res.body;
+                case "stream":
+                    throw new Error("Stream mode requires raw response. Use stream() method.");
                 default:
-                    return text;
+                    return res.body.toString("utf8");
             }
         }
         catch (err) {
-            throw new HttpClientError(`Parsing failed: ${err?.message ?? String(err)}`, res.status);
+            throw new Types_1.HttpClientError(`Parsing failed: ${err?.message ?? String(err)}`, res.status);
         }
     }
     /**
@@ -544,10 +615,7 @@ class HttpClientImproved {
     async requestInternalWithoutCache(method, req, responseType) {
         const url = req.getURL();
         const rawBody = req.getBodyData();
-        const headers = {
-            ...this.defaultHeaders,
-            ...req.getHeaders(),
-        };
+        const headers = Object.assign({}, this.baseHeaders, req.getHeaders());
         const isBodyAllowed = ["POST", "PUT", "PATCH", "DELETE"].includes(method);
         let body;
         const contentType = headers["content-type"] || headers["Content-Type"] || "";
@@ -578,19 +646,35 @@ class HttpClientImproved {
             url,
             method,
         };
-        const result = await this.queue.enqueue(async () => {
-            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") {
-                return { status: res.status, headers: res.headers };
-            }
-            const parsed = await this.parseResponse(res, responseType);
-            return parsed;
-        });
+        const result = await (this.queue && this.options.enableQueue
+            ? this.queue.enqueue(async () => {
+                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") {
+                    return { status: res.status, headers: res.headers };
+                }
+                const parsed = await this.parseResponse(res, responseType);
+                return parsed;
+            })
+            : (async () => {
+                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") {
+                    return { status: res.status, headers: res.headers };
+                }
+                const parsed = await this.parseResponse(res, responseType);
+                return parsed;
+            })());
         metrics.endTime = Date.now();
         metrics.duration = metrics.endTime - metrics.startTime;
         this.requestMetrics.set(url, metrics);
@@ -606,16 +690,50 @@ class HttpClientImproved {
      * @param responseType - Expected response type
      * @returns Promise resolving to the response data
      */
+    async fastRequest(method, req, responseType) {
+        const url = req.getURL();
+        const headers = Object.assign({}, this.baseHeaders, req.getHeaders());
+        const body = req.getBodyData();
+        let finalBody;
+        if (body == null) {
+            finalBody = undefined;
+        }
+        else if (typeof body === "string" || Buffer.isBuffer(body)) {
+            finalBody = body;
+        }
+        else {
+            finalBody = JSON.stringify(body);
+        }
+        const res = await (0, undici_1.request)(url, {
+            method,
+            headers,
+            body: finalBody,
+            dispatcher: this.agent,
+        });
+        if (responseType === "json") {
+            return res.body.json();
+        }
+        if (responseType === "text") {
+            const text = await res.body.text();
+            return text;
+        }
+        return Buffer.from(await res.body.arrayBuffer());
+    }
     async requestInternal(method, req, useCache = true, responseType) {
-        if (this.options.cacheTTL === 0) {
+        if (!this.cache &&
+            !this.options.enableQueue &&
+            !this.options.enableRateLimit &&
+            this.retryOptions.maxRetries === 0 &&
+            this.requestInterceptors.length === 0 &&
+            this.responseInterceptors.length === 0) {
+            return this.fastRequest(method, req, responseType);
+        }
+        if (this.options.cacheTTL === 0 || this.options.enableCache === false) {
             return this.requestInternalWithoutCache(method, req, responseType);
         }
         const url = req.getURL();
         const rawBody = req.getBodyData();
-        const headers = {
-            ...this.defaultHeaders,
-            ...req.getHeaders(),
-        };
+        const headers = Object.assign({}, this.baseHeaders, req.getHeaders());
         const isBodyAllowed = ["POST", "PUT", "PATCH", "DELETE"].includes(method);
         let body;
         const contentType = headers["content-type"] || headers["Content-Type"] || "";
@@ -635,18 +753,21 @@ class HttpClientImproved {
                     headers["Content-Type"] = "application/json; charset=utf-8";
             }
         }
-        const bodyHash = this.hashBody(body);
-        const cacheKey = (0, crypto_1.createHash)("sha1")
-            .update(method + url + bodyHash + responseType)
-            .digest("hex");
-        if (this.options.cacheMethods.includes(method) && useCache) {
-            const cached = this.cache.get(cacheKey);
-            if (cached) {
+        let cacheKey;
+        if (this.cache && useCache) {
+            const bodyHash = this.hashBody(body);
+            cacheKey = (0, crypto_1.createHash)("sha1")
+                .update(method + url + bodyHash + responseType)
+                .digest("hex");
+        }
+        if (cacheKey && this.options.cacheMethods.includes(method) && useCache && this.cache) {
+            const cached = await this.cache.get(cacheKey);
+            if (cached != null) {
                 this.log("debug", `Cache hit for ${url}`);
                 return cached;
             }
         }
-        if (this.inflight.has(cacheKey)) {
+        if (cacheKey && this.inflight.has(cacheKey)) {
             this.log("debug", `Deduplicating request for ${url}`);
             return this.inflight.get(cacheKey);
         }
@@ -661,31 +782,55 @@ class HttpClientImproved {
                 cached: false,
                 url,
                 method,
-                bodyHash,
             };
             try {
                 this.log("debug", `Starting request: ${method} ${url}`);
-                const result = await this.queue.enqueue(async () => {
-                    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") {
-                        return { status: res.status, headers: res.headers };
-                    }
-                    const parsed = await this.parseResponse(res, responseType);
-                    if (this.options.cacheMethods.includes(method) && useCache) {
-                        this.cache.set(cacheKey, parsed);
-                        metrics.cached = true;
-                    }
-                    return parsed;
-                });
+                const result = await (this.queue && this.options.enableQueue
+                    ? this.queue.enqueue(async () => {
+                        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") {
+                            return { status: res.status, headers: res.headers };
+                        }
+                        const parsed = await this.parseResponse(res, responseType);
+                        if (cacheKey &&
+                            this.options.cacheMethods.includes(method) &&
+                            useCache &&
+                            this.cache) {
+                            this.cache.set(cacheKey, parsed);
+                            metrics.cached = true;
+                        }
+                        return parsed;
+                    })
+                    : (async () => {
+                        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") {
+                            return { status: res.status, headers: res.headers };
+                        }
+                        const parsed = await this.parseResponse(res, responseType);
+                        if (cacheKey &&
+                            this.options.cacheMethods.includes(method) &&
+                            useCache &&
+                            this.cache) {
+                            await this.cache.set(cacheKey, parsed);
+                            metrics.cached = true;
+                        }
+                        return parsed;
+                    })());
                 metrics.endTime = Date.now();
                 metrics.duration = metrics.endTime - metrics.startTime;
-                this.requestMetrics.set(cacheKey, metrics);
+                this.requestMetrics.set(cacheKey || url, metrics);
                 this.trimMetrics();
                 this.log("info", `${method} ${url} completed in ${metrics.duration}ms`, metrics);
                 return result;
@@ -693,15 +838,17 @@ class HttpClientImproved {
             catch (error) {
                 metrics.endTime = Date.now();
                 metrics.duration = metrics.endTime - metrics.startTime;
-                this.requestMetrics.set(cacheKey, metrics);
+                this.requestMetrics.set(cacheKey || url, metrics);
                 this.trimMetrics();
                 throw error;
             }
             finally {
-                this.inflight.delete(cacheKey);
+                if (cacheKey)
+                    this.inflight.delete(cacheKey);
             }
         })();
-        this.inflight.set(cacheKey, promise);
+        if (cacheKey)
+            this.inflight.set(cacheKey, promise);
         return promise;
     }
     /**
@@ -758,16 +905,60 @@ class HttpClientImproved {
      */
     put(req, body, responseType = "json") {
         if (typeof req === "string") {
-            const client = defaultClient ?? (defaultClient = new HttpClientImproved());
             const simpleReq = {
                 getURL: () => req,
                 getBodyData: () => body,
                 getHeaders: () => ({ "Content-Type": "application/json" }),
             };
-            return client.put(simpleReq, responseType);
+            return this.requestInternal("PUT", simpleReq, false, responseType);
         }
         return this.requestInternal("PUT", req, false, responseType);
     }
+    /**
+     * @ru Получает потоковый ответ (для SSE, больших файлов).
+     * @en Gets streaming response (for SSE, large files).
+     */
+    stream(req) {
+        if (typeof req === "string") {
+            const simpleReq = {
+                getURL: () => req,
+                getBodyData: () => undefined,
+                getHeaders: () => ({}),
+            };
+            return this.stream(simpleReq);
+        }
+        return (this.queue && this.options.enableQueue
+            ? this.queue.enqueue(async function () {
+                const url = req.getURL();
+                const headers = Object.assign({}, this.baseHeaders, 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.baseHeaders, 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)());
+    }
     /**
      * Makes an HTTP DELETE request.
      * Supports both RequestInterface objects and direct URL strings.
@@ -795,7 +986,15 @@ class HttpClientImproved {
      * @param responseType - Expected response type (default: "json")
      * @returns Promise resolving to the response data
      */
-    patch(req, responseType = "json") {
+    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);
     }
     /**
@@ -807,13 +1006,12 @@ class HttpClientImproved {
      */
     async head(req) {
         if (typeof req === "string") {
-            const client = defaultClient ?? (defaultClient = new HttpClientImproved());
             const simpleReq = {
                 getURL: () => req,
                 getBodyData: () => undefined,
                 getHeaders: () => ({}),
             };
-            return client.head(simpleReq);
+            return this.requestInternal("HEAD", simpleReq, false);
         }
         return this.requestInternal("HEAD", req, false);
     }
@@ -821,9 +1019,11 @@ class HttpClientImproved {
      * Clears the internal cache of the HTTP client.
      * Removes all cached responses and resets the cache state.
      */
-    clearCache() {
-        this.cache.clear();
-        this.log("info", "Cache cleared");
+    async clearCache() {
+        if (this.cache) {
+            await this.cache.clear();
+            this.log("info", "Cache cleared");
+        }
     }
     /**
      * Clears all collected request metrics.
@@ -864,11 +1064,17 @@ class HttpClientImproved {
      */
     getStats() {
         return {
-            cacheSize: this.cache.size,
+            cacheSize: this.cache?.size ?? 0,
             inflightRequests: this.inflight.size,
-            queuedRequests: this.queue.queuedCount,
-            activeRequests: this.queue.activeCount,
-            currentRateLimit: this.limiter.currentCount,
+            queuedRequests: this.queue && this.options.enableQueue
+                ? (this.queue.queuedCount ?? 0)
+                : 0,
+            activeRequests: this.queue && this.options.enableQueue
+                ? (this.queue.activeCount ?? 0)
+                : 0,
+            currentRateLimit: this.limiter && this.options.enableRateLimit
+                ? (this.limiter.currentCount ?? 0)
+                : 0,
             metricsSize: this.requestMetrics.size,
         };
     }
@@ -951,6 +1157,14 @@ class RequestBuilder {
         this._method = "POST";
         return this;
     }
+    /**
+     * @ru Устанавливает потоковый режим ответа.
+     * @en Sets streaming response mode.
+     */
+    stream() {
+        this._responseType = "stream";
+        return this;
+    }
     /**
      * Sets the HTTP method to PUT.
      * @returns The builder instance for chaining
@@ -994,7 +1208,7 @@ class RequestBuilder {
      */
     jsonBody(body) {
         this._body = body;
-        this._headers['Content-Type'] = 'application/json; charset=utf-8';
+        this._headers["Content-Type"] = "application/json; charset=utf-8";
         return this;
     }
     /**
@@ -1010,16 +1224,22 @@ class RequestBuilder {
         };
         switch (this._method) {
             case "GET":
+                if (this._responseType === "stream") {
+                    return client.stream(req);
+                }
                 return client.get(req, this._responseType);
             case "POST":
-                return client.post(req, this._responseType);
+                return client.post(req, this._body, this._responseType);
             case "PUT":
-                return client.put(req, this._responseType);
+                return client.put(req, this._body, this._responseType);
             case "DELETE":
                 return client.delete(req, this._responseType);
             case "PATCH":
-                return client.patch(req, this._responseType);
+                return client.patch(req, this._body, this._responseType);
             default:
+                if (this._responseType === "stream") {
+                    return client.stream(req);
+                }
                 return client.get(req, this._responseType);
         }
     }