@fedify/fedify 2.5.0-dev.2446 → 2.5.0-dev.2448

package/dist/inbox-wDuMKaFW.mjs

@@ -0,0 +1,312 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as getAuthenticationOrigin } from "./portable-key-id-Ca30-hOa.mjs";
+import { o as serializeAuthentication, r as getEffectivePrincipals } from "./inbox-authentication-DflPYlLL.mjs";
+import { n as version, t as name } from "./deno-Dpewt_jJ.mjs";
+import { g as recordInboxActivity, n as getDurationMs, r as getFederationMetrics } from "./metrics-B-QxRSSR.mjs";
+import { getLogger } from "@logtape/logtape";
+import { getTypeId } from "@fedify/vocab";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+//#region src/federation/inbox.ts
+/**
+* Checks whether an activity's ID and all of its actor IDs have the same
+* [FEP-fe34] origin.  Activities without an ID have no origin to authenticate.
+*
+* Origins are compared by `getAuthenticationOrigin()`, so a portable activity
+* and its portable actors, including compatible identifiers on any gateway,
+* are compared by their DIDs.  An ID that has no supported origin, such as an
+* opaque URN, never matches.
+*
+* The caller is responsible for rejecting a missing primary actor ID before
+* relying on this check.
+*
+* [FEP-fe34]: https://w3id.org/fep/fe34
+* @internal
+*/
+function actorsHaveSameOrigin(activity) {
+	if (activity.id == null) return true;
+	const origin = getAuthenticationOrigin(activity.id);
+	return origin != null && activity.actorIds.every((actor) => getAuthenticationOrigin(actor) === origin);
+}
+/**
+* The headroom that the size check of a queued inbox message leaves for the
+* fields that grow when Fedify retries the message, e.g., its attempt count.
+*/
+const QUEUED_MESSAGE_HEADROOM = 64;
+/**
+* Computes the idempotency key of an incoming activity.
+* @returns The key, or `null` if the activity is not deduplicated.
+* @internal
+*/
+async function getInboxIdempotencyKey(strategy, inboxContext, activity, origin, recipient, prefix) {
+	if (activity.id == null) return null;
+	strategy ??= "per-inbox";
+	let keyString;
+	if (typeof strategy === "function") keyString = await strategy(inboxContext(), activity);
+	else switch (strategy) {
+		case "global":
+			keyString = activity.id.href;
+			break;
+		case "per-origin":
+			keyString = `${origin}\n${activity.id.href}`;
+			break;
+		case "per-inbox":
+			keyString = `${origin}\n${activity.id.href}\n${recipient == null ? "sharedInbox" : `inbox\n${recipient}`}`;
+			break;
+		default: keyString = `${origin}\n${activity.id.href}`;
+	}
+	return keyString == null ? null : [...prefix, keyString];
+}
+/**
+* Checks whether an incoming activity has already been processed, by its
+* idempotency key, or by the key that queue workers of older versions of
+* Fedify recorded.
+* @internal
+*/
+async function isInboxActivityProcessed(kv, cacheKey, activity, origin, prefix) {
+	if (cacheKey == null) return false;
+	if (await kv.get(cacheKey) === true) return true;
+	if (activity.id == null) return false;
+	return await kv.get([
+		...prefix,
+		origin,
+		activity.id.href
+	]) === true;
+}
+/**
+* The bytes added to the UTF-8 JSON length of a message for each of its JSON
+* values, to bound the size of serialization formats other than JSON, such
+* as the structured serialization of Deno KV, which spends more bytes than
+* JSON on type tags and lengths of small values, e.g., empty arrays, and up
+* to nine bytes on a fractional number that JSON writes in three.
+*/
+const PER_VALUE_SERIALIZATION_OVERHEAD = 8;
+/**
+* Estimates, conservatively, how large a queued message is once a queue
+* backend serializes it: the UTF-8 length of its JSON serialization, plus
+* a fixed overhead for each JSON value in it, plus the bytes that encoding
+* strings beyond Latin-1 as UTF-16 adds.
+* @internal
+*/
+function estimateQueuedMessageSize(message) {
+	const encoder = new TextEncoder();
+	let values = 0;
+	let stringExpansion = 0;
+	const countString = (value) => {
+		values++;
+		if (!/[\u0100-\uffff]/.test(value)) return;
+		const expansion = value.length * 2 - encoder.encode(value).byteLength;
+		if (expansion > 0) stringExpansion += expansion;
+	};
+	const count = (value) => {
+		if (typeof value === "string") {
+			countString(value);
+			return;
+		}
+		values++;
+		if (Array.isArray(value)) for (const item of value) count(item);
+		else if (value != null && typeof value === "object") for (const [key, item] of Object.entries(value)) {
+			if (item === void 0) continue;
+			countString(key);
+			count(item);
+		}
+	};
+	count(message);
+	return encoder.encode(JSON.stringify(message)).byteLength + stringExpansion + values * PER_VALUE_SERIALIZATION_OVERHEAD;
+}
+/**
+* Checks whether an activity that declares no actor is authenticated: at
+* least one principal must be authenticated for it, and its ID, if any, must
+* have the same [FEP-fe34] origin as one of those principals.
+*
+* [FEP-fe34]: https://w3id.org/fep/fe34
+* @returns `"ok"` if it is authenticated, or why it is not.
+* @internal
+*/
+function checkActorlessActivity(activity, authentication) {
+	const principals = getEffectivePrincipals(authentication);
+	if (principals.length < 1) return {
+		status: "noAuthenticatedPrincipal",
+		principals
+	};
+	if (activity.id == null) return {
+		status: "ok",
+		principals
+	};
+	const origin = getAuthenticationOrigin(activity.id);
+	if (origin == null || !principals.some((principal) => getAuthenticationOrigin(principal.id) === origin)) return {
+		status: "activityOriginMismatch",
+		principals
+	};
+	return {
+		status: "ok",
+		principals
+	};
+}
+/**
+* Same as {@link checkActorlessActivity}, but returns a boolean.
+* @internal
+*/
+function isActorlessActivityAuthenticated(activity, authentication) {
+	return checkActorlessActivity(activity, authentication).status === "ok";
+}
+async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, authentication, verifiedView, replayable, actorless, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	if (activity.actorId == null && !actorless) {
+		logger.error("Missing actor.", { activity: json });
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: "Missing actor."
+		});
+		recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
+		return "missingActor";
+	}
+	const contextMetadata = { authentication };
+	const cacheKey = await getInboxIdempotencyKey(idempotencyStrategy, () => inboxContextFactory(recipient, json, activity.id?.href, getTypeId(activity).href, contextMetadata), activity, ctx.origin, recipient, kvPrefixes.activityIdempotence);
+	if (await isInboxActivityProcessed(kv, cacheKey, activity, ctx.origin, kvPrefixes.activityIdempotence)) {
+		logger.debug("Activity {activityId} has already been processed.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		span.setStatus({
+			code: SpanStatusCode.UNSET,
+			message: `Activity ${activity.id?.href} has already been processed.`
+		});
+		recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
+		return "alreadyProcessed";
+	}
+	if (activity.actorId != null) span.setAttribute("activitypub.actor.id", activity.actorId.href);
+	let message;
+	if (queue != null) {
+		const carrier = {};
+		propagation.inject(context.active(), carrier);
+		message = {
+			type: "inbox",
+			id: crypto.randomUUID(),
+			baseUrl: ctx.origin,
+			activity: originalJson ?? json,
+			...normalizedActivity == null ? {} : { normalizedActivity },
+			...ldSignatureVerified == null ? {} : { ldSignatureVerified },
+			...verifiedView == null ? {} : { verifiedView },
+			...authentication == null ? {} : { authentication: serializeAuthentication(authentication) },
+			identifier: recipient,
+			attempt: 0,
+			started: (/* @__PURE__ */ new Date()).toISOString(),
+			traceContext: carrier
+		};
+		const maxMessageSize = queue.maxMessageSize;
+		if (replayable === false) {
+			logger.warn("The incoming activity {activityId} uses a JSON-LD context that cannot be kept for the queue; processing it immediately instead.", {
+				activityId: activity.id?.href,
+				recipient
+			});
+			message = void 0;
+		} else if (maxMessageSize != null && estimateQueuedMessageSize(message) > maxMessageSize - QUEUED_MESSAGE_HEADROOM) {
+			logger.warn("The incoming activity {activityId} is too large to enqueue; processing it immediately instead.", {
+				activityId: activity.id?.href,
+				recipient,
+				maxMessageSize
+			});
+			message = void 0;
+		}
+	}
+	if (queue != null && message != null) {
+		try {
+			await queue.enqueue(message);
+		} catch (error) {
+			logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: `Failed to enqueue the incoming activity ${activity.id?.href}.`
+			});
+			throw error;
+		}
+		getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
+			role: "inbox",
+			queue,
+			activityType: getTypeId(activity).href
+		}, 0);
+		recordInboxActivity(meterProvider, "queued", getTypeId(activity).href);
+		logger.info("Activity {activityId} is enqueued.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		return "enqueued";
+	}
+	tracerProvider = tracerProvider ?? trace.getTracerProvider();
+	return await tracerProvider.getTracer(name, version).startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
+		const dispatched = inboxListeners?.dispatchWithClass(activity);
+		if (dispatched == null) {
+			logger.error("Unsupported activity type:\n{activity}", {
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.UNSET,
+				message: `Unsupported activity type: ${getTypeId(activity).href}`
+			});
+			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
+			span.end();
+			return "unsupportedActivity";
+		}
+		const { class: cls, listener } = dispatched;
+		span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+		try {
+			const activityType = getTypeId(activity).href;
+			const started = performance.now();
+			try {
+				const contextFactory = listenerInboxContextFactory ?? inboxContextFactory;
+				await listener(contextFactory(recipient, contextFactory === inboxContextFactory ? json : originalJson ?? json, activity.id?.href, activityType, contextMetadata), activity);
+			} finally {
+				getFederationMetrics(meterProvider).recordInboxProcessingDuration(activityType, getDurationMs(started));
+			}
+		} catch (error) {
+			try {
+				await inboxErrorHandler?.(ctx, error);
+			} catch (error) {
+				logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+					error,
+					activityId: activity.id?.href,
+					activity: json,
+					recipient
+				});
+			}
+			logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
+			span.end();
+			return "error";
+		}
+		recordInboxActivity(meterProvider, "processed", getTypeId(activity).href);
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
+		logger.info("Activity {activityId} has been processed.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		span.end();
+		return "success";
+	});
+}
+//#endregion
+export { isActorlessActivityAuthenticated as a, getInboxIdempotencyKey as i, checkActorlessActivity as n, isInboxActivityProcessed as o, estimateQueuedMessageSize as r, routeActivity as s, actorsHaveSameOrigin as t };

