@npy/fetch 0.1.0 → 0.1.1

package/agent-pool.cjs

@@ -0,0 +1,78 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_tcp = require("./dialers/tcp.cjs");
+const require_errors = require("./errors.cjs");
+const require_agent = require("./agent.cjs");
+let generic_pool = require("generic-pool");
+//#region src/agent-pool.ts
+var defaultEvictionInterval = 1e4;
+var defaultMax = Number.MAX_SAFE_INTEGER;
+var defaultIdleTimeout = 3e4;
+function createAgentPool(baseUrl, options = {}) {
+	const poolUrl = new URL(baseUrl);
+	const evictionRunIntervalMillis = options.poolIdleTimeout !== false ? Math.min(options.poolIdleTimeout || defaultEvictionInterval, defaultEvictionInterval) : 0;
+	const max = options.poolMaxPerHost ? Math.max(1, options.poolMaxPerHost) : defaultMax;
+	const softIdleTimeoutMillis = options.poolIdleTimeout !== false ? Math.max(1, options.poolIdleTimeout || defaultIdleTimeout) : -1;
+	const min = softIdleTimeoutMillis > 0 && options.poolMaxIdlePerHost ? Math.max(0, options.poolMaxIdlePerHost) : 0;
+	if (poolUrl.protocol !== "http:" && poolUrl.protocol !== "https:") throw new require_errors.UnsupportedProtocolError(poolUrl.protocol, {
+		origin: poolUrl.origin,
+		scheme: poolUrl.protocol,
+		host: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : void 0
+	});
+	const dialer = options.dialer ?? new require_tcp.AutoDialer();
+	const connectOptions = options.connect ?? {};
+	const ioOptions = options.io;
+	const pool = (0, generic_pool.createPool)({
+		async create() {
+			return require_agent.createAgent(dialer, baseUrl, {
+				connect: connectOptions,
+				io: ioOptions
+			});
+		},
+		async destroy(agent) {
+			agent.close();
+		}
+	}, {
+		autostart: false,
+		evictionRunIntervalMillis,
+		softIdleTimeoutMillis,
+		max,
+		min
+	});
+	let releaseAgentFns = [];
+	async function send(sendOptions) {
+		let agent;
+		let agentReleased = false;
+		const releaseAgentFn = async (forceClose = false) => {
+			if (!agent || agentReleased) return;
+			agentReleased = true;
+			releaseAgentFns = releaseAgentFns.filter((r) => r !== releaseAgentFn);
+			if (forceClose) agent.close();
+			if (pool.isBorrowedResource(agent)) await pool.release(agent);
+		};
+		releaseAgentFns.push(releaseAgentFn);
+		try {
+			agent = await pool.acquire();
+			const responsePromise = agent.send(sendOptions);
+			agent.whenIdle().then(() => releaseAgentFn(), () => releaseAgentFn(true));
+			return responsePromise;
+		} catch (error) {
+			await releaseAgentFn(true);
+			throw error;
+		}
+	}
+	async function close() {
+		await Promise.all(releaseAgentFns.map((release) => release(true)));
+		await pool.drain();
+		await pool.clear();
+	}
+	return {
+		[Symbol.asyncDispose]: close,
+		close,
+		hostname: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : poolUrl.protocol === "https:" ? 443 : 80,
+		send
+	};
+}
+//#endregion
+exports.createAgentPool = createAgentPool;

package/agent-pool.js

