@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/{deno-BHzKn9Ig.mjs → deno-oR5aJKpU.mjs}

@@ -3,6 +3,6 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-pr.936.41+59c7432c";
+var version = "2.5.0-dev.2271+49d937e2";
 //#endregion
 export { version as n, name as t };

package/dist/dist-DJQM4u7i.mjs

@@ -0,0 +1,189 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { createRequire } from "node:module";
+import { configure, getConsoleSink, getLogger, reset } from "@logtape/logtape";
+import "@opentelemetry/sdk-trace-base";
+import "@opentelemetry/core";
+//#region ../fixture/dist/mod.js
+const fixtureFetch = globalThis.fetch.bind(globalThis);
+const logger = getLogger(["fixture", "docloader"]);
+/**
+* A mock of the document loader.  This does not make any actual HTTP requests
+* towards the remote server, but looks up the local fixture files instead.
+*
+* For instance, `mockDocumentLoader("http://example.com/foo/bar")` will look up
+* the file `testing/fixtures/http/example.com/foo/bar` (no suffix) and return
+* its content as the response.
+*/
+async function mockDocumentLoader(resource, _options) {
+	const url = new URL(resource);
+	if ("navigator" in globalThis && navigator.userAgent === "Cloudflare-Workers") {
+		const testUrl = new URL(url);
+		testUrl.hostname += ".test";
+		const resp = await fixtureFetch(testUrl);
+		if (resp.ok) {
+			const document = await resp.json();
+			logger.debug("Successfully fetched fixture {resource}: {status} {statusText}\n{body}", {
+				resource,
+				status: resp.status,
+				statusText: resp.statusText,
+				body: document
+			});
+			return {
+				contextUrl: null,
+				document,
+				documentUrl: resource
+			};
+		}
+		const error = await resp.text();
+		logger.error("Failed to fetch fixture {resource}: {error}", {
+			resource,
+			error
+		});
+		throw new Error(error);
+	}
+	const fixturePath = `${"Deno" in globalThis ? "." : "@fedify/fixture"}/fixtures/${url.host}${url.pathname}.json`;
+	let document;
+	try {
+		document = (await import(fixturePath, { with: { type: "json" } })).default;
+	} catch (error) {
+		logger.error("Failed to read fixture file {path}: {error}", {
+			path: fixturePath,
+			error
+		});
+		throw error;
+	}
+	return {
+		contextUrl: null,
+		document,
+		documentUrl: resource
+	};
+}
+const testDefinitions = [];
+function test(name, options, fn) {
+	const def = typeof name === "string" ? typeof options === "function" ? {
+		name,
+		fn: options
+	} : {
+		name,
+		...options,
+		fn
+	} : name;
+	testDefinitions.push(def);
+	if ("Deno" in globalThis) {
+		const func = def.fn;
+		Deno.test({
+			...def,
+			async fn(t) {
+				const records = [];
+				await configure({
+					sinks: {
+						buffer(record) {
+							if (record.category.length > 1 && record.category[0] === "logtape" && record.category[1] === "meta") return;
+							records.push(record);
+						},
+						console: getConsoleSink()
+					},
+					filters: {},
+					loggers: [{
+						category: [],
+						sinks: [Deno.env.get("LOG") === "always" ? "console" : "buffer"]
+					}]
+				});
+				try {
+					await func(t);
+				} catch (e) {
+					const consoleSink = getConsoleSink();
+					for (const record of records) consoleSink(record);
+					throw e;
+				} finally {
+					await reset();
+				}
+			}
+		});
+	} else if ("Bun" in globalThis) {
+		let failed = void 0;
+		async function step(defOrNameOrFn, fn) {
+			let def;
+			if (typeof defOrNameOrFn === "string") def = {
+				name: defOrNameOrFn,
+				fn
+			};
+			else if (typeof defOrNameOrFn === "function") def = {
+				name: defOrNameOrFn.name,
+				fn: defOrNameOrFn
+			};
+			else def = defOrNameOrFn;
+			if (def.ignore) return false;
+			try {
+				await def.fn({
+					name: def.name,
+					origin: "",
+					step
+				});
+			} catch (e) {
+				failed ??= e;
+				return false;
+			}
+			return true;
+		}
+		const ctx = {
+			name: def.name,
+			origin: "",
+			step
+		};
+		async function fn() {
+			await def.fn(ctx);
+			if (failed) throw failed;
+		}
+		const bunTest = Bun.jest(caller()).test;
+		if (def.ignore) bunTest.skip(def.name, fn);
+		else bunTest(def.name, fn);
+	} else if (typeof process !== "undefined" && process.release?.name === "node" && !("navigator" in globalThis && navigator.userAgent === "Cloudflare-Workers")) {
+		const { test: nodeTest } = createRequire(process.cwd() + "/")("node:test");
+		nodeTest(def.name, { skip: def.ignore }, async (t) => {
+			await def.fn(intoTestContext(def.name, t));
+		});
+	}
+}
+function intoTestContext(name, ctx) {
+	async function step(defOrNameOrFn, fn) {
+		let def;
+		if (typeof defOrNameOrFn === "string") def = {
+			name: defOrNameOrFn,
+			fn
+		};
+		else if (typeof defOrNameOrFn === "function") def = {
+			name: defOrNameOrFn.name,
+			fn: defOrNameOrFn
+		};
+		else def = defOrNameOrFn;
+		let failed = false;
+		await ctx.test(def.name, { skip: def.ignore }, async (ctx2) => {
+			try {
+				await def.fn(intoTestContext(def.name, ctx2));
+			} catch (e) {
+				failed = true;
+				throw e;
+			}
+		});
+		return !def.ignore && !failed;
+	}
+	return {
+		name,
+		origin: ctx.filePath ?? "",
+		step
+	};
+}
+/** Retrieve caller test file. */
+function caller() {
+	const Trace = Error;
+	const _ = Trace.prepareStackTrace;
+	Trace.prepareStackTrace = (_, stack) => stack;
+	const { stack } = /* @__PURE__ */ new Error();
+	Trace.prepareStackTrace = _;
+	return stack[2].getFileName().replaceAll("\\", "/");
+}
+//#endregion
+export { test as n, testDefinitions as r, mockDocumentLoader as t };