package/dist/{kv-cache-D_m3A241.mjs → kv-cache-CTQSfkmp.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { p as recordDocumentCache } from "./metrics-D3LHk6Z4.mjs";
+import { p as recordDocumentCache } from "./metrics-B-QxRSSR.mjs";
 import { getLogger } from "@logtape/logtape";
 import { preloadedContexts } from "@fedify/vocab-runtime";
 //#region src/utils/kv-cache.ts

package/dist/{kv-cache-kkBB0vbI.cjs → kv-cache-CjgCOz3i.cjs}

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_http = require("./http-BfW3wyQ4.cjs");
+const require_http = require("./http-CAl7Num5.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 let es_toolkit = require("es-toolkit");

package/dist/{kv-cache-7015lbrx.js → kv-cache-U7uz5nx4.js}

@@ -1,6 +1,6 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { ct as recordDocumentCache, q as validateCryptoKey, t as doubleKnock } from "./http-DlNxxW_5.js";
+import { X as validateCryptoKey, dt as recordDocumentCache, t as doubleKnock } from "./http-BBr-VLil.js";
 import { getLogger } from "@logtape/logtape";
 import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, preloadedContexts, resolveDocumentLoaderTimeout, validatePublicUrl, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
 import { curry } from "es-toolkit";

package/dist/{ld-CD2CsPxq.mjs → ld-CQFuiah9.mjs}

@@ -3,8 +3,8 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { c as isPortableActorDocument, d as isPortableUri, l as isPortableId, m as parseKeyIdString, s as isCompatibleKeyId } from "./portable-key-id-Ca30-hOa.mjs";
 import { a as verificationObservation, i as triedKey, n as observeCheck, t as observeAttempt } from "./verification-Dpfcw8ml.mjs";
-import { n as version, t as name } from "./deno-eNpfj4oR.mjs";
-import { _ as recordKeyLookup, n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch, t as classifyFetchError } from "./metrics-D3LHk6Z4.mjs";
+import { n as version, t as name } from "./deno-Dpewt_jJ.mjs";
+import { _ as recordKeyLookup, n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch, t as classifyFetchError } from "./metrics-B-QxRSSR.mjs";
 import { n as attachKeyOwnerEvidence, t as MAX_PORTABLE_KEY_TTL } from "./key-owner-evidence-APB6NpSk.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Activity, CryptographicKey, Multikey, Object as Object$1, getTypeId, isActor } from "@fedify/vocab";
@@ -200,6 +200,7 @@ async function fetchActorDocumentInternal(actorId, options, propagateContextFetc
 			actorId: actorId.href,
 			error
 		});
+		if (propagateContextFetchErrors) throw new KeyContextFetchError(error);
 		return null;
 	}
 	let object;