@@ -0,0 +1,77 @@
+import { AutoDialer } from "./dialers/tcp.js";
+import { UnsupportedProtocolError } from "./errors.js";
+import { createAgent } from "./agent.js";
+import { createPool } from "generic-pool";
+//#region src/agent-pool.ts
+var defaultEvictionInterval = 1e4;
+var defaultMax = Number.MAX_SAFE_INTEGER;
+var defaultIdleTimeout = 3e4;
+function createAgentPool(baseUrl, options = {}) {
+	const poolUrl = new URL(baseUrl);
+	const evictionRunIntervalMillis = options.poolIdleTimeout !== false ? Math.min(options.poolIdleTimeout || defaultEvictionInterval, defaultEvictionInterval) : 0;
+	const max = options.poolMaxPerHost ? Math.max(1, options.poolMaxPerHost) : defaultMax;
+	const softIdleTimeoutMillis = options.poolIdleTimeout !== false ? Math.max(1, options.poolIdleTimeout || defaultIdleTimeout) : -1;
+	const min = softIdleTimeoutMillis > 0 && options.poolMaxIdlePerHost ? Math.max(0, options.poolMaxIdlePerHost) : 0;
+	if (poolUrl.protocol !== "http:" && poolUrl.protocol !== "https:") throw new UnsupportedProtocolError(poolUrl.protocol, {
+		origin: poolUrl.origin,
+		scheme: poolUrl.protocol,
+		host: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : void 0
+	});
+	const dialer = options.dialer ?? new AutoDialer();
+	const connectOptions = options.connect ?? {};
+	const ioOptions = options.io;
+	const pool = createPool({
+		async create() {
+			return createAgent(dialer, baseUrl, {
+				connect: connectOptions,
+				io: ioOptions
+			});
+		},
+		async destroy(agent) {
+			agent.close();
+		}
+	}, {
+		autostart: false,
+		evictionRunIntervalMillis,
+		softIdleTimeoutMillis,
+		max,
+		min
+	});
+	let releaseAgentFns = [];
+	async function send(sendOptions) {
+		let agent;
+		let agentReleased = false;
+		const releaseAgentFn = async (forceClose = false) => {
+			if (!agent || agentReleased) return;
+			agentReleased = true;
+			releaseAgentFns = releaseAgentFns.filter((r) => r !== releaseAgentFn);
+			if (forceClose) agent.close();
+			if (pool.isBorrowedResource(agent)) await pool.release(agent);
+		};
+		releaseAgentFns.push(releaseAgentFn);
+		try {
+			agent = await pool.acquire();
+			const responsePromise = agent.send(sendOptions);
+			agent.whenIdle().then(() => releaseAgentFn(), () => releaseAgentFn(true));
+			return responsePromise;
+		} catch (error) {
+			await releaseAgentFn(true);
+			throw error;
+		}
+	}
+	async function close() {
+		await Promise.all(releaseAgentFns.map((release) => release(true)));
+		await pool.drain();
+		await pool.clear();
+	}
+	return {
+		[Symbol.asyncDispose]: close,
+		close,
+		hostname: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : poolUrl.protocol === "https:" ? 443 : 80,
+		send
+	};
+}
+//#endregion
+export { createAgentPool };

package/agent.cjs

