@fedify/vocab-runtime 2.4.0-dev.2169 → 2.4.0-dev.2190

package/dist/tests/{docloader-DWkl3u7X.mjs → docloader-6iodlx7G.mjs}

@@ -1,5 +1,5 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-Cg8MQByW.mjs";
-import { n as MAX_BODY_SIZE, r as readBoundedText, t as BodyTooLargeError } from "./body-CNwDKYQs.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-CGmX5n4v.mjs";
+import { i as readBoundedText, n as MAX_BODY_SIZE, r as readBoundedBytes, t as BodyTooLargeError } from "./body-DMNbCBhz.mjs";
 import { t as preloadedContexts } from "./contexts-CIKsin4e.mjs";
 import { t as HttpHeaderLink } from "./link-Cevmc87v.mjs";
 import { t as UrlError, v as validatePublicUrl } from "./url-D7qRF-dF.mjs";
@@ -13,6 +13,9 @@ const logger = getLogger([
 ]);
 const DEFAULT_MAX_REDIRECTION = 20;
 const MAX_HTML_SIZE = 1024 * 1024;
+const MAX_ERROR_BODY_SIZE = 1024 * 1024;
+const DEFAULT_TIMEOUT = 1e4;
+const MAX_TIMEOUT = 2147483647;
 function createResponseMetadata(response) {
 	return new Response(null, {
 		headers: response.headers,
@@ -20,6 +23,55 @@ function createResponseMetadata(response) {
 		statusText: response.statusText
 	});
 }
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+/**
+* Reads the body of an error response while the document loader is still
+* running, so that its timeout and `AbortSignal` also bound the read, and
+* nothing reading {@link FetchError.response} later waits on the network.
+* The body is kept byte for byte, unless it is too large or cannot be read;
+* then only the status and headers are kept.  A response whose status
+* the `Response` constructor does not accept (e.g., 999) is kept as a clone
+* whose body has been read in full; if its body is too large or cannot be
+* read, no response is kept at all.
+*/
+async function bufferErrorResponse(response, url, signal) {
+	if (response.status < 200 || response.status > 599) {
+		const clone = response.clone();
+		try {
+			await readBoundedBytes(response, MAX_ERROR_BODY_SIZE, url);
+		} catch (error) {
+			await clone.body?.cancel().catch(() => {});
+			if (signal?.aborted) throw error;
+			logger.debug("Failed to read the error response body from {url}: {error}", {
+				url,
+				error
+			});
+			return;
+		}
+		return clone;
+	}
+	if (response.body == null || NULL_BODY_STATUSES.has(response.status)) return createResponseMetadata(response);
+	let body;
+	try {
+		body = await readBoundedBytes(response, MAX_ERROR_BODY_SIZE, url);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		logger.debug("Failed to read the error response body from {url}: {error}", {
+			url,
+			error
+		});
+		return createResponseMetadata(response);
+	}
+	return new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 /**
 * Gets a {@link RemoteDocument} from the given response.
 * @param url The URL of the document to load.
@@ -44,7 +96,7 @@ async function getRemoteDocument(url, response, fetch, options) {
 			url: documentUrl,
 			headers: Object.fromEntries(response.headers.entries())
 		});
-		throw new FetchError(documentUrl, `HTTP ${response.status}: ${documentUrl}`, response.clone());
+		throw new FetchError(documentUrl, `HTTP ${response.status}: ${documentUrl}`, await bufferErrorResponse(response, documentUrl, options?.signal));
 	}
 	const contentType = response.headers.get("Content-Type");
 	const jsonLd = contentType == null || contentType === "application/activity+json" || contentType.startsWith("application/activity+json;") || contentType === "application/ld+json" || contentType.startsWith("application/ld+json;");
@@ -131,9 +183,87 @@ async function getRemoteDocument(url, response, fetch, options) {
 	};
 }
 /**
+* Resolves {@link DocumentLoaderFactoryOptions.timeout} into milliseconds.
+* @param timeout The timeout option.  `undefined` means the default timeout,
+*                and `null` means no timeout.
+* @returns The timeout in milliseconds, or `null` if it is turned off.
+* @throws {RangeError} If the timeout is invalid.
+* @internal
+*/
+function resolveDocumentLoaderTimeout(timeout) {
+	if (timeout === void 0) return DEFAULT_TIMEOUT;
+	if (timeout === null) return null;
+	if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) throw new RangeError(`The document loader timeout must be a positive finite number of milliseconds, but got ${String(timeout)}.`);
+	const ms = Math.ceil(timeout);
+	if (ms > MAX_TIMEOUT) throw new RangeError(`The document loader timeout must not be greater than ${MAX_TIMEOUT} milliseconds, but got ${timeout}.`);
+	return ms;
+}
+/**
+* Bounds each call of the given document loader by the given timeout.
+* The timeout is combined with the caller's `signal`, and the combined
+* signal is passed to the loader.  The call settles no later than the
+* timeout even if the loader is stuck in a step that cannot be aborted,
+* e.g., a DNS lookup.
+*
+* A timed-out call throws a {@link FetchError} without a response, whose
+* `cause` is a `DOMException` named `"TimeoutError"`.  If the caller's
+* signal is aborted, its reason is thrown instead.
+* @param loader The document loader to bound.
+* @param timeout The timeout in milliseconds, or `null` for no timeout.
+*                It is assumed to have been resolved by
+*                {@link resolveDocumentLoaderTimeout}.
+* @returns The bounded document loader.
+* @internal
+*/
+function withDocumentLoaderTimeout(loader, timeout) {
+	if (timeout == null) return loader;
+	return async (url, options) => {
+		const callerSignal = options?.signal;
+		callerSignal?.throwIfAborted();
+		const controller = new AbortController();
+		const timeoutReason = new DOMException(`The document loader timed out after ${timeout} ms.`, "TimeoutError");
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			controller.abort(timeoutReason);
+		}, timeout);
+		const onCallerAbort = () => controller.abort(callerSignal?.reason);
+		callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+		let onAbort;
+		const aborted = new Promise((_, reject) => {
+			onAbort = () => reject(controller.signal.reason);
+			controller.signal.addEventListener("abort", onAbort, { once: true });
+		});
+		const loading = loader(url, {
+			...options,
+			signal: controller.signal
+		});
+		loading.catch(() => {});
+		try {
+			return await Promise.race([loading, aborted]);
+		} catch (error) {
+			if (callerSignal?.aborted) throw callerSignal.reason;
+			if (!timedOut) throw error;
+			logger[options?.suppressError ? "warn" : "error"]("Timed out after {timeout} ms while fetching document: {url}", {
+				timeout,
+				url
+			});
+			const fetchError = new FetchError(url, `Timed out after ${timeout} ms`);
+			fetchError.cause = timeoutReason;
+			throw fetchError;
+		} finally {
+			clearTimeout(timer);
+			callerSignal?.removeEventListener("abort", onCallerAbort);
+			if (onAbort != null) controller.signal.removeEventListener("abort", onAbort);
+		}
+	};
+}
+/**
 * Creates a JSON-LD document loader that utilizes the browser's `fetch` API.
 * At most 20 HTTP redirects and alternate document links are followed in total
 * per call.  Revisiting a URL within that chain throws a {@link FetchError}.
+* Each call times out after 10 seconds by default; see
+* {@link DocumentLoaderFactoryOptions.timeout}.
 *
 * The created loader preloads the below frequently used contexts by default
 * (unless `options.skipPreloadedContexts` is set to `true`):
@@ -153,7 +283,8 @@ async function getRemoteDocument(url, response, fetch, options) {
 * @returns The document loader.
 * @since 1.3.0
 */
