@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.4.0

package/dist/tests/docloader-C3YFl6y4.cjs

@@ -0,0 +1,396 @@
+const require_request = require("./request-8vPWtV1-.cjs");
+const require_body = require("./body-CkEwROsn.cjs");
+const require_contexts = require("./contexts-DizzBjz4.cjs");
+const require_link = require("./link-DlKm8bEr.cjs");
+const require_url = require("./url-BNakuZ8k.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+let _opentelemetry_api = require("@opentelemetry/api");
+//#region src/docloader.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"runtime",
+	"docloader"
+]);
+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,
+		status: response.status,
+		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.
+* @param response The response to get the document from.
+* @param fetch The function to fetch the document.
+* @param options The options for loading the document.
+* @returns The loaded remote document.
+* @throws {FetchError} If the response is not OK.
+* @internal
+*/
+async function getRemoteDocument(url, response, fetch, options) {
+	const documentUrl = response.url === "" ? url : response.url;
+	const docUrl = new URL(documentUrl);
+	if (!response.ok) {
+		if (options?.suppressError) logger.warn("Failed to fetch document: {status} {url} {headers}", {
+			status: response.status,
+			url: documentUrl,
+			headers: Object.fromEntries(response.headers.entries())
+		});
+		else logger.error("Failed to fetch document: {status} {url} {headers}", {
+			status: response.status,
+			url: documentUrl,
+			headers: Object.fromEntries(response.headers.entries())
+		});
+		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;");
+	const linkHeader = response.headers.get("Link");
+	let contextUrl = null;
+	if (linkHeader != null) {
+		let link;
+		try {
+			link = new require_link.HttpHeaderLink(linkHeader);
+		} catch (e) {
+			if (e instanceof SyntaxError) link = new require_link.HttpHeaderLink();
+			else throw e;
+		}
+		if (jsonLd) {
+			const entries = link.getByRel("http://www.w3.org/ns/json-ld#context");
+			for (const [uri, params] of entries) if ("type" in params && params.type === "application/ld+json") {
+				contextUrl = uri;
+				break;
+			}
+		} else {
+			const entries = link.getByRel("alternate");
+			for (const [uri, params] of entries) {
+				const altUri = new URL(uri, docUrl);
+				if ("type" in params && (params.type === "application/activity+json" || params.type === "application/ld+json" || params.type.startsWith("application/ld+json;")) && altUri.href !== docUrl.href) {
+					logger.debug("Found alternate document: {alternateUrl} from {url}", {
+						alternateUrl: altUri.href,
+						url: documentUrl
+					});
+					return await fetch(altUri.href, options);
+				}
+			}
+		}
+	}
+	let document;
+	if (!jsonLd && (contentType === "text/html" || contentType?.startsWith("text/html;") || contentType === "application/xhtml+xml" || contentType?.startsWith("application/xhtml+xml;"))) {
+		const errorResponse = createResponseMetadata(response);
+		let html;
+		try {
+			html = await require_body.readBoundedText(response, MAX_HTML_SIZE, documentUrl);
+		} catch (error) {
+			if (!(error instanceof require_body.BodyTooLargeError)) throw error;
+			logger.warn("HTML response too large, skipping alternate link discovery: {url}", {
+				url: documentUrl,
+				maxBytes: MAX_HTML_SIZE
+			});
+			throw new require_request.FetchError(documentUrl, `HTML document is too large to scan for an ActivityPub alternate link (Content-Type: ${contentType})`, errorResponse);
+		}
+		const tagPattern = /<(a|link)\s+([^>]*?)\s*\/?>/gi;
+		const attrPattern = /([a-z][a-z:_-]*)=(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi;
+		let tagMatch;
+		while ((tagMatch = tagPattern.exec(html)) !== null) {
+			const tagContent = tagMatch[2];
+			let attrMatch;
+			const attribs = {};
+			attrPattern.lastIndex = 0;
+			while ((attrMatch = attrPattern.exec(tagContent)) !== null) {
+				const key = attrMatch[1].toLowerCase();
+				attribs[key] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+			}
+			if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" || attribs.type === "application/ld+json" || attribs.type.startsWith("application/ld+json;")) && "href" in attribs && new URL(attribs.href, docUrl).href !== docUrl.href) {
+				logger.debug("Found alternate document: {alternateUrl} from {url}", {
+					alternateUrl: attribs.href,
+					url: documentUrl
+				});
+				return await fetch(new URL(attribs.href, docUrl).href, options);
+			}
+		}
+		try {
+			document = JSON.parse(html);
+		} catch (error) {
+			if (!(error instanceof SyntaxError)) throw error;
+			throw new require_request.FetchError(documentUrl, `HTML document has no ActivityPub alternate link (Content-Type: ${contentType})`, errorResponse);
+		}
+	} else document = JSON.parse(await require_body.readBoundedText(response, require_body.MAX_BODY_SIZE, documentUrl));
+	logger.debug("Fetched document: {status} {url} {headers}", {
+		status: response.status,
+		url: documentUrl,
+		headers: Object.fromEntries(response.headers.entries())
+	});
+	return {
+		contextUrl,
+		document,
+		documentUrl
+	};
+}
+/**
+* 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`):
+*
+* - <https://www.w3.org/ns/activitystreams>
+* - <https://w3id.org/security/v1>
+* - <https://w3id.org/security/data-integrity/v1>
+* - <https://w3id.org/security/data-integrity/v2>
+* - <https://www.w3.org/ns/did/v1>
+* - <https://www.w3.org/ns/cid/v1>
+* - <https://w3id.org/security/multikey/v1>
+* - <https://w3id.org/fep/ef61>
+* - <https://w3id.org/fep/7aa9>
+* - <https://purl.archive.org/socialweb/webfinger>
+* - <http://schema.org/>
+* @param options Options for the document loader.
+* @returns The document loader.
+* @since 1.3.0
+*/
+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()) {
+		options?.signal?.throwIfAborted();
+		const currentUrl = new URL(url).href;
+		if (!skipPreloadedContexts && currentUrl in require_contexts.preloadedContexts) {
+			logger.debug("Using preloaded context: {url}.", { url: currentUrl });
+			return {
+				contextUrl: null,
+				document: require_contexts.preloadedContexts[currentUrl],
+				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;
+			}
+			options?.signal?.throwIfAborted();
+		}
+		visited.add(currentUrl);
+		return await tracer.startActiveSpan("activitypub.fetch_document", {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes: { "url.full": currentUrl }
+		}, async (span) => {
+			try {
+				const request = require_request.createActivityPubRequest(currentUrl, { userAgent });
+				require_request.logRequest(logger, request);
+				const response = await fetch(request, {
+					redirect: "manual",
+					signal: options?.signal
+				});
+				span.setAttribute("http.response.status_code", response.status);
+				if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
+					if (redirected >= maximumRedirection) {
+						logger[options?.suppressError ? "warn" : "error"]("Too many redirections ({redirections}) while fetching document.", {
+							redirections: redirected + 1,
+							url: currentUrl
+						});
+						throw new require_request.FetchError(currentUrl, `Too many redirections (${redirected + 1})`);
+					}
+					const redirectUrl = new URL(response.headers.get("Location"), response.url === "" ? currentUrl : response.url).href;
+					span.setAttribute("http.redirect.url", redirectUrl);
+					if (visited.has(redirectUrl)) {
+						logger[options?.suppressError ? "warn" : "error"]("Detected a redirect loop while fetching document: {url} -> {redirectUrl}", {
+							url: currentUrl,
+							redirectUrl
+						});
+						throw new require_request.FetchError(currentUrl, `Redirect loop detected: ${redirectUrl}`);
+					}
+					return await load(redirectUrl, options, redirected + 1, visited);
+				}
+				const result = await getRemoteDocument(currentUrl, response, async (alternateUrl) => {
+					options?.signal?.throwIfAborted();
+					if (redirected >= DEFAULT_MAX_REDIRECTION) throw new require_request.FetchError(currentUrl, `Too many redirections (${redirected + 1})`);
+					if (visited.has(alternateUrl)) throw new require_request.FetchError(currentUrl, `Redirect loop detected: ${alternateUrl}`);
+					return await load(alternateUrl, options, redirected + 1, visited);
+				}, options);
+				span.setAttribute("docloader.document_url", result.documentUrl);
+				if (result.contextUrl != null) span.setAttribute("docloader.context_url", result.contextUrl);
+				return result;
+			} catch (error) {
+				span.recordException(error);
+				span.setStatus({
+					code: _opentelemetry_api.SpanStatusCode.ERROR,
+					message: String(error)
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	}
+	return withDocumentLoaderTimeout((url, options) => load(url, options), resolvedTimeout);
+}
+//#endregion
+Object.defineProperty(exports, "getDocumentLoader", {
+	enumerable: true,
+	get: function() {
+		return getDocumentLoader;
+	}
+});
+Object.defineProperty(exports, "getRemoteDocument", {
+	enumerable: true,
+	get: function() {
+		return getRemoteDocument;
+	}
+});
+Object.defineProperty(exports, "resolveDocumentLoaderTimeout", {
+	enumerable: true,
+	get: function() {
+		return resolveDocumentLoaderTimeout;
+	}
+});
+Object.defineProperty(exports, "withDocumentLoaderTimeout", {
+	enumerable: true,
+	get: function() {
+		return withDocumentLoaderTimeout;
+	}
+});