package/dist/docloader-DBoYbvYW.mjs

@@ -0,0 +1,87 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { c as validateCryptoKey } from "./key-BspPiXqn.mjs";
+import { n as doubleKnock } from "./http-siciWkmx.mjs";
+import { getLogger } from "@logtape/logtape";
+import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, resolveDocumentLoaderTimeout, validatePublicUrl, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
+import { curry } from "es-toolkit";
+//#region src/utils/docloader.ts
+const logger = getLogger([
+	"fedify",
+	"utils",
+	"docloader"
+]);
+const DEFAULT_MAX_REDIRECTION = 20;
+/**
+* Gets an authenticated {@link DocumentLoader} for the given identity.
+* Note that an authenticated document loader intentionally does not cache
+* the fetched documents.
+* 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, including its double-knocking retries, times out after
+* 10 seconds by default; see {@link DocumentLoaderFactoryOptions.timeout}.
+* @param identity The identity to get the document loader for.
+*                 The actor's key pair.
+* @param options The options for the document loader.
+* @returns The authenticated document loader.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @throws {RangeError} If the `timeout` option is invalid.
+* @since 0.4.0
+*/
+function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, timeout, tracerProvider } = {}) {
+	validateCryptoKey(identity.privateKey);
+	const resolvedTimeout = resolveDocumentLoaderTimeout(timeout);
+	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
+		options?.signal?.throwIfAborted();
+		let currentUrl = new URL(url).href;
+		await validateUrl(currentUrl, options);
+		visited.add(currentUrl);
+		const originalRequest = createActivityPubRequest(currentUrl, { userAgent });
+		function follow(nextUrl) {
+			options?.signal?.throwIfAborted();
+			if (redirected >= DEFAULT_MAX_REDIRECTION) throw new FetchError(currentUrl, `Too many redirections (${redirected + 1})`);
+			if (visited.has(nextUrl)) throw new FetchError(currentUrl, `Redirect loop detected: ${nextUrl}`);
+			redirected++;
+		}
+		const response = await doubleKnock(originalRequest, identity, {
+			maxRedirection,
+			specDeterminer,
+			log: curry(logRequest)(logger),
+			tracerProvider,
+			signal: options?.signal,
+			validateRedirect: async (nextUrl) => {
+				follow(nextUrl);
+				await validateUrl(nextUrl, options);
+				visited.add(nextUrl);
+				currentUrl = nextUrl;
+			}
+		});
+		options?.signal?.throwIfAborted();
+		return getRemoteDocument(currentUrl, response, (alternateUrl) => {
+			follow(alternateUrl);
+			return load(alternateUrl, options, redirected, visited);
+		}, options);
+	}
+	async function validateUrl(url, options) {
+		if (!allowPrivateAddress) {
+			try {
+				await validatePublicUrl(url);
+			} catch (error) {
+				if (error instanceof UrlError) if (error.reason === "dns") logger.debug("DNS lookup failed for {url}", {
+					url,
+					error
+				});
+				else logger[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+					url,
+					error
+				});
+				throw error;
+			}
+			options?.signal?.throwIfAborted();
+		}
+	}
+	return withDocumentLoaderTimeout((url, options) => load(url, options), resolvedTimeout);
+}
+//#endregion
+export { getAuthenticatedDocumentLoader as t };