-function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedContexts, userAgent } = {}) {
+function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedContexts, timeout, userAgent } = {}) {
+	const resolvedTimeout = resolveDocumentLoaderTimeout(timeout);
 	const tracer = trace.getTracerProvider().getTracer(name, version);
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
@@ -167,18 +298,21 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 				documentUrl: currentUrl
 			};
 		}
-		if (!allowPrivateAddress) try {
-			await validatePublicUrl(currentUrl);
-		} catch (error) {
-			if (error instanceof UrlError) if (error.reason === "dns") logger.debug("DNS lookup failed for {url}", {
-				url: currentUrl,
-				error
-			});
-			else logger[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
-				url: currentUrl,
-				error
-			});
-			throw error;
+		if (!allowPrivateAddress) {
+			try {
+				await validatePublicUrl(currentUrl);
+			} catch (error) {
+				if (error instanceof UrlError) if (error.reason === "dns") logger.debug("DNS lookup failed for {url}", {
+					url: currentUrl,
+					error
+				});
+				else logger[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+					url: currentUrl,
+					error
+				});
+				throw error;
+			}
+			options?.signal?.throwIfAborted();
 		}
 		visited.add(currentUrl);
 		return await tracer.startActiveSpan("activitypub.fetch_document", {
@@ -233,7 +367,7 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 			}
 		});
 	}
-	return (url, options) => load(url, options);
+	return withDocumentLoaderTimeout((url, options) => load(url, options), resolvedTimeout);
 }
 //#endregion
-export { getRemoteDocument as n, getDocumentLoader as t };
+export { withDocumentLoaderTimeout as i, getRemoteDocument as n, resolveDocumentLoaderTimeout as r, getDocumentLoader as t };

package/dist/tests/{docloader-DLkb9qAS.cjs → docloader-B0omnjRS.cjs}