@@ -1146,8 +1147,26 @@ function createMemoizedDocumentLoader(documentLoader) {
 		return cloneRemoteDocument(await remoteDocument);
 	};
 }
+const effectiveContextLoaderPolicies = /* @__PURE__ */ new WeakMap();
+/**
+* Marks a context loader as the *effective* loader of a policy, i.e., one
+* that already applies what {@link wrapContextLoaderForJsonLd} (`"standard"`)
+* or {@link getNormalizationContextLoader} (`"normalization"`) would add.
+* Those functions return a marked loader as is instead of wrapping it again,
+* so that a caller can observe every response a parse actually uses,
+* including Fedify's own baseline contexts.
+* @param loader The effective context loader.
+* @param policy The policy the loader already applies.
+* @returns The given loader.
+* @internal
+*/
+function markEffectiveContextLoader(loader, policy) {
+	effectiveContextLoaderPolicies.set(loader, policy);
+	return loader;
+}
 /** @internal */
 function wrapContextLoaderForJsonLd(contextLoader) {
+	if (contextLoader != null && effectiveContextLoaderPolicies.has(contextLoader)) return contextLoader;
 	const loader = contextLoader ?? builtInContextLoader;
 	return async (url, options) => {
 		try {
@@ -1161,6 +1180,7 @@ function wrapContextLoaderForJsonLd(contextLoader) {
 }
 /** @internal */
 function getNormalizationContextLoader(contextLoader) {
+	if (contextLoader != null && effectiveContextLoaderPolicies.get(contextLoader) === "normalization") return contextLoader;
 	const loader = wrapContextLoaderForJsonLd(contextLoader);
 	return createMemoizedDocumentLoader(async (url, options) => {
 		if (URL.canParse(url)) {
@@ -1613,10 +1633,21 @@ function getLdSignatureObject(jsonLd) {
 * @returns `true` if the document is authentic; `false` otherwise.
 */
 async function verifyJsonLd(jsonLd, options = {}) {
-	return await verifyJsonLdInternal(jsonLd, options, true);
+	return (await verifyJsonLdInternal(jsonLd, options, true)).verified;
 }
 /** @internal */
 async function verifyCompactJsonLd(jsonLd, options = {}) {
+	return (await verifyJsonLdInternal(jsonLd, options, false)).verified;
+}
+/**
+* Same as {@link verifyCompactJsonLd}, but also returns the key that verified
+* the signature, whose `owner` {@link fetchKey} has confirmed.
+* @param jsonLd The compacted JSON-LD document to verify.
+* @param options Options for verifying the JSON-LD document.
+* @returns The result.
+* @internal
+*/
+async function verifyCompactJsonLdDetailed(jsonLd, options = {}) {
 	return await verifyJsonLdInternal(jsonLd, options, false);
 }
 async function verifyJsonLdInternal(jsonLd, options, compact) {
@@ -1626,7 +1657,7 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 	}, "linkedData", (observation) => verifyJsonLdInternal(jsonLd, {
 		...options,
 		[verificationObservation]: observation
-	}, compact), (value) => value);
+	}, compact), (value) => value.verified);
 	const observation = options[verificationObservation];
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.verify", async (span) => {
 		const start = performance.now();
@@ -1658,12 +1689,18 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 			const key = await verifySignature(compacted, verificationOptions);
 			if (key == null) {
 				if (observation?.attempt != null && !hasLdSignatureProperty(jsonLd)) observation.attempt.reason = { type: "noSignature" };
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			if (key.ownerId == null) {
 				if (observation?.attempt != null) observation.attempt.reason = { type: "missingOwner" };
 				logger.debug("Key {keyId} has no owner.", { keyId: key.id?.href });
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			attributions.delete(key.ownerId.href);
 			if (attributions.size > 0) {
@@ -1672,10 +1709,16 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 					attributionIds: [...attributions].map((id) => new URL(id))
 				};
 				logger.debug("Some attributions are not authenticated by the Linked Data Signatures: {attributions}.", { attributions: [...attributions] });
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			verified = true;
-			return true;
+			return {
+				verified: true,
+				key
+			};
 		} catch (error) {
 			threw = true;
 			span.setStatus({
@@ -1706,4 +1749,4 @@ async function hashJsonLd(jsonLd, contextLoader) {
 	return encodeHex(await crypto.subtle.digest("SHA-256", encoder.encode(canon)));
 }
 //#endregion
-export { generateCryptoKeyPair as C, verifyKeyOwnership as E, fetchKeyDetailed as S, validateCryptoKey as T, wrapContextLoaderForJsonLd as _, compactJsonLd as a, fetchActorDocument as b, getNormalizationContextLoader as c, isClearlyMalformedContextReference as d, isInvalidUrlTypeError as f, verifySignature as g, verifyJsonLd as h, attachSignature as i, hasSignature as l, verifyCompactJsonLd as m, UnsafeJsonLdError as n, createSignature as o, signJsonLd as p, assertSafeJsonLd as r, detachSignature as s, InvalidContextReferenceError as t, hasSignatureLike as u, bypassKeyCacheReads as v, importJwk as w, fetchKey as x, exportJwk as y };
+export { fetchKey as C, validateCryptoKey as D, importJwk as E, verifyKeyOwnership as O, fetchActorDocument as S, generateCryptoKeyPair as T, verifyJsonLd as _, compactJsonLd as a, bypassKeyCacheReads as b, getNormalizationContextLoader as c, isClearlyMalformedContextReference as d, isInvalidUrlTypeError as f, verifyCompactJsonLdDetailed as g, verifyCompactJsonLd as h, attachSignature as i, hasSignature as l, signJsonLd as m, UnsafeJsonLdError as n, createSignature as o, markEffectiveContextLoader as p, assertSafeJsonLd as r, detachSignature as s, InvalidContextReferenceError as t, hasSignatureLike as u, verifySignature as v, fetchKeyDetailed as w, exportJwk as x, wrapContextLoaderForJsonLd as y };