@@ -0,0 +1,257 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors.cjs");
+const require_error_adapters = require("./_internal/error-adapters.cjs");
+const require_promises = require("./_internal/promises.cjs");
+const require_io = require("./io/io.cjs");
+let _fuman_utils = require("@fuman/utils");
+//#region src/agent.ts
+var PORT_MAP = {
+	"http:": 80,
+	"https:": 443
+};
+var DEFAULT_ALPN_PROTOCOLS = ["http/1.1"];
+function resolvedDeferred() {
+	const deferred = new _fuman_utils.Deferred();
+	deferred.resolve();
+	return deferred;
+}
+function withSignal(promise, signal) {
+	return signal ? require_promises.raceSignal(promise, signal) : promise;
+}
+function isTlsConnection(conn) {
+	return "getAlpnProtocol" in conn && typeof conn.getAlpnProtocol === "function";
+}
+function createAgent(dialer, baseUrl, options = {}) {
+	const base = new URL(baseUrl);
+	if (base.protocol !== "http:" && base.protocol !== "https:") throw new require_errors.UnsupportedProtocolError(base.protocol, {
+		origin: base.origin,
+		scheme: base.protocol,
+		host: base.hostname,
+		port: base.port ? Number.parseInt(base.port, 10) : void 0,
+		url: base.toString()
+	});
+	const secure = base.protocol === "https:";
+	const hostname = base.hostname;
+	const port = base.port ? Number.parseInt(base.port, 10) : PORT_MAP[base.protocol];
+	if (!Number.isFinite(port) || port <= 0 || port > 65535) throw new TypeError(`Invalid port in base URL: ${baseUrl}`);
+	const target = {
+		address: hostname,
+		port,
+		secure,
+		sni: secure ? hostname : void 0,
+		alpnProtocols: secure ? [...DEFAULT_ALPN_PROTOCOLS] : void 0
+	};
+	const connectOptions = options.connect ?? {};
+	const readerOptions = options.io?.reader ?? {};
+	const writerOptions = options.io?.writer ?? {};
+	let conn;
+	let connectPromise;
+	let closed = false;
+	let isBusy = false;
+	let lastUsedTime = Date.now();
+	let idleDeferred = resolvedDeferred();
+	function createBaseErrorContext() {
+		return {
+			origin: base.origin,
+			scheme: base.protocol,
+			host: hostname,
+			port
+		};
+	}
+	function createRequestErrorContext(url, method) {
+		return {
+			...createBaseErrorContext(),
+			url: url.toString(),
+			method
+		};
+	}
+	function markIdle() {
+		isBusy = false;
+		lastUsedTime = Date.now();
+		idleDeferred.resolve();
+	}
+	function disposeConn() {
+		const current = conn;
+		conn = void 0;
+		if (!current) return;
+		try {
+			current.close();
+		} catch {}
+	}
+	function forceClose() {
+		if (closed) return;
+		closed = true;
+		disposeConn();
+		if (!isBusy) markIdle();
+	}
+	function assertUsable() {
+		if (closed) throw new require_errors.AgentClosedError(createBaseErrorContext());
+	}
+	function assertSameOrigin(url) {
+		if (url.origin !== base.origin) throw new require_errors.OriginMismatchError(base.origin, url.origin, {
+			...createBaseErrorContext(),
+			url: url.toString()
+		});
+	}
+	function configureConnection(nextConn) {
+		nextConn.setNoDelay(connectOptions.noDelay ?? true);
+		if (connectOptions.keepAlive !== null) nextConn.setKeepAlive(connectOptions.keepAlive ?? true);
+	}
+	async function connect(signal) {
+		assertUsable();
+		if (conn) return conn;
+		if (connectPromise) return withSignal(connectPromise, signal);
+		let timedOut = false;
+		let timeoutId;
+		const abortController = new AbortController();
+		const onAbort = () => {
+			abortController.abort(signal?.reason);
+		};
+		const cleanup = () => {
+			if (timeoutId !== void 0) {
+				clearTimeout(timeoutId);
+				timeoutId = void 0;
+			}
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+		if (signal) if (signal.aborted) abortController.abort(signal.reason);
+		else signal.addEventListener("abort", onAbort, { once: true });
+		if (connectOptions.timeout != null && Number.isFinite(connectOptions.timeout) && connectOptions.timeout > 0) timeoutId = setTimeout(() => {
+			timedOut = true;
+			abortController.abort(new DOMException("Connection timed out", "TimeoutError"));
+		}, connectOptions.timeout);
+		connectPromise = (async () => {
+			try {
+				const nextConn = await dialer.dial(target, { signal: abortController.signal });
+				if (closed) {
+					try {
+						nextConn.close();
+					} catch {}
+					throw new require_errors.AgentClosedError(createBaseErrorContext());
+				}
+				configureConnection(nextConn);
+				if (secure && isTlsConnection(nextConn)) {
+					const alpn = nextConn.getAlpnProtocol();
+					if (alpn != null && alpn !== "" && alpn !== "http/1.1") {
+						try {
+							nextConn.close();
+						} catch {}
+						throw new require_errors.UnsupportedAlpnProtocolError(alpn, createBaseErrorContext());
+					}
+				}
+				conn = nextConn;
+				return nextConn;
+			} catch (error) {
+				throw require_error_adapters.mapAdvancedConnectError(error, {
+					signal,
+					timedOut,
+					context: createBaseErrorContext()
+				});
+			} finally {
+				cleanup();
+				connectPromise = void 0;
+			}
+		})();
+		return withSignal(connectPromise, signal);
+	}
+	async function send(sendOptions) {
+		assertUsable();
+		const url = typeof sendOptions.url === "string" ? new URL(sendOptions.url) : sendOptions.url;
+		const method = sendOptions.method.toUpperCase();
+		const errorContext = createRequestErrorContext(url, method);
+		if (sendOptions.signal?.aborted) throw new require_errors.RequestAbortedError(sendOptions.signal.reason, errorContext);
+		if (isBusy) throw new require_errors.AgentBusyError(errorContext);
+		assertSameOrigin(url);
+		if (method === "CONNECT") throw new require_errors.UnsupportedMethodError("CONNECT", errorContext);
+		isBusy = true;
+		idleDeferred = new _fuman_utils.Deferred();
+		let finalized = false;
+		let activeConn;
+		const finalize = (reusable) => {
+			if (finalized) return;
+			finalized = true;
+			if (!reusable || closed) {
+				if (conn === activeConn) disposeConn();
+				else if (activeConn) try {
+					activeConn.close();
+				} catch {}
+			}
+			markIdle();
+		};
+		const abortListener = () => {
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+		};
+		try {
+			activeConn = await connect(sendOptions.signal);
+			sendOptions.signal?.addEventListener("abort", abortListener, { once: true });
+			try {
+				await withSignal(require_io.writeRequest(activeConn, {
+					url,
+					method,
+					headers: sendOptions.headers,
+					body: sendOptions.body ?? null,
+					signal: sendOptions.signal
+				}, writerOptions), sendOptions.signal);
+			} catch (error) {
+				throw require_error_adapters.mapAdvancedSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "request"
+				});
+			}
+			const isHeadRequest = method === "HEAD";
+			const shouldIgnoreBody = (status) => isHeadRequest || status >= 100 && status < 200 || status === 204 || status === 304;
+			let response;
+			try {
+				response = await withSignal(require_io.readResponse(activeConn, readerOptions, shouldIgnoreBody, (reusable) => {
+					sendOptions.signal?.removeEventListener("abort", abortListener);
+					finalize(reusable);
+				}), sendOptions.signal);
+			} catch (error) {
+				throw require_error_adapters.mapAdvancedSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "response"
+				});
+			}
+			return require_error_adapters.wrapResponseBodyErrors(response, (error) => require_error_adapters.mapAdvancedSendError(error, {
+				signal: sendOptions.signal,
+				context: errorContext,
+				phase: "body"
+			}));
+		} catch (error) {
+			sendOptions.signal?.removeEventListener("abort", abortListener);
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+			finalize(false);
+			throw error;
+		}
+	}
+	return {
+		[Symbol.dispose]: forceClose,
+		close: forceClose,
+		hostname,
+		port,
+		send,
+		whenIdle() {
+			return idleDeferred.promise;
+		},
+		get isIdle() {
+			return !isBusy;
+		},
+		get lastUsed() {
+			return lastUsedTime;
+		}
+	};
+}
+//#endregion
+exports.createAgent = createAgent;