@@ -1,5 +1,5 @@
-const require_request = require("./request-Dm3ye46t.cjs");
-const require_body = require("./body-DHAC8qhR.cjs");
+const require_request = require("./request-BU0mCgOL.cjs");
+const require_body = require("./body-CmZdqiw3.cjs");
 const require_contexts = require("./contexts-DizzBjz4.cjs");
 const require_link = require("./link-DlKm8bEr.cjs");
 const require_url = require("./url-gLKqAO1H.cjs");
@@ -13,6 +13,9 @@ const logger = (0, _logtape_logtape.getLogger)([
 ]);
 const DEFAULT_MAX_REDIRECTION = 20;
 const MAX_HTML_SIZE = 1024 * 1024;
+const MAX_ERROR_BODY_SIZE = 1024 * 1024;
+const DEFAULT_TIMEOUT = 1e4;
+const MAX_TIMEOUT = 2147483647;
 function createResponseMetadata(response) {
 	return new Response(null, {
 		headers: response.headers,
@@ -20,6 +23,55 @@ function createResponseMetadata(response) {
 		statusText: response.statusText
 	});
 }
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+/**
+* Reads the body of an error response while the document loader is still
+* running, so that its timeout and `AbortSignal` also bound the read, and
+* nothing reading {@link FetchError.response} later waits on the network.
+* The body is kept byte for byte, unless it is too large or cannot be read;
+* then only the status and headers are kept.  A response whose status
+* the `Response` constructor does not accept (e.g., 999) is kept as a clone
+* whose body has been read in full; if its body is too large or cannot be
+* read, no response is kept at all.
+*/
+async function bufferErrorResponse(response, url, signal) {
+	if (response.status < 200 || response.status > 599) {
+		const clone = response.clone();
+		try {
+			await require_body.readBoundedBytes(response, MAX_ERROR_BODY_SIZE, url);
+		} catch (error) {
+			await clone.body?.cancel().catch(() => {});
+			if (signal?.aborted) throw error;
+			logger.debug("Failed to read the error response body from {url}: {error}", {
+				url,
+				error
+			});
+			return;
+		}
+		return clone;
+	}
+	if (response.body == null || NULL_BODY_STATUSES.has(response.status)) return createResponseMetadata(response);
+	let body;
+	try {
+		body = await require_body.readBoundedBytes(response, MAX_ERROR_BODY_SIZE, url);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		logger.debug("Failed to read the error response body from {url}: {error}", {
+			url,
+			error
+		});
+		return createResponseMetadata(response);
+	}
+	return new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 /**
 * Gets a {@link RemoteDocument} from the given response.
 * @param url The URL of the document to load.
@@ -44,7 +96,7 @@ async function getRemoteDocument(url, response, fetch, options) {
 			url: documentUrl,
 			headers: Object.fromEntries(response.headers.entries())
 		});
-		throw new require_request.FetchError(documentUrl, `HTTP ${response.status}: ${documentUrl}`, response.clone());
+		throw new require_request.FetchError(documentUrl, `HTTP ${response.status}: ${documentUrl}`, await bufferErrorResponse(response, documentUrl, options?.signal));
 	}
 	const contentType = response.headers.get("Content-Type");
 	const jsonLd = contentType == null || contentType === "application/activity+json" || contentType.startsWith("application/activity+json;") || contentType === "application/ld+json" || contentType.startsWith("application/ld+json;");
@@ -131,9 +183,87 @@ async function getRemoteDocument(url, response, fetch, options) {
 	};
 }
 /**
+* Resolves {@link DocumentLoaderFactoryOptions.timeout} into milliseconds.
+* @param timeout The timeout option.  `undefined` means the default timeout,
+*                and `null` means no timeout.
+* @returns The timeout in milliseconds, or `null` if it is turned off.
+* @throws {RangeError} If the timeout is invalid.
+* @internal
+*/
+function resolveDocumentLoaderTimeout(timeout) {
+	if (timeout === void 0) return DEFAULT_TIMEOUT;
+	if (timeout === null) return null;
+	if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) throw new RangeError(`The document loader timeout must be a positive finite number of milliseconds, but got ${String(timeout)}.`);
+	const ms = Math.ceil(timeout);
+	if (ms > MAX_TIMEOUT) throw new RangeError(`The document loader timeout must not be greater than ${MAX_TIMEOUT} milliseconds, but got ${timeout}.`);
+	return ms;
+}
+/**
+* Bounds each call of the given document loader by the given timeout.
+* The timeout is combined with the caller's `signal`, and the combined
+* signal is passed to the loader.  The call settles no later than the
+* timeout even if the loader is stuck in a step that cannot be aborted,
+* e.g., a DNS lookup.
+*
+* A timed-out call throws a {@link FetchError} without a response, whose
+* `cause` is a `DOMException` named `"TimeoutError"`.  If the caller's
+* signal is aborted, its reason is thrown instead.
+* @param loader The document loader to bound.
+* @param timeout The timeout in milliseconds, or `null` for no timeout.
+*                It is assumed to have been resolved by
+*                {@link resolveDocumentLoaderTimeout}.
+* @returns The bounded document loader.
+* @internal
+*/
+function withDocumentLoaderTimeout(loader, timeout) {
+	if (timeout == null) return loader;
+	return async (url, options) => {
+		const callerSignal = options?.signal;
+		callerSignal?.throwIfAborted();
+		const controller = new AbortController();
+		const timeoutReason = new DOMException(`The document loader timed out after ${timeout} ms.`, "TimeoutError");
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			controller.abort(timeoutReason);
+		}, timeout);
+		const onCallerAbort = () => controller.abort(callerSignal?.reason);
+		callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+		let onAbort;
+		const aborted = new Promise((_, reject) => {
+			onAbort = () => reject(controller.signal.reason);
+			controller.signal.addEventListener("abort", onAbort, { once: true });
+		});
+		const loading = loader(url, {
+			...options,
+			signal: controller.signal
+		});
+		loading.catch(() => {});
+		try {
+			return await Promise.race([loading, aborted]);
+		} catch (error) {
+			if (callerSignal?.aborted) throw callerSignal.reason;
+			if (!timedOut) throw error;
+			logger[options?.suppressError ? "warn" : "error"]("Timed out after {timeout} ms while fetching document: {url}", {
+				timeout,
+				url
+			});
+			const fetchError = new require_request.FetchError(url, `Timed out after ${timeout} ms`);
+			fetchError.cause = timeoutReason;
+			throw fetchError;
+		} finally {
+			clearTimeout(timer);
+			callerSignal?.removeEventListener("abort", onCallerAbort);
+			if (onAbort != null) controller.signal.removeEventListener("abort", onAbort);
+		}
+	};
+}
+/**
 * Creates a JSON-LD document loader that utilizes the browser's `fetch` API.
 * At most 20 HTTP redirects and alternate document links are followed in total
 * per call.  Revisiting a URL within that chain throws a {@link FetchError}.
+* Each call times out after 10 seconds by default; see
+* {@link DocumentLoaderFactoryOptions.timeout}.
 *
 * The created loader preloads the below frequently used contexts by default
 * (unless `options.skipPreloadedContexts` is set to `true`):
@@ -153,7 +283,8 @@ async function getRemoteDocument(url, response, fetch, options) {
 * @returns The document loader.
 * @since 1.3.0
 */
