@fedify/fedify 2.4.0-dev.2077 → 2.4.0-dev.2093

package/dist/federation/portable.test.mjs

@@ -7,13 +7,15 @@ import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
-import { o as verifyPortableObjectProof, r as signObject } from "../proof-CVL7JnZd.mjs";
-import { s as signRequest } from "../http-CCJ97Jql.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { i as signObject, s as verifyPortableObjectProof } from "../proof-DVXC6nYz.mjs";
+import { s as signRequest } from "../http-B2ftY0Ha.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation, v as PORTABLE_OBJECT_CONTENT_TYPE } from "../middleware-BMgzqBtr.mjs";
+import { o as createFederation, y as PORTABLE_OBJECT_CONTENT_TYPE } from "../middleware-E_0IH72m.mjs";
+import { configure, reset } from "@logtape/logtape";
 import { Collection, Create, Note, Object as Object$1, Person, Tombstone, lookupObject } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
-import { exportDidKey, formatIri, parseIri } from "@fedify/vocab-runtime";
+import { exportDidKey, formatIri, parseIri, toCompatibleEf61Id } from "@fedify/vocab-runtime";
 //#region src/federation/portable.test.ts
 const did = await exportDidKey(ed25519PublicKey.publicKey);
 const keyId = new URL(`${did}#${did.substring(8)}`);
@@ -276,6 +278,73 @@ test("Federation.fetch() authorizes portable object requests", async (t) => {
 		assertEquals(dispatched, 1);
 	});
 });
+test("Federation.fetch() serves portable objects with compatible IDs", async (t) => {
+	const federation = createTestFederation();
+	const compatible = (path, authority = did, origin = "example.com") => new URL(`https://${origin}/.well-known/apgateway/${authority}${path}`);
+	const objects = {
+		"compatible": () => sign(new Note({ id: compatible("/objects/compatible") })),
+		"other-gateway": () => sign(new Note({ id: compatible("/objects/other-gateway", did, "other.example") })),
+		"percent-encoded": () => sign(new Note({ id: compatible("/objects/percent-encoded", did.replaceAll(":", "%3A")) })),
+		"other-did": () => sign(new Note({ id: compatible("/objects/other-did", otherDid) }), otherKeyPair.privateKey, otherKeyId),
+		"other-path": () => sign(new Note({ id: compatible("/objects/else") })),
+		"fragment": () => sign(new Note({ id: compatible("/objects/fragment#note") })),
+		"malformed": () => sign(new Note({ id: new URL(compatible("/objects/malformed").href + "?@gateway=https%3A%2F%2Fexample.com") })),
+		"ordinary": () => sign(new Note({ id: new URL("https://example.com/objects/ordinary") })),
+		"unsigned": () => Promise.resolve(new Note({ id: compatible("/objects/unsigned") })),
+		"wrong-did": () => sign(new Note({ id: compatible("/objects/wrong-did") }), otherKeyPair.privateKey, otherKeyId),
+		"mutated-id": async () => {
+			const signed = await sign(new Note({ id: compatible("/objects/original") }));
+			const object = await Note.fromJsonLd(await signed.toJsonLd({ contextLoader: mockDocumentLoader }), {
+				contextLoader: mockDocumentLoader,
+				documentLoader: mockDocumentLoader
+			});
+			object.id.pathname = object.id.pathname.replace(/original$/, "mutated-id");
+			return object;
+		},
+		"actor": () => sign(new Person({
+			id: compatible("/objects/actor"),
+			inbox: compatible("/objects/actor/inbox"),
+			outbox: compatible("/objects/actor/outbox"),
+			gateways: [new URL("https://example.com/")]
+		}))
+	};
+	federation.setObjectDispatcher(Object$1, "/objects/{id}", (_ctx, { id }) => objects[id]?.() ?? null);
+	const expected = {
+		"compatible": 200,
+		"other-gateway": 200,
+		"percent-encoded": 200,
+		"other-did": 404,
+		"other-path": 404,
+		"fragment": 404,
+		"malformed": 404,
+		"ordinary": 404,
+		"unsigned": 500,
+		"wrong-did": 500,
+		"mutated-id": 404,
+		"actor": 200
+	};
+	for (const host of ["example.com", "other.example"]) for (const [id, status] of globalThis.Object.entries(expected)) await t.step(`${id} on ${host} → ${status}`, async () => {
+		const response = await federation.fetch(new Request(`https://${host}/.well-known/apgateway/${did}/objects/${id}`, { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		assertEquals(response.status, status);
+		if (status !== 200) return;
+		assertEquals(response.headers.get("Content-Type"), PORTABLE_OBJECT_CONTENT_TYPE);
+		assertEquals((await response.json()).id, (await objects[id]()).id?.href);
+	});
+	await t.step("authorizes compatible-ID objects on any gateway", async () => {
+		const authorized = createTestFederation();
+		authorized.setObjectDispatcher(Note, "/notes/{id}", (_ctx, values) => sign(new Note({ id: compatible(`/notes/${values.id}`) }))).authorize(async (ctx) => {
+			return (await ctx.getSignedKeyOwner())?.id?.href === "https://example.com/person2";
+		});
+		for (const host of ["example.com", "other.example"]) {
+			const url = `https://${host}/.well-known/apgateway/${did}/notes/1`;
+			const request = new Request(url, { headers: { Accept: ACCEPT } });
+			let response = await authorized.fetch(request, { contextData: void 0 });
+			assertEquals(response.status, 401, host);
+			response = await authorized.fetch(await signRequest(new Request(url, { headers: { Accept: ACCEPT } }), rsaPrivateKey3, rsaPublicKey3.id), { contextData: void 0 });
+			assertEquals(response.status, 200, host);
+		}
+	});
+});
 test("Federation.fetch() lets application routes shadow the gateway", async () => {
 	const federation = createTestFederation();
 	const paths = [];
@@ -426,5 +495,114 @@ test("Federation.fetch() serves portable actors through WebFinger", async () =>
 		document: unsigned
 	}) }), null);
 });
