@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/webfinger/handler.js

@@ -0,0 +1,140 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Link } from "../vocab/vocab.js";
+import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { domainToASCII } from "node:url";
+
+//#region webfinger/handler.ts
+const logger = getLogger([
+	"fedify",
+	"webfinger",
+	"server"
+]);
+/**
+* Handles a WebFinger request.  You would not typically call this function
+* directly, but instead use {@link Federation.fetch} method.
+* @param request The WebFinger request to handle.
+* @param parameters The parameters for handling the request.
+* @returns The response to the request.
+*/
+async function handleWebFinger(request, options) {
+	if (options.tracer == null) return await handleWebFingerInternal(request, options);
+	return await options.tracer.startActiveSpan("webfinger.handle", { kind: SpanKind.SERVER }, async (span) => {
+		try {
+			const response = await handleWebFingerInternal(request, options);
+			span.setStatus({ code: response.ok ? SpanStatusCode.UNSET : SpanStatusCode.ERROR });
+			return response;
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function handleWebFingerInternal(request, { context: context$1, host, actorDispatcher, actorHandleMapper, actorAliasMapper, onNotFound, span }) {
+	if (actorDispatcher == null) return await onNotFound(request);
+	const resource = context$1.url.searchParams.get("resource");
+	if (resource == null) return new Response("Missing resource parameter.", { status: 400 });
+	span?.setAttribute("webfinger.resource", resource);
+	let resourceUrl;
+	try {
+		resourceUrl = new URL(resource);
+	} catch (e) {
+		if (e instanceof TypeError) return new Response("Invalid resource URL.", { status: 400 });
+		throw e;
+	}
+	span?.setAttribute("webfinger.resource.scheme", resourceUrl.protocol.replace(/:$/, ""));
+	if (actorDispatcher == null) {
+		logger.error("Actor dispatcher is not set.");
+		return await onNotFound(request);
+	}
+	async function mapUsernameToIdentifier(username) {
+		if (actorHandleMapper == null) {
+			logger.error("No actor handle mapper is set; use the WebFinger username {username} as the actor's internal identifier.", { username });
+			return username;
+		}
+		const identifier$1 = await actorHandleMapper(context$1, username);
+		if (identifier$1 == null) {
+			logger.error("Actor {username} not found.", { username });
+			return null;
+		}
+		return identifier$1;
+	}
+	let identifier = null;
+	const uriParsed = context$1.parseUri(resourceUrl);
+	if (uriParsed?.type != "actor") {
+		const match = /^acct:([^@]+)@([^@]+)$/.exec(resource);
+		if (match == null) {
+			const result = await actorAliasMapper?.(context$1, resourceUrl);
+			if (result == null) return await onNotFound(request);
+			if ("identifier" in result) identifier = result.identifier;
+			else identifier = await mapUsernameToIdentifier(result.username);
+		} else {
+			const portMatch = /:\d+$/.exec(match[2]);
+			const normalizedHost = portMatch == null ? domainToASCII(match[2].toLowerCase()) : domainToASCII(match[2].substring(0, portMatch.index).toLowerCase()) + portMatch[0];
+			if (normalizedHost != context$1.url.host && normalizedHost != host) return await onNotFound(request);
+			else {
+				identifier = await mapUsernameToIdentifier(match[1]);
+				resourceUrl = new URL(`acct:${match[1]}@${normalizedHost}`);
+			}
+		}
+	} else identifier = uriParsed.identifier;
+	if (identifier == null) return await onNotFound(request);
+	const actor = await actorDispatcher(context$1, identifier);
+	if (actor == null) {
+		logger.error("Actor {identifier} not found.", { identifier });
+		return await onNotFound(request);
+	}
+	const links = [{
+		rel: "self",
+		href: context$1.getActorUri(identifier).href,
+		type: "application/activity+json"
+	}];
+	for (const url of actor.urls) if (url instanceof Link && url.href != null) links.push({
+		rel: url.rel ?? "http://webfinger.net/rel/profile-page",
+		href: url.href.href,
+		type: url.mediaType == null ? void 0 : url.mediaType
+	});
+	else if (url instanceof URL) links.push({
+		rel: "http://webfinger.net/rel/profile-page",
+		href: url.href
+	});
+	for await (const image of actor.getIcons()) {
+		if (image.url?.href == null) continue;
+		const link = {
+			rel: "http://webfinger.net/rel/avatar",
+			href: image.url.href.toString()
+		};
+		if (image.mediaType != null) link.type = image.mediaType;
+		links.push(link);
+	}
+	const aliases = [];
+	if (resourceUrl.protocol != "acct:" && actor.preferredUsername != null) {
+		aliases.push(`acct:${actor.preferredUsername}@${host ?? context$1.url.host}`);
+		if (host != null && host !== context$1.url.host) aliases.push(`acct:${actor.preferredUsername}@${context$1.url.host}`);
+	}
+	if (resourceUrl.href !== context$1.getActorUri(identifier).href) aliases.push(context$1.getActorUri(identifier).href);
+	if (resourceUrl.protocol === "acct:" && host != null && host !== context$1.url.host && !resourceUrl.href.endsWith(`@${host}`)) {
+		const username = resourceUrl.href.replace(/^acct:/, "").replace(/@.*$/, "");
+		aliases.push(`acct:${username}@${host}`);
+	}
+	const jrd = {
+		subject: resourceUrl.href,
+		aliases,
+		links
+	};
+	return new Response(JSON.stringify(jrd), { headers: {
+		"Content-Type": "application/jrd+json",
+		"Access-Control-Allow-Origin": "*"
+	} });
+}
+
+//#endregion
+export { handleWebFinger };

package/dist/webfinger/handler.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/webfinger/handler.test.js

@@ -0,0 +1,483 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Image, Link, Person } from "../vocab/vocab.js";
+import { handleWebFinger } from "./handler.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { createRequestContext } from "../testing/context.js";
+
+//#region webfinger/handler.test.ts
+test("handleWebFinger()", async (t) => {
+	const url = new URL("https://example.com/.well-known/webfinger");
+	function createContext(url$1) {
+		const context = createRequestContext({
+			url: url$1,
+			data: void 0,
+			getActorUri(identifier) {
+				return new URL(`${url$1.origin}/users/${identifier}`);
+			},
+			async getActor(handle) {
+				return await actorDispatcher(context, handle);
+			},
+			parseUri(uri) {
+				if (uri == null) return null;
+				if (uri.protocol === "acct:") return null;
+				if (!uri.pathname.startsWith("/users/")) return null;
+				const paths = uri.pathname.split("/");
+				const identifier = paths[paths.length - 1];
+				return {
+					type: "actor",
+					identifier,
+					get handle() {
+						throw new Error("ParseUriResult.handle is deprecated!");
+					}
+				};
+			}
+		});
+		return context;
+	}
+	const actorDispatcher = (ctx, identifier) => {
+		if (identifier !== "someone" && identifier !== "someone2") return null;
+		const actorUri = ctx.getActorUri(identifier);
+		return new Person({
+			id: actorUri,
+			name: identifier === "someone" ? "Someone" : "Someone 2",
+			preferredUsername: identifier === "someone" ? null : identifier === "someone2" ? "bar" : null,
+			icon: new Image({
+				url: new URL(`${actorUri.origin}/icon.jpg`),
+				mediaType: "image/jpeg"
+			}),
+			urls: [new URL(`${actorUri.origin}/@${identifier}`), new Link({
+				href: new URL(`${actorUri.origin}/@${identifier}`),
+				rel: "alternate",
+				mediaType: "text/html"
+			})]
+		});
+	};
+	let onNotFoundCalled = null;
+	const onNotFound = (request) => {
+		onNotFoundCalled = request;
+		return new Response("Not found", { status: 404 });
+	};
+	await t.step("no actor dispatcher", async () => {
+		const context = createContext(url);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+		assertEquals(onNotFoundCalled, request);
+	});
+	onNotFoundCalled = null;
+	await t.step("no resource", async () => {
+		const context = createContext(url);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 400);
+		assertEquals(await response.text(), "Missing resource parameter.");
+		assertEquals(onNotFoundCalled, null);
+	});
+	await t.step("invalid resource", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", " invalid ");
+		const context = createContext(u);
+		const request = new Request(u);
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 400);
+		assertEquals(await response.text(), "Invalid resource URL.");
+		assertEquals(onNotFoundCalled, null);
+	});
+	const expected = {
+		subject: "acct:someone@example.com",
+		aliases: ["https://example.com/users/someone"],
+		links: [
+			{
+				href: "https://example.com/users/someone",
+				rel: "self",
+				type: "application/activity+json"
+			},
+			{
+				href: "https://example.com/@someone",
+				rel: "http://webfinger.net/rel/profile-page"
+			},
+			{
+				href: "https://example.com/@someone",
+				rel: "alternate",
+				type: "text/html"
+			},
+			{
+				href: "https://example.com/icon.jpg",
+				rel: "http://webfinger.net/rel/avatar",
+				type: "image/jpeg"
+			}
+		]
+	};
+	await t.step("ok: resource=acct:...", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:someone@example.com");
+		const context = createContext(u);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(response.headers.get("Content-Type"), "application/jrd+json");
+		assertEquals(response.headers.get("Access-Control-Allow-Origin"), "*");
+		assertEquals(await response.json(), expected);
+	});
+	const expected2 = {
+		subject: "https://example.com/users/someone2",
+		aliases: ["acct:bar@example.com"],
+		links: [
+			{
+				href: "https://example.com/users/someone2",
+				rel: "self",
+				type: "application/activity+json"
+			},
+			{
+				href: "https://example.com/@someone2",
+				rel: "http://webfinger.net/rel/profile-page"
+			},
+			{
+				href: "https://example.com/@someone2",
+				rel: "alternate",
+				type: "text/html"
+			},
+			{
+				href: "https://example.com/icon.jpg",
+				rel: "http://webfinger.net/rel/avatar",
+				type: "image/jpeg"
+			}
+		]
+	};
+	await t.step("ok: resource=https:...", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "https://example.com/users/someone");
+		let context = createContext(u);
+		let request = context.request;
+		let response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			aliases: [],
+			subject: "https://example.com/users/someone"
+		});
+		u.searchParams.set("resource", "https://example.com/users/someone2");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), expected2);
+	});
+	await t.step("not found: resource=acct:...", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:no-one@example.com");
+		const context = createContext(u);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+		assertEquals(onNotFoundCalled, request);
+	});
+	onNotFoundCalled = null;
+	await t.step("not found: resource=http:...", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "https://example.com/users/no-one");
+		let context = createContext(u);
+		let request = context.request;
+		let response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+		assertEquals(onNotFoundCalled, request);
+		onNotFoundCalled = null;
+		u.searchParams.set("resource", "https://google.com/");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+		assertEquals(onNotFoundCalled, request);
+	});
+	onNotFoundCalled = null;
+	const actorHandleMapper = (_ctx, username) => {
+		return username === "foo" ? "someone" : username === "bar" ? "someone2" : null;
+	};
+	await t.step("handle mapper", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:foo@example.com");
+		let context = createContext(u);
+		let request = context.request;
+		let response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			aliases: ["https://example.com/users/someone"],
+			subject: "acct:foo@example.com"
+		});
+		u.searchParams.set("resource", "acct:bar@example.com");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected2,
+			aliases: ["https://example.com/users/someone2"],
+			subject: "acct:bar@example.com"
+		});
+		u.searchParams.set("resource", "https://example.com/users/someone");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			aliases: [],
+			subject: "https://example.com/users/someone"
+		});
+		u.searchParams.set("resource", "acct:baz@example.com");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+	});
+	const actorAliasMapper = (_ctx, resource) => {
+		if (resource.protocol !== "https:") return null;
+		if (resource.host !== "example.com") return null;
+		const m = /^\/@(\w+)$/.exec(resource.pathname);
+		if (m == null) return null;
+		return { username: m[1] };
+	};
+	await t.step("alias mapper", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "https://example.com/@someone");
+		let context = createContext(u);
+		let request = context.request;
+		let response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorAliasMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			aliases: ["https://example.com/users/someone"],
+			subject: "https://example.com/@someone"
+		});
+		u.searchParams.set("resource", "https://example.com/@bar");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			actorAliasMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected2,
+			aliases: ["acct:bar@example.com", "https://example.com/users/someone2"],
+			subject: "https://example.com/@bar"
+		});
+		u.searchParams.set("resource", "https://example.com/@no-one");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorAliasMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+		u.searchParams.set("resource", "https://example.com/@no-one");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			actorHandleMapper,
+			actorAliasMapper,
+			onNotFound
+		});
+		assertEquals(response.status, 404);
+	});
+	await t.step("handleHost", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:someone@example.com");
+		let context = createContext(u);
+		let request = context.request;
+		let response = await handleWebFinger(request, {
+			context,
+			host: "handle.example.com",
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			aliases: [...expected.aliases, "acct:someone@handle.example.com"]
+		});
+		u.searchParams.set("resource", "acct:someone@handle.example.com");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			host: "handle.example.com",
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected,
+			subject: "acct:someone@handle.example.com"
+		});
+		u.searchParams.set("resource", "https://example.com/users/someone2");
+		context = createContext(u);
+		request = context.request;
+		response = await handleWebFinger(request, {
+			context,
+			host: "handle.example.com",
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			...expected2,
+			aliases: ["acct:bar@handle.example.com", "acct:bar@example.com"],
+			subject: "https://example.com/users/someone2"
+		});
+	});
+	const expectedForLocalhostWithPort = {
+		subject: "acct:someone@localhost:8000",
+		aliases: ["https://localhost:8000/users/someone"],
+		links: [
+			{
+				href: "https://localhost:8000/users/someone",
+				rel: "self",
+				type: "application/activity+json"
+			},
+			{
+				href: "https://localhost:8000/@someone",
+				rel: "http://webfinger.net/rel/profile-page"
+			},
+			{
+				href: "https://localhost:8000/@someone",
+				rel: "alternate",
+				type: "text/html"
+			},
+			{
+				href: "https://localhost:8000/icon.jpg",
+				rel: "http://webfinger.net/rel/avatar",
+				type: "image/jpeg"
+			}
+		]
+	};
+	await t.step("on localhost with port, ok: resource=acct:...", async () => {
+		const u = new URL("https://localhost:8000/.well-known/webfinger");
+		u.searchParams.set("resource", "acct:someone@localhost:8000");
+		const context = createContext(u);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(response.headers.get("Content-Type"), "application/jrd+json");
+		assertEquals(response.headers.get("Access-Control-Allow-Origin"), "*");
+		assertEquals(await response.json(), expectedForLocalhostWithPort);
+	});
+	const expectedForHostnameWithPort = {
+		subject: "acct:someone@example.com:8000",
+		aliases: ["http://example.com:8000/users/someone"],
+		links: [
+			{
+				href: "http://example.com:8000/users/someone",
+				rel: "self",
+				type: "application/activity+json"
+			},
+			{
+				href: "http://example.com:8000/@someone",
+				rel: "http://webfinger.net/rel/profile-page"
+			},
+			{
+				href: "http://example.com:8000/@someone",
+				rel: "alternate",
+				type: "text/html"
+			},
+			{
+				href: "http://example.com:8000/icon.jpg",
+				rel: "http://webfinger.net/rel/avatar",
+				type: "image/jpeg"
+			}
+		]
+	};
+	await t.step("on hostname with port, ok: resource=acct:...", async () => {
+		const u = new URL("http://example.com:8000/.well-known/webfinger");
+		u.searchParams.set("resource", "acct:someone@example.com:8000");
+		const context = createContext(u);
+		const request = context.request;
+		const response = await handleWebFinger(request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(response.status, 200);
+		assertEquals(response.headers.get("Content-Type"), "application/jrd+json");
+		assertEquals(response.headers.get("Access-Control-Allow-Origin"), "*");
+		assertEquals(await response.json(), expectedForHostnameWithPort);
+	});
+});
+
+//#endregion

