@fedify/fedify 2.0.35-dev.2470 → 2.0.35-dev.2485

package/dist/nodeinfo/client.test.mjs

@@ -5,12 +5,21 @@ import { t as esm_default } from "../esm-DVILvP5e.mjs";
 import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
 import "../std__assert-DflMZha5.mjs";
 import { n as assertInstanceOf } from "../assert-BhQd8QHP.mjs";
-import { a as parseProtocol, c as parseUsage, i as parseOutboundService, n as parseInboundService, o as parseServices, r as parseNodeInfo, s as parseSoftware, t as getNodeInfo } from "../client-BUqbea1d.mjs";
+import { a as parseOutboundService, c as parseSoftware, i as parseNodeInfo, l as parseUsage, n as getNodeInfoInternal, o as parseProtocol, r as parseInboundService, s as parseServices, t as getNodeInfo } from "../client-DGNacEx_.mjs";
 import { test } from "@fedify/fixture";
 import { UrlError } from "@fedify/vocab-runtime";
+import { openDirectFetch, openPublicFetch } from "@fedify/vocab-runtime/internal";
 import { configure, reset } from "@logtape/logtape";
-import dns from "node:dns/promises";
 //#region src/nodeinfo/client.test.ts
+function getNodeInfoDirect(url, options) {
+	return getNodeInfoInternal(url, options, { openHop: openDirectFetch });
+}
+function getNodeInfoValidated(url, options) {
+	return getNodeInfoInternal(url, options, { openHop: (hopUrl) => new URL(hopUrl).hostname === "example.com" ? openDirectFetch(hopUrl) : openPublicFetch(hopUrl, { lookup: () => Promise.resolve([{
+		address: "93.184.215.14",
+		family: 4
+	}]) }) });
+}
 test("getNodeInfo()", async (t) => {
 	esm_default.spyGlobal();
 	esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [{
@@ -44,25 +53,25 @@ test("getNodeInfo()", async (t) => {
 		}
 	};
 	await t.step("indirect", async () => {
-		assertEquals(await getNodeInfo("https://example.com/"), expected);
-		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), rawExpected);
+		assertEquals(await getNodeInfoDirect("https://example.com/"), expected);
+		assertEquals(await getNodeInfoDirect("https://example.com/", { parse: "none" }), rawExpected);
 	});
 	await t.step("direct", async () => {
-		assertEquals(await getNodeInfo("https://example.com/nodeinfo/2.1", { direct: true }), expected);
+		assertEquals(await getNodeInfoDirect("https://example.com/nodeinfo/2.1", { direct: true }), expected);
 	});
 	esm_default.removeRoutes();
 	esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [] } });
 	await t.step("indirect: no links", async () => {
-		assertEquals(await getNodeInfo("https://example.com/"), void 0);
+		assertEquals(await getNodeInfoDirect("https://example.com/"), void 0);
 	});
 	esm_default.removeRoutes();
 	esm_default.get("https://example.com/.well-known/nodeinfo", { status: 404 });
 	await t.step("indirect: 404", async () => {
-		assertEquals(await getNodeInfo("https://example.com/"), void 0);
+		assertEquals(await getNodeInfoDirect("https://example.com/"), void 0);
 	});
 	await t.step("direct: 404", async () => {
-		assertEquals(await getNodeInfo("https://example.com/nodeinfo/2.0", { direct: true }), void 0);
-		assertEquals(await getNodeInfo("https://example.com/404", { direct: true }), void 0);
+		assertEquals(await getNodeInfoDirect("https://example.com/nodeinfo/2.0", { direct: true }), void 0);
+		assertEquals(await getNodeInfoDirect("https://example.com/404", { direct: true }), void 0);
 	});
 	esm_default.hardReset();
 });
@@ -79,7 +88,7 @@ test("getNodeInfo() blocks SSRF", async (t) => {
 			internalFetched = true;
 			return { body: { secret: "INTERNAL_DATA_LEAKED" } };
 		});
-		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
+		assertEquals(await getNodeInfoValidated("https://example.com/", { parse: "none" }), void 0);
 		assertEquals(internalFetched, false);
 	});
 	await t.step("link href using a data: URL", async () => {
@@ -88,7 +97,7 @@ test("getNodeInfo() blocks SSRF", async (t) => {
 			rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
 			href: "data:application/json,{\"software\":{\"name\":\"x\"}}"
 		}] } });