package/dist/{esm-yYQfPhIY.mjs → esm-BHXXx4Wx.mjs}

@@ -129,27 +129,27 @@ function parse(input, loose) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/TypeDescriptor.js
-const valueTypes = new Set([
+const valueTypes = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"null",
 	"string",
 	"undefined"
 ]);
-const referenceTypes = new Set([
+const referenceTypes = /* @__PURE__ */ new Set([
 	"array",
 	"function",
 	"object",
 	"symbol"
 ]);
-const detectableTypes = new Set([
+const detectableTypes = /* @__PURE__ */ new Set([
 	"boolean",
 	"function",
 	"number",
 	"string",
 	"symbol"
 ]);
-const typeConstructors = new Set([
+const typeConstructors = /* @__PURE__ */ new Set([
 	Boolean,
 	Number,
 	String
@@ -220,7 +220,7 @@ var TypeDescriptor = class TypeDescriptor {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/IsSubsetOf.js
-const allowedTypes = new Set([
+const allowedTypes = /* @__PURE__ */ new Set([
 	"array",
 	"object",
 	"function",
@@ -712,7 +712,14 @@ var __classPrivateFieldGet = function(receiver, state, kind, f) {
 	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Route_instances, _a, _Route_responseSubscriptions, _Route_validate, _Route_sanitize, _Route_generateMatcher, _Route_limit, _Route_delayResponse;
+var _Route_instances;
+var _a;
+var _Route_responseSubscriptions;
+var _Route_validate;
+var _Route_sanitize;
+var _Route_generateMatcher;
+var _Route_limit;
+var _Route_delayResponse;
 var RouteConfigWrapper = class {
 	constructor(config) {
 		Object.assign(this, config);

package/dist/federation/audience.test.d.mts

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

package/dist/federation/audience.test.mjs

@@ -0,0 +1,130 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as isPubliclyAddressedNode, t as isInAudience } from "../audience-CHQ-FlLD.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { Note, PUBLIC_COLLECTION, Person } from "@fedify/vocab";
+import { parseIri, toCompatibleEf61Id } from "@fedify/vocab-runtime";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+//#region src/federation/audience.test.ts
+const did = "did:key:z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2";
+async function expand(document) {
+	const [node] = await jsonld.expand({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/notes/1",
+		type: "Note",
+		...document
+	}, { documentLoader: mockDocumentLoader });
+	return node;
+}
+test("isPubliclyAddressedNode()", async (t) => {
+	for (const property of [
+		"to",
+		"cc",
+		"bto",
+		"bcc",
+		"audience"
+	]) for (const value of [
+		PUBLIC_COLLECTION.href,
+		"as:Public",
+		"Public",
+		["https://example.com/person", "as:Public"]
+	]) await t.step(`${JSON.stringify(value)} in ${property}`, async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({ [property]: value })), true);
+	});
+	await t.step("not addressed", async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({})), false);
+	});
+	await t.step("addressed to other recipients", async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({
+			to: "https://example.com/person",
+			cc: "https://example.com/person/followers"
+		})), false);
+	});
+	await t.step("Public in other properties", async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({ tag: PUBLIC_COLLECTION.href })), false);
+	});
+	await t.step("a Public literal rather than an ID", async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({ to: { "@value": PUBLIC_COLLECTION.href } })), false);
+	});
+	await t.step("Public that the context maps elsewhere", async () => {
+		for (const [context, to] of [[{ as: "https://example.com/ns#" }, "as:Public"], [{ "@base": "https://example.com/" }, "Public"]]) {
+			const [node] = await jsonld.expand({
+				"@context": ["https://www.w3.org/ns/activitystreams", context],
+				id: "https://example.com/notes/1",
+				type: "Note",
+				to
+			}, { documentLoader: mockDocumentLoader });
+			assertEquals(isPubliclyAddressedNode(node), false, JSON.stringify(context));
+		}
+	});
+	await t.step("only the node itself is checked", async () => {
+		assertEquals(isPubliclyAddressedNode(await expand({
+			type: "Create",
+			actor: "https://example.com/person",
+			object: {
+				type: "Note",
+				id: "https://example.com/notes/2",
+				to: PUBLIC_COLLECTION.href
+			}
+		})), false);
+	});
+});
+test("isInAudience()", async (t) => {
+	const person = new Person({ id: new URL("https://example.com/person") });
+	const portableId = parseIri(`ap+ef61://${did}/actor`);
+	const portable = new Person({ id: toCompatibleEf61Id(portableId, "https://other.example") });
+	const followers = new URL("https://example.com/person2/followers");
+	await t.step("publicly addressed", async () => {
+		for (const actor of [null, person]) assertEquals(await isInAudience(new Note({ cc: PUBLIC_COLLECTION }), actor), true);
+	});
+	await t.step("no actor", async () => {
+		assertEquals(await isInAudience(new Note({ to: person.id }), null), false);
+		assertEquals(await isInAudience(new Note({}), null), false);
+	});
+	await t.step("directly addressed", async () => {
+		for (const property of [
+			"to",
+			"cc",
+			"bto",
+			"bcc",
+			"audience"
+		]) assertEquals(await isInAudience(new Note({ [property]: person.id }), person), true, property);
+	});
+	await t.step("not addressed", async () => {
+		assertEquals(await isInAudience(new Note({ to: new URL("https://example.com/other") }), person), false);
+		assertEquals(await isInAudience(new Note({ to: person.id }), new Person({})), false);
+	});
+	await t.step("portable IDs are compared canonically", async () => {
+		for (const addressee of [
+			portableId,
+			parseIri(`ap://${did}/actor`),
+			parseIri(`ap+ef61://${did.replaceAll(":", "%3A")}/actor`),
+			toCompatibleEf61Id(portableId, "https://example.com")
+		]) assertEquals(await isInAudience(new Note({ to: addressee }), portable), true, addressee.href);
+		assertEquals(await isInAudience(new Note({ to: parseIri(`ap+ef61://${did}/other`) }), portable), false);
+		assertEquals(await isInAudience(new Note({ to: new URL(`https://other.example/${did}/actor`) }), portable), false);
+	});
+	await t.step("isMember()", async () => {
+		const calls = [];
+		const isMember = (addressee, actor) => {
+			calls.push(`${addressee.href} ${actor.id?.href}`);
+			return addressee.href === followers.href;
+		};
+		const note = new Note({
+			to: new URL("https://example.com/other"),
+			cc: followers
+		});
+		assertEquals(await isInAudience(note, person, { isMember }), true);
+		assertEquals(calls, [`https://example.com/other ${person.id?.href}`, `${followers.href} ${person.id?.href}`]);
+		calls.length = 0;
+		assertEquals(await isInAudience(new Note({ to: person.id }), person, { isMember }), true);
+		assertEquals(await isInAudience(note, null, { isMember }), false);
+		assertEquals(calls, []);
+		assertEquals(await isInAudience(note, person, { isMember: () => false }), false);
+	});
+});
+//#endregion
+export {};

