@npy/fetch 0.1.1 → 0.1.2

package/encoding.js

@@ -1,3 +1,4 @@
+import { DecodeStreamError } from "./_internal/decode-stream-error.js";
 import { nodeReadableToWeb } from "@fuman/node";
 import { Readable } from "node:stream";
 //#region src/encoding.ts
@@ -17,10 +18,11 @@ function encodeStream(stream, contentEncoding) {
 	return applyTransforms(stream, contentEncoding, createEncoders);
 }
 /**
-* Create a series of decoding streams based on the content-encoding header. The
-* resulting streams should be piped together to decode the content.
+* Creates the decoder pipeline for a Content-Encoding or transfer-coding list.
 *
-* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+* @remarks
+* Decoding is applied in reverse order of encoding, as required by HTTP semantics.
+* The special value `identity` is ignored.
 */
 function createDecoders(contentEncoding) {
 	const decoders = [];
@@ -35,13 +37,10 @@ function createDecoders(contentEncoding) {
 	return decoders.reverse();
 }
 /**
-* Create a series of encoding streams based on the content-encoding header (or
-* transfer-coding list).
+* Creates the encoder pipeline for a Content-Encoding or transfer-coding list.
 *
-* The resulting streams should be piped together to apply the encoding in the
-* declared order.
-*
-* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+* @remarks
+* Encoders are returned in the declared order. The special value `identity` is ignored.
 */
 function createEncoders(contentEncoding) {
 	const encoders = [];
@@ -61,15 +60,35 @@ function commaSplit(header) {
 function normalizeEncoding(encoding) {
 	return encoding.trim().toLowerCase();
 }
+function tagDecodeErrors(native) {
+	const reader = native.readable.getReader();
+	const tagged = new ReadableStream({
+		pull(controller) {
+			return reader.read().then(({ done, value }) => {
+				if (done) controller.close();
+				else if (value) controller.enqueue(value);
+			}, (err) => {
+				controller.error(new DecodeStreamError(err));
+			});
+		},
+		cancel(reason) {
+			return reader.cancel(reason);
+		}
+	});
+	return {
+		writable: native.writable,
+		readable: tagged
+	};
+}
 function createDecoder(normalizedEncoding) {
 	switch (normalizedEncoding) {
 		case "gzip":
-		case "x-gzip": return new DecompressionStream("gzip");
+		case "x-gzip": return tagDecodeErrors(new DecompressionStream("gzip"));
 		case "deflate":
-		case "x-deflate": return new DecompressionStream("deflate");
+		case "x-deflate": return tagDecodeErrors(new DecompressionStream("deflate"));
 		case "zstd":
-		case "x-zstd": return new DecompressionStream("zstd");
-		case "br": return new DecompressionStream("brotli");
+		case "x-zstd": return tagDecodeErrors(new DecompressionStream("zstd"));
+		case "br": return tagDecodeErrors(new DecompressionStream("brotli"));
 		case "identity": return new TransformStream();
 		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
 	}

package/fetch.cjs

@@ -1,53 +1,82 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_error_mapping = require("./_internal/error-mapping.cjs");
+const require_symbols = require("./_internal/symbols.cjs");
+const require_guards = require("./_internal/guards.cjs");
+const require_body = require("./body.cjs");
+const require_proxy = require("./dialers/proxy.cjs");
 const require_tcp = require("./dialers/tcp.cjs");
-const require_error_adapters = require("./_internal/error-adapters.cjs");
 const require_http_client = require("./http-client.cjs");
+let _npy_proxy_kit = require("@npy/proxy-kit");
 //#region src/fetch.ts
+var MAX_REDIRECTS = 20;
+var REDIRECT_STATUSES = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+var SENSITIVE_REDIRECT_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization"
+];
+var BODY_HEADERS = [
+	"content-encoding",
+	"content-language",
+	"content-length",
+	"content-location",
+	"content-type",
+	"transfer-encoding"
+];
 function createDefaultHttpClient(options = {}) {
 	return new require_http_client.HttpClient({
 		...options,
 		dialer: options.dialer ?? new require_tcp.AutoDialer()
 	});
 }
+/**
+* Normalizes any supported header input into a {@link Headers} instance.
+*
+* @remarks
+* If the input is already a {@link Headers} object, the same instance is returned.
+* Tuple arrays and plain records are copied into a new {@link Headers}.
+*/
 function normalizeHeaders(headers) {
 	if (headers instanceof Headers) return headers;
-	const normalized = new Headers();
+	const result = new Headers();
+	if (!headers) return result;
 	if (Array.isArray(headers)) {
-		headers.forEach(([key, value]) => {
-			normalized.append(key, value);
-		});
-		return normalized;
+		for (const [key, value] of headers) result.append(key, value);
+		return result;
 	}
-	if (headers) Object.entries(headers).forEach(([key, value]) => {
-		if (Array.isArray(value)) value.forEach((entry) => {
-			normalized.append(key, entry);
-		});
-		else if (value !== void 0) normalized.append(key, value);
-	});
-	return normalized;
+	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) for (const entry of value) result.append(key, entry);
+	else if (value !== void 0) result.append(key, value);
+	return result;
 }
 function resolveUrl(input) {
 	if (input instanceof URL) return input;
-	if (input instanceof Request) return new URL(input.url);
-	return new URL(String(input));
+	return new URL(input instanceof Request ? input.url : String(input));
 }
 function resolveMethod(input, init) {
-	if (init.method != null) return init.method.toUpperCase();
-	if (input instanceof Request) return input.method.toUpperCase();
-	return "GET";
+	return (init.method ?? (input instanceof Request ? input.method : void 0))?.toUpperCase().trim() ?? "GET";
 }
 function resolveHeaders(input, init) {
-	if (init.headers !== void 0) return normalizeHeaders(init.headers);
-	if (input instanceof Request) return normalizeHeaders(input.headers);
-	return new Headers();
+	return normalizeHeaders(init.headers !== void 0 ? init.headers : input instanceof Request ? input.headers : void 0);
 }
 function resolveSignal(input, init) {
 	return init.signal ?? (input instanceof Request ? input.signal : void 0);
 }
 function resolveBody(input, init) {
 	if (init.body !== void 0) return init.body;
-	if (!(input instanceof Request)) return;
-	if (input.bodyUsed) throw new TypeError("Request body has already been used");
-	return input.body;
+	return input instanceof Request ? require_body.fromRequestBody(input) : void 0;
+}
+function resolveRedirectMode(input, init) {
+	return init.redirect ?? (input instanceof Request ? input.redirect : "follow");
+}
+function getBodyReplaySource(input, init, method, body, redirect) {
+	if (redirect !== "follow" || init.body !== void 0 || body == null || method === "GET" || method === "HEAD" || !(input instanceof Request)) return;
+	return input.clone();
 }
 function assertValidFetchUrl(url) {
 	if (url.username || url.password) throw new TypeError("Request URL must not include embedded credentials");
@@ -57,36 +86,236 @@ function assertValidFetchBody(method, body) {
 	if (body == null) return;
 	if (method === "GET" || method === "HEAD") throw new TypeError(`Request with ${method} method cannot have a body`);
 }
-async function fetchImpl(input, init) {
+function lookupEnvProxy(...names) {
+	for (const name of names) {
+		const normalized = (process.env[name] ?? process.env[name.toLowerCase()])?.trim();
+		if (normalized) return normalized;
+	}
+}
+function resolveProxyFromEnv(url) {
+	const socksProxy = lookupEnvProxy("SOCKS5_PROXY", "SOCKS_PROXY");
+	if (socksProxy) return socksProxy;
+	if (url.protocol === "https:") return lookupEnvProxy("HTTPS_PROXY", "HTTP_PROXY");
+	return lookupEnvProxy("HTTP_PROXY");
+}
+function normalizeProxyConfig(proxy) {
+	const parsed = typeof proxy === "string" ? (0, _npy_proxy_kit.parse)(proxy, { strict: true }) : proxy;
+	if (parsed == null) throw new TypeError(`Invalid proxy string: ${String(proxy)}`);
+	const key = (0, _npy_proxy_kit.stringify)(parsed, {
+		strict: true,
+		format: "user:pass@ip:port"
+	});
+	if (!key) throw new TypeError("Failed to normalize proxy configuration");
+	return {
+		key,
+		proxy: parsed
+	};
+}
+function resolveNormalizedProxy(url, proxy) {
+	if (proxy === null) return null;
+	if (proxy !== void 0) return normalizeProxyConfig(proxy);
+	const envProxy = resolveProxyFromEnv(url);
+	return envProxy ? normalizeProxyConfig(envProxy) : null;
+}
+function annotateResponse(response, url, redirected) {
+	try {
+		if (redirected) Object.defineProperties(response, {
+			redirected: {
+				configurable: true,
+				enumerable: true,
+				value: true,
+				writable: false
+			},
+			url: {
+				configurable: true,
+				enumerable: true,
+				value: url,
+				writable: false
+			}
+		});
+		else Object.defineProperty(response, "url", {
+			configurable: true,
+			enumerable: true,
+			value: url,
+			writable: false
+		});
+	} catch {}
+	return response;
+}
+async function discardResponse(response) {
+	try {
+		await response.body?.cancel();
+	} catch {}
+}
+function isRedirectResponse(response) {
+	return REDIRECT_STATUSES.has(response.status) && response.headers.get("location") != null;
+}
+function isReplayableBody(body) {
+	if (body == null || typeof body === "string" || body instanceof Uint8Array || require_guards.isBlob(body) || require_guards.isFormData(body) || require_guards.isURLSearchParameters(body)) return true;
+	if (require_guards.isReadableStream(body) || require_guards.isReadable(body) || require_guards.isMultipartFormDataStream(body) || require_guards.isIterable(body)) return false;
+	return true;
+}
+async function resolveReplayableBody(current) {
+	if (isReplayableBody(current.body)) return current.body;
+	if (current.replayBodyRequest) {
+		const buffer = await current.replayBodyRequest.arrayBuffer();
+		return buffer.byteLength > 0 ? new Uint8Array(buffer) : null;
+	}
+	throw new TypeError("Cannot follow redirect with a non-replayable request body");
+}
+function shouldDropBodyOnRedirect(status, method) {
+	if (status === 303) return method !== "HEAD";
+	return (status === 301 || status === 302) && method === "POST";
+}
+function resolveRedirectMethod(status, method) {
+	if (status === 303 && method !== "HEAD" || (status === 301 || status === 302) && method === "POST") return "GET";
+	return method;
+}
+function createRedirectHeaders(current, nextUrl, dropBody) {
+	const headers = new Headers(current.headers);
+	const isCrossOrigin = current.url.origin !== nextUrl.origin;
+	const isDowngrade = current.url.protocol === "https:" && nextUrl.protocol === "http:";
+	headers.delete("host");
+	if (isCrossOrigin) for (const name of SENSITIVE_REDIRECT_HEADERS) headers.delete(name);
+	if (dropBody) for (const name of BODY_HEADERS) headers.delete(name);
+	if (!headers.has("referer") && !isDowngrade) headers.set("referer", current.url.toString());
+	return headers;
+}
+async function buildRedirectRequest(current, response) {
+	const location = response.headers.get("location");
+	if (!location) return current;
+	const nextUrl = new URL(location, current.url);
+	const nextMethod = resolveRedirectMethod(response.status, current.method);
+	const dropBody = shouldDropBodyOnRedirect(response.status, current.method);
+	const nextHeaders = createRedirectHeaders(current, nextUrl, dropBody);
+	const nextBody = dropBody ? void 0 : await resolveReplayableBody(current);
+	return {
+		...current,
+		url: nextUrl,
+		method: nextMethod,
+		headers: nextHeaders,
+		body: nextBody,
+		replayBodyRequest: void 0
+	};
+}
+async function sendPreparedRequest(prepared, getProxyClient) {
+	assertValidFetchUrl(prepared.url);
+	assertValidFetchBody(prepared.method, prepared.body);
+	const normalizedProxy = resolveNormalizedProxy(prepared.url, prepared.proxy);
+	const client = normalizedProxy ? getProxyClient(prepared.baseClient, normalizedProxy) : prepared.baseClient;
+	try {
+		const sendOptions = Object.defineProperty({
+			url: prepared.url,
+			method: prepared.method,
+			headers: prepared.headers,
+			body: prepared.body ?? null,
+			signal: prepared.signal
+		}, require_symbols.bodyErrorMapperSymbol, {
+			configurable: false,
+			enumerable: false,
+			writable: false,
+			value: (error) => require_error_mapping.toWebBodyReadError(error, prepared.signal)
+		});
+		return await client.send(sendOptions);
+	} catch (error) {
+		throw require_error_mapping.toWebFetchError(error, prepared.signal);
+	}
+}
+function prepareRequest(input, init, defaultHttpClient) {
 	const url = resolveUrl(input);
-	assertValidFetchUrl(url);
 	const method = resolveMethod(input, init);
 	const headers = resolveHeaders(input, init);
 	const body = resolveBody(input, init);
 	const signal = resolveSignal(input, init);
-	assertValidFetchBody(method, body);
-	try {
-		return require_error_adapters.wrapResponseBodyErrors(await init.client.send({
-			url,
-			method,
-			headers,
-			body: body ?? null,
-			signal
-		}), (error) => require_error_adapters.toWebBodyReadError(error, signal));
-	} catch (error) {
-		throw require_error_adapters.toWebFetchError(error, signal);
-	}
+	const redirect = resolveRedirectMode(input, init);
+	return {
+		url,
+		method,
+		headers,
+		body,
+		signal,
+		redirect,
+		baseClient: init.client ?? defaultHttpClient,
+		proxy: init.proxy,
+		replayBodyRequest: getBodyReplaySource(input, init, method, body, redirect)
+	};
 }
+/**
+* Creates a fetch-compatible client backed by {@link HttpClient}.
+*
+* @remarks
+* The returned function follows the standard fetch shape, but uses this library's
+* connection pooling, proxy support and body/error mapping rules.
+*
+* When no client is provided, an internal {@link HttpClient} is created and owned
+* by the returned fetch-like function. Calling {@link FetchLike.close} closes that
+* internal client and any proxy-specific clients created on demand.
+*
+* @example
+* ```ts
+* const fetchLike = createFetch();
+* const response = await fetchLike("https://httpbin.org/anything");
+* const data = await response.json();
+* await fetchLike.close();
+* ```
+*/
 function createFetch(client) {
 	const defaultHttpClient = client ?? createDefaultHttpClient();
+	const proxyClientsByBase = /* @__PURE__ */ new WeakMap();
+	const ownedProxyClients = /* @__PURE__ */ new Set();
+	let closePromise;
+	const getProxyClient = (baseClient, proxy) => {
+		let clients = proxyClientsByBase.get(baseClient);
+		if (!clients) {
+			clients = /* @__PURE__ */ new Map();
+			proxyClientsByBase.set(baseClient, clients);
+		}
+		const existing = clients.get(proxy.key);
+		if (existing) return existing;
+		const proxyClient = new require_http_client.HttpClient({
+			...baseClient.options,
+			dialer: new require_proxy.ProxyDialer(proxy.proxy)
+		});
+		clients.set(proxy.key, proxyClient);
+		ownedProxyClients.add(proxyClient);
+		return proxyClient;
+	};
 	const fetchLike = (async (input, init = {}) => {
-		return fetchImpl(input, init.client == null ? {
-			...init,
-			client: defaultHttpClient
-		} : init);
+		let prepared = prepareRequest(input, init, defaultHttpClient);
+		let redirected = false;
+		let redirects = 0;
+		for (;;) {
+			const response = await sendPreparedRequest(prepared, getProxyClient);
+			if (!isRedirectResponse(response) || prepared.redirect === "manual") return annotateResponse(response, prepared.url.toString(), redirected);
+			if (prepared.redirect === "error") {
+				await discardResponse(response);
+				throw new TypeError(`fetch failed: redirect mode is set to "error"`);
+			}
+			if (redirects >= MAX_REDIRECTS) {
+				await discardResponse(response);
+				throw new TypeError(`fetch failed: maximum redirect count exceeded`);
+			}
+			prepared = await buildRedirectRequest(prepared, response);
+			await discardResponse(response);
+			redirected = true;
+			redirects += 1;
+		}
 	});
 	const close = async () => {
-		if (client == null) await defaultHttpClient.close();
+		if (closePromise) return closePromise;
+		const promise = (async () => {
+			const proxyClients = Array.from(ownedProxyClients);
+			ownedProxyClients.clear();
+			const errors = (await Promise.allSettled([...proxyClients.map((c) => c.close()), ...client == null ? [defaultHttpClient.close()] : []])).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more fetch clients");
+		})();
+		closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (closePromise === promise) closePromise = void 0;
+		}
 	};
 	Object.defineProperties(fetchLike, {
 		client: {
@@ -110,6 +339,13 @@ function createFetch(client) {
 	});
 	return fetchLike;
 }
+/**
+* Default fetch-compatible client created with {@link createFetch}.
+*
+* @remarks
+* This singleton owns its internal {@link HttpClient}. Call {@link FetchLike.close}
+* when you want to release pooled connections explicitly.
+*/
 var fetch = createFetch();
 //#endregion
 exports.createFetch = createFetch;

package/fetch.d.cts

@@ -0,0 +1,58 @@
+import { ProxyInfo } from '@npy/proxy-kit';
+import { BodyInit as FetchBodyInit } from './body';
+import { HttpClientOptions, HttpClient } from './http-client';
+export type FetchProxyInput = string | ProxyInfo | null;
+export interface RequestInit extends Omit<globalThis.RequestInit, "body" | "headers"> {
+    body?: FetchBodyInit | null;
+    headers?: HeadersInit;
+    client?: HttpClient;
+    proxy?: FetchProxyInput;
+}
+export type FetchRequestInit = RequestInit;
+export interface FetchOptions extends HttpClientOptions {
+}
+export interface FetchLike {
+    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    readonly client: HttpClient;
+}
+/**
+ * Normalizes any supported header input into a {@link Headers} instance.
+ *
+ * @remarks
+ * If the input is already a {@link Headers} object, the same instance is returned.
+ * Tuple arrays and plain records are copied into a new {@link Headers}.
+ */
+export declare function normalizeHeaders(headers?: HeadersInit): Headers;
+/**
+ * Creates a fetch-compatible client backed by {@link HttpClient}.
+ *
+ * @remarks
+ * The returned function follows the standard fetch shape, but uses this library's
+ * connection pooling, proxy support and body/error mapping rules.
+ *
+ * When no client is provided, an internal {@link HttpClient} is created and owned
+ * by the returned fetch-like function. Calling {@link FetchLike.close} closes that
+ * internal client and any proxy-specific clients created on demand.
+ *
+ * @example
+ * ```ts
+ * const fetchLike = createFetch();
+ * const response = await fetchLike("https://httpbin.org/anything");
+ * const data = await response.json();
+ * await fetchLike.close();
+ * ```
+ */
+export declare function createFetch(client?: HttpClient): FetchLike;
+export type { HttpClientOptions, ProxyInfo };
+export { HttpClient };
+/**
+ * Default fetch-compatible client created with {@link createFetch}.
+ *
+ * @remarks
+ * This singleton owns its internal {@link HttpClient}. Call {@link FetchLike.close}
+ * when you want to release pooled connections explicitly.
+ */
+export declare const fetch: FetchLike;
+export default fetch;

package/fetch.d.ts

@@ -0,0 +1,58 @@
+import { ProxyInfo } from '@npy/proxy-kit';
+import { BodyInit as FetchBodyInit } from './body';
+import { HttpClientOptions, HttpClient } from './http-client';
+export type FetchProxyInput = string | ProxyInfo | null;
+export interface RequestInit extends Omit<globalThis.RequestInit, "body" | "headers"> {
+    body?: FetchBodyInit | null;
+    headers?: HeadersInit;
+    client?: HttpClient;
+    proxy?: FetchProxyInput;
+}
+export type FetchRequestInit = RequestInit;
+export interface FetchOptions extends HttpClientOptions {
+}
+export interface FetchLike {
+    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    readonly client: HttpClient;
+}
+/**
+ * Normalizes any supported header input into a {@link Headers} instance.
+ *
+ * @remarks
+ * If the input is already a {@link Headers} object, the same instance is returned.
+ * Tuple arrays and plain records are copied into a new {@link Headers}.
+ */
+export declare function normalizeHeaders(headers?: HeadersInit): Headers;
+/**
+ * Creates a fetch-compatible client backed by {@link HttpClient}.
+ *
+ * @remarks
+ * The returned function follows the standard fetch shape, but uses this library's
+ * connection pooling, proxy support and body/error mapping rules.
+ *
+ * When no client is provided, an internal {@link HttpClient} is created and owned
+ * by the returned fetch-like function. Calling {@link FetchLike.close} closes that
+ * internal client and any proxy-specific clients created on demand.
+ *
+ * @example
+ * ```ts
+ * const fetchLike = createFetch();
+ * const response = await fetchLike("https://httpbin.org/anything");
+ * const data = await response.json();
+ * await fetchLike.close();
+ * ```
+ */
+export declare function createFetch(client?: HttpClient): FetchLike;
+export type { HttpClientOptions, ProxyInfo };
+export { HttpClient };
+/**
+ * Default fetch-compatible client created with {@link createFetch}.
+ *
+ * @remarks
+ * This singleton owns its internal {@link HttpClient}. Call {@link FetchLike.close}
+ * when you want to release pooled connections explicitly.
+ */
+export declare const fetch: FetchLike;
+export default fetch;