-function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedContexts, userAgent } = {}) {
+function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedContexts, timeout, userAgent } = {}) {
+	const resolvedTimeout = resolveDocumentLoaderTimeout(timeout);
 	const tracer = _opentelemetry_api.trace.getTracerProvider().getTracer(require_request.name, require_request.version);
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
@@ -167,18 +298,21 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 				documentUrl: currentUrl
 			};
 		}
-		if (!allowPrivateAddress) try {
-			await require_url.validatePublicUrl(currentUrl);
-		} catch (error) {
-			if (error instanceof require_url.UrlError) if (error.reason === "dns") logger.debug("DNS lookup failed for {url}", {
-				url: currentUrl,
-				error
-			});
-			else logger[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
-				url: currentUrl,
-				error
-			});
-			throw error;
+		if (!allowPrivateAddress) {
+			try {
+				await require_url.validatePublicUrl(currentUrl);
+			} catch (error) {
+				if (error instanceof require_url.UrlError) if (error.reason === "dns") logger.debug("DNS lookup failed for {url}", {
+					url: currentUrl,
+					error
+				});
+				else logger[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+					url: currentUrl,
+					error
+				});
+				throw error;
+			}
+			options?.signal?.throwIfAborted();
 		}
 		visited.add(currentUrl);
 		return await tracer.startActiveSpan("activitypub.fetch_document", {
@@ -233,7 +367,7 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 			}
 		});
 	}
-	return (url, options) => load(url, options);
+	return withDocumentLoaderTimeout((url, options) => load(url, options), resolvedTimeout);
 }
 //#endregion
 Object.defineProperty(exports, "getDocumentLoader", {
@@ -248,3 +382,15 @@ Object.defineProperty(exports, "getRemoteDocument", {
 		return getRemoteDocument;
 	}
 });
+Object.defineProperty(exports, "resolveDocumentLoaderTimeout", {
+	enumerable: true,
+	get: function() {
+		return resolveDocumentLoaderTimeout;
+	}
+});
+Object.defineProperty(exports, "withDocumentLoaderTimeout", {
+	enumerable: true,
+	get: function() {
+		return withDocumentLoaderTimeout;
+	}
+});