package/dist/federation/builder.test.mjs

@@ -1,11 +1,13 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as MemoryKvStore } from "../kv-CXBAok3k.mjs";
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import { r as assertExists } from "../std__assert-B2NnY9bq.mjs";
-import { t as assertThrows } from "../assert_throws-NiFfqbnH.mjs";
-import { r as createFederationBuilder } from "../builder-DonuxRl_.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertExists } from "../assert_exists-cffSpJ7X.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 { r as createFederationBuilder } from "../builder-Bda6LK7A.mjs";
 import { DisallowedOperatorError, DisallowedVarSpecModifierError, DuplicateRouteVariableError, RouteTemplateOptionsNotMatchedError, RouterError } from "@fedify/uri-template";
 import { Activity, Note, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
@@ -342,6 +344,53 @@ test("FederationBuilder", async (t) => {
 		});
 		builder.setCollectionDispatcher(strId, Note, "/string-id/{id}", dispatcher);
 	});
+	await t.step("propagates custom collection dispatchers to the built federation", async () => {
+		const kv = new MemoryKvStore();
+		const builder = createFederationBuilder();
+		builder.setCollectionDispatcher("test", Note, "/c/{id}", () => ({ items: [] }));
+		const impl = await builder.build({
+			kv,
+			origin: "https://example.com"
+		});
+		assertExists(impl.collectionCallbacks["test"]);
+		assertEquals(impl.collectionTypeIds["test"], Note);
+		assertEquals((await impl.fetch(new Request("https://example.com/c/x", { headers: { accept: "application/activity+json" } }), { contextData: void 0 })).status, 200);
+	});
+	await t.step("preserves symbol-named collections through build()", async () => {
+		const builder = createFederationBuilder();
+		const collection = Symbol("saved");
+		const ordered = Symbol("saved");
+		builder.setCollectionDispatcher(collection, Note, "/users/{identifier}/saved", () => ({ items: [] }));
+		builder.setOrderedCollectionDispatcher(ordered, Note, "/users/{identifier}/ordered-saved", () => ({ items: [] }));
+		for (let build = 0; build < 2; build++) {
+			const federation = await builder.build({ kv: new MemoryKvStore() });
+			const ctx = federation.createContext(new URL("https://example.com/"));
+			for (const [name, path, type] of [[
+				collection,
+				"/users/alice/saved",
+				"collection"
+			], [
+				ordered,
+				"/users/alice/ordered-saved",
+				"orderedCollection"
+			]]) {
+				const uri = ctx.getCollectionUri(name, { identifier: "alice" });
+				assertEquals(uri.pathname, path);
+				const parsed = ctx.parseUri(uri);
+				assertEquals(parsed?.type, type);
+				if (parsed?.type !== "collection" && parsed?.type !== "orderedCollection") throw new Error("Expected a custom collection URI");
+				assertStrictEquals(parsed.name, name);
+				assertStrictEquals(parsed.class, Note);
+				assertEquals(parsed.values, { identifier: "alice" });
+				for (const cursor of [null, "next"]) {
+					const pageUri = new URL(uri);
+					if (cursor != null) pageUri.searchParams.set("cursor", cursor);
+					assertEquals((await federation.fetch(new Request(pageUri, { headers: { accept: "application/activity+json" } }), { contextData: void 0 })).status, 200);
+				}
+			}
+			assertThrows(() => federation.setCollectionDispatcher(collection, Note, "/users/{identifier}/duplicate", () => ({ items: [] })));
+		}
+	});
 });
 //#endregion
 export {};