package/dist/webfinger/jrd.d.ts

@@ -0,0 +1,60 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region webfinger/jrd.d.ts
+/**
+* Describes a resource.  See also
+* [RFC 7033 section 4.4](https://datatracker.ietf.org/doc/html/rfc7033#section-4.4).
+*/
+/**
+ * Describes a resource.  See also
+ * [RFC 7033 section 4.4](https://datatracker.ietf.org/doc/html/rfc7033#section-4.4).
+ */
+interface ResourceDescriptor {
+  /**
+   * A URI that identifies the entity that this descriptor describes.
+   */
+  subject?: string;
+  /**
+   * URIs that identify the same entity as the `subject`.
+   */
+  aliases?: string[];
+  /**
+   * Conveys additional information about the `subject` of this descriptor.
+   */
+  properties?: Record<string, string>;
+  /**
+   * Links to other resources.
+   */
+  links?: Link[];
+}
+/**
+ * Represents a link.  See also
+ * [RFC 7033 section 4.4.4](https://datatracker.ietf.org/doc/html/rfc7033#section-4.4.4).
+ */
+interface Link {
+  /**
+   * The link's relation type, which is either a URI or a registered relation
+   * type (see [RFC 5988](https://datatracker.ietf.org/doc/html/rfc5988)).
+   */
+  rel: string;
+  /**
+   * The media type of the target resource (see
+   * [RFC 6838](https://datatracker.ietf.org/doc/html/rfc6838)).
+   */
+  type?: string;
+  /**
+   * A URI pointing to the target resource.
+   */
+  href: string;
+  /**
+   * Human-readable titles describing the link relation.  If the language is
+   * unknown or unspecified, the key is `"und"`.
+   */
+  titles?: Record<string, string>;
+  /**
+   * Conveys additional information about the link relation.
+   */
+  properties?: Record<string, string>;
+} //#endregion
+export { Link as Link$1, ResourceDescriptor };