package/agent.js

@@ -0,0 +1,256 @@
+import { AgentBusyError, AgentClosedError, OriginMismatchError, RequestAbortedError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError } from "./errors.js";
+import { mapAdvancedConnectError, mapAdvancedSendError, wrapResponseBodyErrors } from "./_internal/error-adapters.js";
+import { raceSignal } from "./_internal/promises.js";
+import { readResponse, writeRequest } from "./io/io.js";
+import { Deferred } from "@fuman/utils";
+//#region src/agent.ts
+var PORT_MAP = {
+	"http:": 80,
+	"https:": 443
+};
+var DEFAULT_ALPN_PROTOCOLS = ["http/1.1"];
+function resolvedDeferred() {
+	const deferred = new Deferred();
+	deferred.resolve();
+	return deferred;
+}
+function withSignal(promise, signal) {
+	return signal ? raceSignal(promise, signal) : promise;
+}
+function isTlsConnection(conn) {
+	return "getAlpnProtocol" in conn && typeof conn.getAlpnProtocol === "function";
+}
+function createAgent(dialer, baseUrl, options = {}) {
+	const base = new URL(baseUrl);
+	if (base.protocol !== "http:" && base.protocol !== "https:") throw new UnsupportedProtocolError(base.protocol, {
+		origin: base.origin,
+		scheme: base.protocol,
+		host: base.hostname,
+		port: base.port ? Number.parseInt(base.port, 10) : void 0,
+		url: base.toString()
+	});
+	const secure = base.protocol === "https:";
+	const hostname = base.hostname;
+	const port = base.port ? Number.parseInt(base.port, 10) : PORT_MAP[base.protocol];
+	if (!Number.isFinite(port) || port <= 0 || port > 65535) throw new TypeError(`Invalid port in base URL: ${baseUrl}`);
+	const target = {
+		address: hostname,
+		port,
+		secure,
+		sni: secure ? hostname : void 0,
+		alpnProtocols: secure ? [...DEFAULT_ALPN_PROTOCOLS] : void 0
+	};
+	const connectOptions = options.connect ?? {};
+	const readerOptions = options.io?.reader ?? {};
+	const writerOptions = options.io?.writer ?? {};
+	let conn;
+	let connectPromise;
+	let closed = false;
+	let isBusy = false;
+	let lastUsedTime = Date.now();
+	let idleDeferred = resolvedDeferred();
+	function createBaseErrorContext() {
+		return {
+			origin: base.origin,
+			scheme: base.protocol,
+			host: hostname,
+			port
+		};
+	}
+	function createRequestErrorContext(url, method) {
+		return {
+			...createBaseErrorContext(),
+			url: url.toString(),
+			method
+		};
+	}
+	function markIdle() {
+		isBusy = false;
+		lastUsedTime = Date.now();
+		idleDeferred.resolve();
+	}
+	function disposeConn() {
+		const current = conn;
+		conn = void 0;
+		if (!current) return;
+		try {
+			current.close();
+		} catch {}
+	}
+	function forceClose() {
+		if (closed) return;
+		closed = true;
+		disposeConn();
+		if (!isBusy) markIdle();
+	}
+	function assertUsable() {
+		if (closed) throw new AgentClosedError(createBaseErrorContext());
+	}
+	function assertSameOrigin(url) {
+		if (url.origin !== base.origin) throw new OriginMismatchError(base.origin, url.origin, {
+			...createBaseErrorContext(),
+			url: url.toString()
+		});
+	}
+	function configureConnection(nextConn) {
+		nextConn.setNoDelay(connectOptions.noDelay ?? true);
+		if (connectOptions.keepAlive !== null) nextConn.setKeepAlive(connectOptions.keepAlive ?? true);
+	}
+	async function connect(signal) {
+		assertUsable();
+		if (conn) return conn;
+		if (connectPromise) return withSignal(connectPromise, signal);
+		let timedOut = false;
+		let timeoutId;
+		const abortController = new AbortController();
+		const onAbort = () => {
+			abortController.abort(signal?.reason);
+		};
+		const cleanup = () => {
+			if (timeoutId !== void 0) {
+				clearTimeout(timeoutId);
+				timeoutId = void 0;
+			}
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+		if (signal) if (signal.aborted) abortController.abort(signal.reason);
+		else signal.addEventListener("abort", onAbort, { once: true });
+		if (connectOptions.timeout != null && Number.isFinite(connectOptions.timeout) && connectOptions.timeout > 0) timeoutId = setTimeout(() => {
+			timedOut = true;
+			abortController.abort(new DOMException("Connection timed out", "TimeoutError"));
+		}, connectOptions.timeout);
+		connectPromise = (async () => {
+			try {
+				const nextConn = await dialer.dial(target, { signal: abortController.signal });
+				if (closed) {
+					try {
+						nextConn.close();
+					} catch {}
+					throw new AgentClosedError(createBaseErrorContext());
+				}
+				configureConnection(nextConn);
+				if (secure && isTlsConnection(nextConn)) {
+					const alpn = nextConn.getAlpnProtocol();
+					if (alpn != null && alpn !== "" && alpn !== "http/1.1") {
+						try {
+							nextConn.close();
+						} catch {}
+						throw new UnsupportedAlpnProtocolError(alpn, createBaseErrorContext());
+					}
+				}
+				conn = nextConn;
+				return nextConn;
+			} catch (error) {
+				throw mapAdvancedConnectError(error, {
+					signal,
+					timedOut,
+					context: createBaseErrorContext()
+				});
+			} finally {
+				cleanup();
+				connectPromise = void 0;
+			}
+		})();
+		return withSignal(connectPromise, signal);
+	}
+	async function send(sendOptions) {
+		assertUsable();
+		const url = typeof sendOptions.url === "string" ? new URL(sendOptions.url) : sendOptions.url;
+		const method = sendOptions.method.toUpperCase();
+		const errorContext = createRequestErrorContext(url, method);
+		if (sendOptions.signal?.aborted) throw new RequestAbortedError(sendOptions.signal.reason, errorContext);
+		if (isBusy) throw new AgentBusyError(errorContext);
+		assertSameOrigin(url);
+		if (method === "CONNECT") throw new UnsupportedMethodError("CONNECT", errorContext);
+		isBusy = true;
+		idleDeferred = new Deferred();
+		let finalized = false;
+		let activeConn;
+		const finalize = (reusable) => {
+			if (finalized) return;
+			finalized = true;
+			if (!reusable || closed) {
+				if (conn === activeConn) disposeConn();
+				else if (activeConn) try {
+					activeConn.close();
+				} catch {}
+			}
+			markIdle();
+		};
+		const abortListener = () => {
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+		};
+		try {
+			activeConn = await connect(sendOptions.signal);
+			sendOptions.signal?.addEventListener("abort", abortListener, { once: true });
+			try {
+				await withSignal(writeRequest(activeConn, {
+					url,
+					method,
+					headers: sendOptions.headers,
+					body: sendOptions.body ?? null,
+					signal: sendOptions.signal
+				}, writerOptions), sendOptions.signal);
+			} catch (error) {
+				throw mapAdvancedSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "request"
+				});
+			}
+			const isHeadRequest = method === "HEAD";
+			const shouldIgnoreBody = (status) => isHeadRequest || status >= 100 && status < 200 || status === 204 || status === 304;
+			let response;
+			try {
+				response = await withSignal(readResponse(activeConn, readerOptions, shouldIgnoreBody, (reusable) => {
+					sendOptions.signal?.removeEventListener("abort", abortListener);
+					finalize(reusable);
+				}), sendOptions.signal);
+			} catch (error) {
+				throw mapAdvancedSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "response"
+				});
+			}
+			return wrapResponseBodyErrors(response, (error) => mapAdvancedSendError(error, {
+				signal: sendOptions.signal,
+				context: errorContext,
+				phase: "body"
+			}));
+		} catch (error) {
+			sendOptions.signal?.removeEventListener("abort", abortListener);
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+			finalize(false);
+			throw error;
+		}
+	}
+	return {
+		[Symbol.dispose]: forceClose,
+		close: forceClose,
+		hostname,
+		port,
+		send,
+		whenIdle() {
+			return idleDeferred.promise;
+		},
+		get isIdle() {
+			return !isBusy;
+		},
+		get lastUsed() {
+			return lastUsedTime;
+		}
+	};
+}
+//#endregion
+export { createAgent };