-		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
+		assertEquals(await getNodeInfoValidated("https://example.com/", { parse: "none" }), void 0);
 	});
 	await t.step("redirect to a private address", async () => {
 		esm_default.removeRoutes();
@@ -105,7 +114,7 @@ test("getNodeInfo() blocks SSRF", async (t) => {
 			internalFetched = true;
 			return { body: { secret: "INTERNAL_DATA_LEAKED" } };
 		});
-		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
+		assertEquals(await getNodeInfoValidated("https://example.com/", { parse: "none" }), void 0);
 		assertEquals(internalFetched, false);
 	});
 	await t.step("direct fetch of a private address", async () => {
@@ -118,7 +127,7 @@ test("getNodeInfo() blocks SSRF", async (t) => {
 				version: "1.0.0"
 			} } };
 		});
-		assertEquals(await getNodeInfo("http://127.0.0.1:8080/nodeinfo", {
+		assertEquals(await getNodeInfoValidated("http://127.0.0.1:8080/nodeinfo", {
 			direct: true,
 			parse: "none"
 		}), void 0);
@@ -998,17 +1007,16 @@ test("getNodeInfo() bounds both discovery and document responses", async () => {
 		esm_default.hardReset();
 	}
 });
-test("getNodeInfo() logs DNS failures as such", { ignore: "Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted" }, async (t) => {
+test("getNodeInfo() logs DNS failures as such", async (t) => {
 	for (const result of [
 		"throws",
 		"empty",
 		"private"
 	]) await t.step(result, async () => {
-		const originalLookup = dns.lookup;
-		dns.lookup = (() => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [{
+		const lookup = () => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [{
 			address: "127.0.0.1",
 			family: 4
-		}]));
+		}]);
 		const records = [];
 		await configure({
 			sinks: { buffer: (record) => records.push(record) },
@@ -1023,7 +1031,7 @@ test("getNodeInfo() logs DNS failures as such", { ignore: "Deno" in globalThis &
 			reset: true
 		});
 		try {
-			assertEquals(await getNodeInfo("https://dns-failure.invalid/"), void 0);
+			assertEquals(await getNodeInfoInternal("https://dns-failure.invalid/", {}, { openHop: (url) => openPublicFetch(url, { lookup }) }), void 0);
 			assertEquals(records.map((r) => [
 				r.level,
 				r.rawMessage,
@@ -1038,9 +1046,319 @@ test("getNodeInfo() logs DNS failures as such", { ignore: "Deno" in globalThis &
 			assertEquals(error.reason, result === "private" ? "disallowed" : "dns");
 		} finally {
 			await reset();
-			dns.lookup = originalLookup;
 		}
 	});
 });
+function recordHops(respond) {
+	const events = [];
+	const unsettled = [];
+	let opens = 0;
+	let closes = 0;
+	let responses = 0;
+	return {
+		events,
+		async openHop(url) {
+			opens++;
+			events.push(`open ${url}`);
+			const states = [];
+			let closed = false;
+			return {
+				url: new URL(url),
+				async fetch(input) {
+					if (closed) throw new TypeError("The fetch session is closed.");
+					const target = new URL(input instanceof Request ? input.url : input);
+					const id = ++responses;
+					events.push(`fetch ${target.href} #${id}`);
+					const fake = respond(target);
+					const state = {
+						id,
+						settled: false
+					};
+					states.push(state);
+					let sent = false;
+					const body = new ReadableStream({
+						pull(controller) {
+							if (!sent && fake.body != null && fake.body !== "") {
+								sent = true;
+								controller.enqueue(new TextEncoder().encode(fake.body));
+								return;
+							}
+							state.settled = true;
+							events.push(`consumed #${id}`);
+							controller.close();
+						},
+						cancel() {
+							state.settled = true;
+							events.push(`cancel #${id}`);
+							if (fake.cancelFails) throw new Error("Cancellation failed");
+							if (fake.cancelNeverSettles) return new Promise(() => {});
+						}
+					}, { highWaterMark: 0 });
+					const response = new Response(body, {
+						status: fake.status ?? 200,
+						headers: fake.headers
+					});
+					if (fake.url != null) Object.defineProperty(response, "url", { value: fake.url });
+					return response;
+				},
+				async close() {
+					if (closed) return;
+					closed = true;
+					closes++;
+					for (const state of states) if (!state.settled) unsettled.push(`#${state.id}`);
+					events.push(`close ${url}`);
+				}
+			};
+		},
+		assertInvariants() {
+			assertEquals(closes, opens);
+			assertEquals(unsettled, []);
+		}
+	};
+}
+test("getNodeInfo() closes each hop after cleaning up its body", async (t) => {
+	const wellKnown = "https://example.com/.well-known/nodeinfo";
+	const wellKnown2 = "https://example.com/.well-known/nodeinfo2";
+	const documentUrl = "https://example.com/nodeinfo/2.1";
+	const rawDocument = {
+		software: {
+			name: "foo",
+			version: "1.2.3"
+		},
+		protocols: ["activitypub"],
+		usage: {
+			users: {},
+			localPosts: 0,
+			localComments: 0
+		}
+	};
+	const descriptor = JSON.stringify({ links: [{
+		rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
+		href: documentUrl
+	}] });
+	await t.step("redirect", async () => {
+		const recorder = recordHops((url) => {
+			switch (url.href) {
+				case wellKnown: return {
+					status: 302,
+					headers: { Location: "/.well-known/nodeinfo2" },
+					body: "redirecting",
+					url: "https://93.184.215.14/.well-known/nodeinfo"
+				};
+				case wellKnown2: return { body: descriptor };
+				default: return { body: JSON.stringify(rawDocument) };
+			}
+		});
+		assertEquals(await getNodeInfoInternal("https://example.com/", { parse: "none" }, { openHop: recorder.openHop }), rawDocument);
+		assertEquals(recorder.events, [
+			`open ${wellKnown}`,
+			`fetch ${wellKnown} #1`,
+			"cancel #1",
+			`close ${wellKnown}`,
+			`open ${wellKnown2}`,
+			`fetch ${wellKnown2} #2`,
+			"consumed #2",
+			`close ${wellKnown2}`,
+			`open ${documentUrl}`,
+			`fetch ${documentUrl} #3`,
+			"consumed #3",
+			`close ${documentUrl}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("non-2xx responses", async () => {
+		const recorder = recordHops(() => ({
+			status: 404,
+			body: "not found"
+		}));
+		assertEquals(await getNodeInfoInternal("https://example.com/", {}, { openHop: recorder.openHop }), void 0);
+		assertEquals(await getNodeInfoInternal(documentUrl, { direct: true }, { openHop: recorder.openHop }), void 0);
+		assertEquals(recorder.events, [
+			`open ${wellKnown}`,
+			`fetch ${wellKnown} #1`,
+			"cancel #1",
+			`close ${wellKnown}`,
+			`open ${documentUrl}`,
+			`fetch ${documentUrl} #2`,
+			"cancel #2",
+			`close ${documentUrl}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("too many redirections", async () => {
+		const recorder = recordHops(() => ({
+			status: 302,
+			headers: { Location: "/.well-known/nodeinfo" },
+			body: "redirecting"
+		}));
+		assertEquals(await getNodeInfoInternal("https://example.com/", {}, { openHop: recorder.openHop }), void 0);
+		assertEquals(recorder.events.filter((e) => e.startsWith("open ")).length, 5);
+		assertEquals(recorder.events.filter((e) => e.startsWith("cancel ")).length, 5);
+		recorder.assertInvariants();
+	});
+	await t.step("failed redirect body cancellation", async () => {
+		const recorder = recordHops((url) => {
+			switch (url.href) {
+				case wellKnown: return {
+					status: 302,
+					headers: { Location: "/.well-known/nodeinfo2" },
+					body: "redirecting",
+					cancelFails: true
+				};
+				case wellKnown2: return { body: descriptor };
+				default: return {
+					status: 404,
+					body: "not found",
+					cancelFails: true
+				};
+			}
+		});
+		const records = [];
+		await configure({
+			sinks: { buffer: (record) => records.push(record) },
+			loggers: [{
+				category: "fedify",
+				sinks: ["buffer"],
+				lowestLevel: "debug"
+			}, {
+				category: ["logtape", "meta"],
+				sinks: []
+			}],
+			reset: true
+		});
+		try {
+			assertEquals(await getNodeInfoInternal("https://example.com/", {}, { openHop: recorder.openHop }), void 0);
+			const failures = records.filter((r) => r.rawMessage === "Failed to cancel the response body from {url}: {error}");
+			assertEquals(failures.map((r) => [r.level, r.properties.url]), [["debug", wellKnown], ["debug", documentUrl]]);
+			for (const { properties: { error } } of failures) {
+				assertInstanceOf(error, Error);
+				assertEquals(error.message, "Cancellation failed");
+			}
+		} finally {
+			await reset();
+		}
+		assertEquals(recorder.events, [
+			`open ${wellKnown}`,
+			`fetch ${wellKnown} #1`,
+			"cancel #1",
+			`close ${wellKnown}`,
+			`open ${wellKnown2}`,
+			`fetch ${wellKnown2} #2`,
+			"consumed #2",
+			`close ${wellKnown2}`,
+			`open ${documentUrl}`,
+			`fetch ${documentUrl} #3`,
+			"cancel #3",
+			`close ${documentUrl}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("never-settling body cancellation", async () => {
+		const recorder = recordHops((url) => {
+			switch (url.href) {
+				case wellKnown: return {
+					status: 302,
+					headers: { Location: "/.well-known/nodeinfo2" },
+					body: "redirecting",
+					cancelNeverSettles: true
+				};
+				case wellKnown2: return { body: descriptor };
+				default: return {
+					status: 404,
+					body: "not found",
+					cancelNeverSettles: true
+				};
+			}
+		});
+		assertEquals(await settleWithin(getNodeInfoInternal("https://example.com/", {}, { openHop: recorder.openHop })), void 0);
+		assertEquals(recorder.events, [
+			`open ${wellKnown}`,
+			`fetch ${wellKnown} #1`,
+			"cancel #1",
+			`close ${wellKnown}`,
+			`open ${wellKnown2}`,
+			`fetch ${wellKnown2} #2`,
+			"consumed #2",
+			`close ${wellKnown2}`,
+			`open ${documentUrl}`,
+			`fetch ${documentUrl} #3`,
+			"cancel #3",
+			`close ${documentUrl}`
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("failure while consuming", async () => {
+		const recorder = recordHops(() => ({ body: "not json" }));
+		assertEquals(await getNodeInfoInternal("https://example.com/", {}, { openHop: recorder.openHop }), void 0);
+		assertEquals(recorder.events, [
+			`open ${wellKnown}`,
+			`fetch ${wellKnown} #1`,
+			"consumed #1",
+			`close ${wellKnown}`
+		]);
+		recorder.assertInvariants();
+	});
+});
+/**
+* Rejects if the given promise does not settle within the timeout, so that
+* a hang fails the test instead of blocking it.
+*/
+async function settleWithin(promise, ms = 5e3) {
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Did not settle within ${ms} ms.`)), ms);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function neverCancellableResponse(init) {
+	return new Response(new ReadableStream({
+		start(controller) {
+			controller.enqueue(new TextEncoder().encode("never cancelled"));
+		},
+		cancel: () => new Promise(() => {})
+	}), init);
+}
+test("getNodeInfo() does not wait for cancelling response bodies", async (t) => {
+	const rawDocument = {
+		software: {
+			name: "foo",
+			version: "1.2.3"
+		},
+		protocols: ["activitypub"],
+		usage: {
+			users: {},
+			localPosts: 0,
+			localComments: 0
+		}
+	};
+	esm_default.mockGlobal();
+	try {
+		await t.step("redirect", async () => {
+			esm_default.removeRoutes();
+			esm_default.get("https://example.com/.well-known/nodeinfo", () => neverCancellableResponse({
+				status: 302,
+				headers: { Location: "/.well-known/nodeinfo2" }
+			}));
+			esm_default.get("https://example.com/.well-known/nodeinfo2", () => Response.json({ links: [{
+				rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
+				href: "https://example.com/nodeinfo/2.1"
+			}] }));
+			esm_default.get("https://example.com/nodeinfo/2.1", () => Response.json(rawDocument));
+			assertEquals(await settleWithin(getNodeInfoDirect("https://example.com/", { parse: "none" })), rawDocument);
+		});
+		await t.step("non-2xx responses", async () => {
+			esm_default.removeRoutes();
+			esm_default.get("https://example.com/.well-known/nodeinfo", () => neverCancellableResponse({ status: 404 }));
+			esm_default.get("https://example.com/nodeinfo/2.1", () => neverCancellableResponse({ status: 404 }));
+			assertEquals(await settleWithin(getNodeInfoDirect("https://example.com/")), void 0);
+			assertEquals(await settleWithin(getNodeInfoDirect("https://example.com/nodeinfo/2.1", { direct: true })), void 0);
+		});
+	} finally {
+		esm_default.hardReset();
+	}
+});
 //#endregion
 export {};

package/dist/nodeinfo/handler.test.mjs

@@ -5,7 +5,7 @@ import { n as createRequestContext } from "../context-Juj6bdHC.mjs";
 import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
 import "../std__assert-DflMZha5.mjs";
 import { t as MemoryKvStore } from "../kv-mI4Ix2EU.mjs";
-import { a as createFederation, h as handleNodeInfoJrd, m as handleNodeInfo } from "../middleware-Bj0R0_D7.mjs";
+import { a as createFederation, h as handleNodeInfoJrd, m as handleNodeInfo } from "../middleware-CA7egMDR.mjs";
 import { test } from "@fedify/fixture";
 //#region src/nodeinfo/handler.test.ts
 test("handleNodeInfo()", async () => {

package/dist/nodeinfo/mod.cjs

@@ -1,7 +1,7 @@
 const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_types = require("../types-DRPjmHVV.cjs");
+const require_types = require("../types-DOvyymM4.cjs");
 exports.getNodeInfo = require_types.getNodeInfo;
 exports.nodeInfoToJson = require_types.nodeInfoToJson;
 exports.parseNodeInfo = require_types.parseNodeInfo;

package/dist/nodeinfo/mod.d.cts

@@ -1,3 +1,3 @@
 /// <reference lib="esnext.temporal" />
-import { a as InboundService, c as OutboundService, d as Software, f as Usage, i as parseNodeInfo, l as Protocol, n as ParseNodeInfoOptions, o as JsonValue, p as nodeInfoToJson, r as getNodeInfo, s as NodeInfo, t as GetNodeInfoOptions, u as Services } from "../client-CAM_bQXx.cjs";
+import { a as InboundService, c as OutboundService, d as Software, f as Usage, i as parseNodeInfo, l as Protocol, n as ParseNodeInfoOptions, o as JsonValue, p as nodeInfoToJson, r as getNodeInfo, s as NodeInfo, t as GetNodeInfoOptions, u as Services } from "../client-BIBzqEIp.cjs";
 export { type GetNodeInfoOptions, InboundService, JsonValue, NodeInfo, OutboundService, type ParseNodeInfoOptions, Protocol, Services, Software, Usage, getNodeInfo, nodeInfoToJson, parseNodeInfo };

package/dist/nodeinfo/mod.d.ts

@@ -1,3 +1,3 @@
 /// <reference lib="esnext.temporal" />
-import { a as InboundService, c as OutboundService, d as Software, f as Usage, i as parseNodeInfo, l as Protocol, n as ParseNodeInfoOptions, o as JsonValue, p as nodeInfoToJson, r as getNodeInfo, s as NodeInfo, t as GetNodeInfoOptions, u as Services } from "../client-CSddvgWN.js";
+import { a as InboundService, c as OutboundService, d as Software, f as Usage, i as parseNodeInfo, l as Protocol, n as ParseNodeInfoOptions, o as JsonValue, p as nodeInfoToJson, r as getNodeInfo, s as NodeInfo, t as GetNodeInfoOptions, u as Services } from "../client-jE7oGvRh.js";
 export { type GetNodeInfoOptions, InboundService, JsonValue, NodeInfo, OutboundService, type ParseNodeInfoOptions, Protocol, Services, Software, Usage, getNodeInfo, nodeInfoToJson, parseNodeInfo };

package/dist/nodeinfo/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getNodeInfo, r as parseNodeInfo, t as nodeInfoToJson } from "../types-miAYfiGO.js";
+import { n as getNodeInfo, r as parseNodeInfo, t as nodeInfoToJson } from "../types-B1_pRFE_.js";
 export { getNodeInfo, nodeInfoToJson, parseNodeInfo };