+/**
+* Captures Fedify's warnings logged while `run` executes.
+*/
+async function captureWarnings(run) {
+	const records = [];
+	await reset();
+	try {
+		await configure({
+			sinks: { buffer: (record) => records.push(record) },
+			filters: {},
+			loggers: [{
+				category: ["logtape", "meta"],
+				sinks: []
+			}, {
+				category: [],
+				sinks: ["buffer"],
+				lowestLevel: "warning"
+			}]
+		});
+		await run();
+	} finally {
+		await reset();
+	}
+	return records.filter((record) => record.category[0] === "fedify");
+}
+test("Federation.fetch() serves compatible-ID actors", async (t) => {
+	const federation = createTestFederation();
+	const actorGateways = {
+		alice: ["https://example.com"],
+		secondary: ["https://primary.example", "https://example.com"],
+		nogateway: [],
+		malformed: ["https://example.com"]
+	};
+	const getActor = async (ctx, name) => {
+		const gateways = actorGateways[name];
+		if (gateways == null) return null;
+		const id = toCompatibleEf61Id(ctx.getPortableObjectUri(Person, { name }, did), "https://example.com");
+		if (name === "malformed") id.search = "?@gateway=https%3A%2F%2Fexample.com";
+		return await sign(new Person({
+			id,
+			preferredUsername: name,
+			inbox: new URL(`${id.href}/inbox`),
+			followers: new URL(`${id.href}/followers`),
+			gateways: gateways.map((g) => new URL(g))
+		}));
+	};
+	federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => getActor(ctx, identifier)).mapHandle((_ctx, username) => username).mapAlias((_ctx, resource) => {
+		const match = resource.href.match(/\/actors\/([^/?#]+)$/);
+		return match == null || !resource.href.startsWith(gatewayUrl("/")) ? null : { identifier: match[1] };
+	});
+	federation.setFollowersDispatcher("/users/{identifier}/followers", () => ({ items: [] }));
+	federation.setObjectDispatcher(Person, "/actors/{name}", (ctx, values) => ctx.portableRequest?.authority === did ? getActor(ctx, values.name) : null);
+	const compatibleId = gatewayUrl("/actors/alice");
+	await t.step("WebFinger", async () => {
+		let records = [];
+		records = await captureWarnings(async () => {
+			for (const resource of ["acct:alice@example.com", compatibleId]) {
+				const response = await federation.fetch(new Request(`https://example.com/.well-known/webfinger?resource=${encodeURIComponent(resource)}`), { contextData: void 0 });
+				assertEquals(response.status, 200, resource);
+				const jrd = await response.json();
+				assertEquals(jrd.subject, "acct:alice@example.com", resource);
+				assertEquals(jrd.links?.[0], {
+					rel: "self",
+					href: compatibleId,
+					type: "application/activity+json"
+				});
+			}
+		});
+		assertEquals(records.map((r) => r.rawMessage), []);
+	});
+	await t.step("gateway", async () => {
+		const response = await federation.fetch(new Request(compatibleId, { headers: { Accept: ACCEPT } }), { contextData: void 0 });
+		assertEquals(response.status, 200);
+		const json = await response.json();
+		assertEquals(json.id, compatibleId);
+		const actor = await lookupObject(compatibleId, {
+			documentLoader: (url) => Promise.resolve({
+				contextUrl: null,
+				documentUrl: url,
+				document: json
+			}),
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifyPortableObjectProof
+		});
+		assertInstanceOf(actor, Person);
+		assertEquals(actor.id?.href, compatibleId);
+	});
+	await t.step("warns if the ID is not on the first gateway", async () => {
+		assertEquals((await captureWarnings(async () => {
+			const response = await federation.fetch(new Request("https://example.com/.well-known/webfinger?resource=acct:secondary@example.com"), { contextData: void 0 });
+			assertEquals(response.status, 200);
+			const jrd = await response.json();
+			assertEquals(jrd.subject, "acct:secondary@primary.example");
+			assertEquals(jrd.links?.[0].href, gatewayUrl("/actors/secondary"));
+		})).map((r) => r.properties.gateway), ["https://primary.example"]);
+	});
+	await t.step("warns if the actor has no gateways", async () => {
+		assertEquals((await captureWarnings(async () => {
+			assertEquals((await federation.fetch(new Request("https://example.com/users/nogateway", { headers: { Accept: ACCEPT } }), { contextData: void 0 })).status, 200);
+		})).map((r) => r.properties.actorId), [gatewayUrl("/actors/nogateway")]);
+	});
+	await t.step("warns if the ID is a malformed compatible identifier", async () => {
+		const records = await captureWarnings(async () => {
+			assertEquals((await federation.fetch(new Request("https://example.com/users/malformed", { headers: { Accept: ACCEPT } }), { contextData: void 0 })).status, 200);
+		});
+		assertEquals(records.length, 1);
+		assert(String(records[0].rawMessage).includes("malformed"));
+	});
+});
 //#endregion
 export {};

package/dist/federation/send.test.mjs

@@ -10,10 +10,10 @@ import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { l as verifyRequest } from "../http-CCJ97Jql.mjs";
+import { l as verifyRequest } from "../http-B2ftY0Ha.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as doesActorOwnKey } from "../owner-DGbYmXqU.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-Ejy1jOz9.mjs";
+import { t as doesActorOwnKey } from "../owner-Cgx2Dc7I.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-D-hOvYKy.mjs";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";

package/dist/federation/tasks/enqueue.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
 import "../../testing-CO_cEvQc.mjs";
-import { o as createFederation } from "../../middleware-BMgzqBtr.mjs";
+import { o as createFederation } from "../../middleware-E_0IH72m.mjs";
 import { n as ParallelMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { delay } from "es-toolkit";

package/dist/federation/tasks/tasks.test.mjs

@@ -4,8 +4,8 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-dbCShlCb.mjs";
 import "../../testing-CO_cEvQc.mjs";
-import { o as createFederation } from "../../middleware-BMgzqBtr.mjs";
-import { r as createFederationBuilder } from "../../builder-i3jxVe9m.mjs";
+import { o as createFederation } from "../../middleware-E_0IH72m.mjs";
+import { r as createFederationBuilder } from "../../builder-Ld4Y9ymR.mjs";
 import { t as TaskCodec } from "../../codec-C6rTrpIp.mjs";
 import { t as InProcessMessageQueue } from "../../mq-Dm1Wmtm-.mjs";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";

package/dist/federation/temporal.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "../temporal-DNJ1cNpr.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-CqpKGEPk.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/temporal.test.ts
 test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {

package/dist/federation/webfinger.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-BMgzqBtr.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-E_0IH72m.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { parseIri } from "@fedify/vocab-runtime";
@@ -852,5 +852,93 @@ test("handleWebFinger() for FEP-ef61 portable actors", async (t) => {
 		assertEquals((await query("acct:alice@primary.example")).status, 404);
 	});
 });
+test("handleWebFinger() for FEP-ef61 compatible-ID actors", async (t) => {
+	const compatibleId = `https://example.com/.well-known/apgateway/did:key:z6Mkabc/actor`;
+	const actors = {
+		alice: {
+			id: compatibleId,
+			gateways: [new URL("https://example.com")]
+		},
+		secondary: {
+			id: compatibleId,
+			gateways: [new URL("https://primary.example"), new URL("https://example.com")]
+		},
+		malformed: {
+			id: `${compatibleId}?@gateway=https%3A%2F%2Fexample.com`,
+			gateways: [new URL("https://example.com")]
+		},
+		nogateway: {
+			id: compatibleId,
+			gateways: []
+		}
+	};
+	const actorDispatcher = (_ctx, identifier) => {
+		const actor = actors[identifier];
+		if (actor == null) return null;
+		return new Person({
+			id: new URL(actor.id),
+			preferredUsername: "alice",
+			gateways: actor.gateways
+		});
+	};
+	const actorAliasMapper = (_ctx, resource) => resource.href === compatibleId ? { identifier: "alice" } : null;
+	async function query(resource) {
+		const url = new URL("https://example.com/.well-known/webfinger");
+		url.searchParams.set("resource", resource);
+		const context = createRequestContext({
+			federation: createFederation({ kv: new MemoryKvStore() }),
+			url,
+			data: void 0,
+			getActorUri(identifier) {
+				return new URL(`${url.origin}/users/${identifier}`);
+			},
+			parseUri: () => null
+		});
+		return await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			actorAliasMapper,
+			onNotFound: () => new Response("Not found", { status: 404 })
+		});
+	}
+	const selfLink = {
+		rel: "self",
+		href: compatibleId,
+		type: "application/activity+json"
+	};
+	await t.step("acct: on the first gateway", async () => {
+		const response = await query("acct:alice@example.com");
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			subject: "acct:alice@example.com",
+			aliases: [compatibleId],
+			links: [selfLink]
+		});
+	});
+	await t.step("compatible identifier", async () => {
+		const response = await query(compatibleId);
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			subject: "acct:alice@example.com",
+			aliases: [compatibleId],
+			links: [selfLink]
+		});
+	});
+	await t.step("compatible identifier not on the first gateway", async () => {
+		const response = await query("acct:secondary@example.com");
+		assertEquals(response.status, 200);
+		assertEquals(await response.json(), {
+			subject: "acct:alice@primary.example",
+			aliases: [compatibleId, "acct:secondary@example.com"],
+			links: [selfLink]
+		});
+	});
+	await t.step("malformed compatible identifier", async () => {
+		assertEquals((await query("acct:malformed@example.com")).status, 404);
+	});
+	await t.step("no gateways", async () => {
+		assertEquals((await query("acct:nogateway@example.com")).status, 404);
+	});
+});
 //#endregion
 export {};