@fedify/interaction-controls 2.5.0-dev.2339 → 2.5.0-dev.2355

package/dist/mod.cjs

@@ -30,7 +30,7 @@ function createInteractionControl(config) {
 		createRevocation: (options) => new _fedify_vocab.Delete({
 			id: options.id,
 			actor: options.actor,
-			object: getRequiredId(options.authorization, "authorization"),
+			object: options.embedAuthorization && !(options.authorization instanceof URL) ? createEmbeddedAuthorization(options.authorization, config) : getRequiredId(options.authorization, "authorization"),
 			...audience(options)
 		}),
 		recognizeImpolite: config.recognizeImpolite,
@@ -59,6 +59,17 @@ function getRequiredId(value, name) {
 	if (value.id == null) throw new TypeError(`The ${name} must have an id.`);
 	return value.id;
 }
+function createEmbeddedAuthorization(authorization, config) {
+	const { interactingObjectId, interactionTargetId } = authorization;
+	if (interactingObjectId == null) throw new TypeError("The authorization's interactingObject must have an id.");
+	if (interactionTargetId == null) throw new TypeError("The authorization's interactionTarget must have an id.");
+	return new config.authorizationClass({
+		id: getRequiredId(authorization, "authorization"),
+		attributions: authorization.attributionIds,
+		interactingObject: interactingObjectId,
+		interactionTarget: interactionTargetId
+	});
+}
 function getId(value) {
 	return value instanceof URL ? value : value.id;
 }
@@ -70,8 +81,9 @@ function getTypeId(object) {
 }
 async function verifyRequest(context, options, config) {
 	const documentLoader = options.documentLoader ?? context.documentLoader;
+	const contextLoader = options.contextLoader ?? documentLoader;
 	const expectedRequestId = options.request instanceof URL ? options.request : null;
-	const requestResult = await materialize(options.request, config.requestClass, documentLoader);
+	const requestResult = await materialize(options.request, config.requestClass, documentLoader, contextLoader);
 	if (!requestResult.ok) return {
 		verified: false,
 		failure: requestResult.failure
@@ -107,12 +119,17 @@ async function verifyRequest(context, options, config) {
 			actual: request.id
 		}
 	};
-	const dereferenceOptions = {
-		documentLoader,
-		contextLoader: documentLoader,
-		suppressError: true
+	const targetResult = options.resolvedInteractionTarget != null && request.objectId != null ? {
+		ok: true,
+		value: options.resolvedInteractionTarget
+	} : await dereferenceField(request, request.objectId, config.getInteractionTarget, documentLoader, contextLoader);
+	if (!targetResult.ok) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: targetResult.failure
 	};
-	const interactionTarget = await config.getInteractionTarget(request, dereferenceOptions);
+	const interactionTarget = targetResult.value;
 	if (interactionTarget == null) return {
 		verified: false,
 		request,
@@ -133,7 +150,17 @@ async function verifyRequest(context, options, config) {
 			actualTypes: [getTypeId(interactionTarget)]
 		}
 	};
-	const interactingObject = await config.getInteractingObject(request, dereferenceOptions);
+	const interactingResult = options.resolvedInteractingObject != null && request.instrumentId != null ? {
+		ok: true,
+		value: options.resolvedInteractingObject
+	} : await dereferenceField(request, request.instrumentId, config.getInteractingObject, documentLoader, contextLoader);
+	if (!interactingResult.ok) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: interactingResult.failure
+	};
+	const interactingObject = interactingResult.value;
 	if (interactingObject == null) return {
 		verified: false,
 		request,
@@ -184,7 +211,7 @@ async function verifyRequest(context, options, config) {
 			type: "missingObjectId"
 		}
 	};
-	const validation = config.validateRequest(request, interactingObject, interactionTarget, requester);
+	const validation = config.validateRequest(request, interactingObject, interactionTarget, requester, options);
 	if (validation != null) return {
 		verified: false,
 		request,
@@ -213,23 +240,35 @@ async function verifyRequest(context, options, config) {
 	};
 }
 async function verifyAuthorization(context, options, config) {
-	const embeddedAuthorization = !(options.authorization instanceof URL);
-	const expectedAuthorizationId = options.authorization instanceof URL ? options.authorization : null;
+	const authorizationUrl = options.authorization instanceof URL ? options.authorization : null;
+	const embeddedAuthorization = authorizationUrl == null;
+	const expectedAuthorizationId = options.authorizationId ?? authorizationUrl;
+	const checkOrigin = !options.allowOffOrigin || options.verifyAuthenticity == null;
 	const expectedAttribution = options.attributedTo ?? (!(options.interactionTarget instanceof URL) ? config.getSelfActor(options.interactionTarget) : null);
-	if (expectedAuthorizationId != null && expectedAttribution == null) return {
+	if (authorizationUrl != null && options.authorizationId != null && !idsEqual(authorizationUrl, options.authorizationId)) return {
+		verified: false,
+		authorizationId: authorizationUrl,
+		failure: {
+			category: "unauthorized",
+			type: "idMismatch",
+			expected: options.authorizationId,
+			actual: authorizationUrl
+		}
+	};
+	if (authorizationUrl != null && expectedAttribution == null) return {
 		verified: false,
-		authorizationId: expectedAuthorizationId,
+		authorizationId: authorizationUrl,
 		failure: {
 			category: "unauthorized",
 			type: "missingAttribution"
 		}
 	};
-	if (expectedAuthorizationId != null && expectedAttribution != null) {
+	if (checkOrigin && authorizationUrl != null && expectedAttribution != null) {
 		const expectedOrigin = getAuthorizationOrigin(expectedAttribution);
-		const actualOrigin = getAuthorizationOrigin(expectedAuthorizationId);
+		const actualOrigin = getAuthorizationOrigin(authorizationUrl);
 		if (expectedOrigin === "null" || actualOrigin === "null" || expectedOrigin !== actualOrigin) return {
 			verified: false,
-			authorizationId: expectedAuthorizationId,
+			authorizationId: authorizationUrl,
 			failure: {
 				category: "unauthorized",
 				type: "originMismatch",
@@ -238,7 +277,8 @@ async function verifyAuthorization(context, options, config) {
 			}
 		};
 	}
-	const authorizationResult = await materialize(options.authorization, config.authorizationClass, options.documentLoader ?? context.documentLoader);
+	const documentLoader = options.documentLoader ?? context.documentLoader;
+	const authorizationResult = await materialize(options.authorization, config.authorizationClass, documentLoader, options.contextLoader ?? documentLoader);
 	if (!authorizationResult.ok) return {
 		verified: false,
 		failure: authorizationResult.failure
@@ -362,7 +402,7 @@ async function verifyAuthorization(context, options, config) {
 	};
 	const expectedOrigin = getAuthorizationOrigin(expectedAttribution);
 	const actualOrigin = getAuthorizationOrigin(authorization.id);
-	if (expectedOrigin === "null" || actualOrigin === "null" || expectedOrigin !== actualOrigin) return {
+	if (checkOrigin && (expectedOrigin === "null" || actualOrigin === "null" || expectedOrigin !== actualOrigin)) return {
 		verified: false,
 		authorization,
 		authorizationId: authorization.id,
@@ -415,60 +455,163 @@ async function verifyAuthorization(context, options, config) {
 		authorizationId: authorization.id
 	};
 }
-async function materialize(value, constructor, documentLoader) {
-	if (!(value instanceof URL)) return {
-		ok: true,
-		object: value
+/**
+* Wraps the loaders for a single dereferencing operation so that errors they
+* throw can be told apart from other errors afterwards.  Parsed objects keep
+* the loaders they were given, so the wrappers stop recording and pass calls
+* through once the operation is released.
+*/
+function trackLoaders(documentLoader, contextLoader) {
+	const records = /* @__PURE__ */ new Map();
+	let released = false;
+	const wrap = (loader) => {
+		if (loader == null) return void 0;
+		return async (url, options) => {
+			if (released) return await loader(url, options);
+			let remoteDocument;
+			try {
+				remoteDocument = await loader(url, options);
+			} catch (error) {
+				if (!released) records.set(error, url);
+				throw error;
+			}
+			if (remoteDocument == null) {
+				const message = "The document loader returned no document.";
+				let error;
+				try {
+					error = new _fedify_vocab_runtime.FetchError((0, _fedify_vocab_runtime.parseIri)(url), message);
+				} catch {
+					error = /* @__PURE__ */ new Error(`${url}: ${message}`);
+				}
+				if (!released) records.set(error, url);
+				throw error;
+			}
+			return remoteDocument;
+		};
 	};
-	const loader = documentLoader;
-	if (loader == null) return {
-		ok: false,
-		failure: {
-			category: "unverifiable",
-			type: "notDereferenceable",
-			url: value
+	const wrappedDocumentLoader = wrap(documentLoader);
+	return {
+		documentLoader: wrappedDocumentLoader,
+		contextLoader: contextLoader === documentLoader ? wrappedDocumentLoader : wrap(contextLoader),
+		records,
+		release: () => {
+			released = true;
+			records.clear();
+		}
+	};
+}
+const MAX_CAUSE_DEPTH = 8;
+function collectCauses(error, causes = [], depth = 0) {
+	if (depth > MAX_CAUSE_DEPTH || causes.includes(error)) return causes;
+	causes.push(error);
+	if (typeof error !== "object" || error == null) return causes;
+	if (error instanceof AggregateError) for (const e of error.errors) collectCauses(e, causes, depth + 1);
+	if ("cause" in error) collectCauses(error.cause, causes, depth + 1);
+	const details = error.details;
+	if (typeof details === "object" && details != null && "cause" in details) collectCauses(details.cause, causes, depth + 1);
+	return causes;
+}
+/**
+* Classifies the error thrown by a dereferencing operation.  It is a fetch
+* failure only if a loader error is among its causes; errors that loaders
+* threw during attempts the operation recovered from are ignored.
+*/
+function classifyFailure(error, tracker) {
+	const loaderErrors = collectCauses(error).filter((e) => tracker.records.has(e));
+	const transientIndex = loaderErrors.findIndex(_fedify_vocab_runtime.isTransientFetchError);
+	const selected = loaderErrors[transientIndex < 0 ? 0 : transientIndex];
+	const url = loaderErrors.length < 1 ? null : getFailedUrl(selected, tracker.records.get(selected));
+	if (url == null) return {
+		category: "unverifiable",
+		type: "invalidJsonLd",
+		cause: error,
+		transient: false
+	};
+	return {
+		category: "unverifiable",
+		type: "notDereferenceable",
+		url,
+		cause: loaderErrors.length === 1 ? selected : error,
+		transient: transientIndex >= 0
+	};
+}
+function getFailedUrl(error, requestedUrl) {
+	const url = error?.url;
+	if (url instanceof URL) return url;
+	for (const candidate of [url, requestedUrl]) {
+		if (typeof candidate !== "string") continue;
+		try {
+			return (0, _fedify_vocab_runtime.parseIri)(candidate);
+		} catch {
+			continue;
 		}
+	}
+	return null;
+}
+function notDereferenceable(url) {
+	return {
+		category: "unverifiable",
+		type: "notDereferenceable",
+		url,
+		transient: false
 	};
-	let remoteDocument;
+}
+/**
+* Dereferences a field of the request, such as its `object` or `instrument`.
+* Returns `null` if the request has no such field at all.
+*/
+async function dereferenceField(request, reference, dereference, documentLoader, contextLoader) {
+	const tracker = trackLoaders(documentLoader, contextLoader);
 	try {
-		remoteDocument = await loader(value.href);
-	} catch (cause) {
+		const value = await dereference(request, {
+			documentLoader: tracker.documentLoader,
+			contextLoader: tracker.contextLoader,
+			suppressError: false
+		});
+		if (value != null || reference == null) return {
+			ok: true,
+			value
+		};
 		return {
 			ok: false,
-			failure: {
-				category: "unverifiable",
-				type: "notDereferenceable",
-				url: value,
-				cause
-			}
+			failure: notDereferenceable(reference)
 		};
+	} catch (error) {
+		return {
+			ok: false,
+			failure: classifyFailure(error, tracker)
+		};
+	} finally {
+		tracker.release();
 	}
-	if (remoteDocument == null) return {
+}
+async function materialize(value, constructor, documentLoader, contextLoader) {
+	if (!(value instanceof URL)) return {
+		ok: true,
+		object: value
+	};
+	if (documentLoader == null) return {
 		ok: false,
-		failure: {
-			category: "unverifiable",
-			type: "notDereferenceable",
-			url: value
-		}
+		failure: notDereferenceable(value)
 	};
+	const tracker = trackLoaders(documentLoader, contextLoader);
 	try {
+		const remoteDocument = await tracker.documentLoader(value.href);
 		return {
 			ok: true,
 			object: await constructor.fromJsonLd(remoteDocument.document, {
-				documentLoader: loader,
-				contextLoader: loader,
+				documentLoader: tracker.documentLoader,
+				contextLoader: tracker.contextLoader,
 				baseUrl: value
 			})
 		};
-	} catch (cause) {
+	} catch (error) {
 		return {
 			ok: false,
-			failure: {
-				category: "unverifiable",
-				type: "invalidJsonLd",
-				cause
-			}
+			failure: classifyFailure(error, tracker)
 		};
+	} finally {
+		tracker.release();
 	}
 }
 async function evaluatePolicy(context, options, config) {
@@ -485,30 +628,60 @@ async function evaluatePolicy(context, options, config) {
 		reason: implicitAutomatic
 	};
 	const policy = options.subject.interactionPolicy;
-	if (policy == null) return missingPolicyDecision(config);
-	const rule = policy[config.policyProperty];
-	if (rule == null) return missingRuleDecision(config);
-	const automaticApprovals = rule.automaticApprovals ?? [];
-	const manualApprovals = rule.manualApprovals ?? [];
-	if (automaticApprovals.length < 1 && manualApprovals.length < 1) return missingRuleDecision(config);
-	const automatic = await matchRule(automaticApprovals, options.requester, context, options.matchesApprovalCollection, { actorOnly: true });
+	let rule = getApprovalRule(policy?.[config.policyProperty]);
+	if (rule == null) {
+		rule = getApprovalRule(options.fallbackRule);
+		if (rule == null) return policy == null ? missingPolicyDecision(config) : missingRuleDecision(config);
+	}
+	const { automaticApprovals, manualApprovals } = rule;
+	const matchOptions = {
+		requester: options.requester,
+		context,
+		matchesApprovalCollection: options.matchesApprovalCollection,
+		throwCollectionErrors: options.collectionErrors === "throw"
+	};
+	if (options.precedence === "automatic") {
+		const automatic = await matchRule(automaticApprovals, matchOptions);
+		if (automatic?.result === "matched") return {
+			result: "automatic",
+			reason: automatic.reason
+		};
+		else if (automatic?.result === "unverifiableCollection") return deniedUnverifiableCollection(automatic);
+		const manual = await matchRule(manualApprovals, matchOptions);
+		if (manual?.result === "matched") return {
+			result: "manual",
+			reason: manual.reason
+		};
+		else if (manual?.result === "unverifiableCollection") return deniedUnverifiableCollection(manual);
+		return {
+			result: "denied",
+			reason: { type: "noMatch" }
+		};
+	}
+	const automatic = await matchRule(automaticApprovals, {
+		...matchOptions,
+		actorOnly: true
+	});
 	if (automatic?.result === "matched") return {
 		result: "automatic",
 		reason: automatic.reason
 	};
-	const manual = await matchRule(manualApprovals, options.requester, context, options.matchesApprovalCollection, { actorOnly: true });
+	const manual = await matchRule(manualApprovals, {
+		...matchOptions,
+		actorOnly: true
+	});
 	if (manual?.result === "matched") return {
 		result: "manual",
 		reason: manual.reason
 	};
-	const broadAutomatic = await matchRule(automaticApprovals, options.requester, context, options.matchesApprovalCollection);
-	const unverifiableAutomatic = broadAutomatic?.result === "unverifiableCollection" ? broadAutomatic.collection : null;
+	const broadAutomatic = await matchRule(automaticApprovals, matchOptions);
+	const unverifiableAutomatic = broadAutomatic?.result === "unverifiableCollection" ? broadAutomatic : null;
 	if (broadAutomatic?.result === "matched") return {
 		result: "automatic",
 		reason: broadAutomatic.reason
 	};
-	const broadManual = await matchRule(manualApprovals, options.requester, context, options.matchesApprovalCollection);
-	if (broadManual?.result === "unverifiableCollection") return deniedUnverifiableCollection(broadManual.collection);
+	const broadManual = await matchRule(manualApprovals, matchOptions);
+	if (broadManual?.result === "unverifiableCollection") return deniedUnverifiableCollection(broadManual);
 	else if (broadManual?.result === "matched") return {
 		result: "manual",
 		reason: broadManual.reason
@@ -519,6 +692,16 @@ async function evaluatePolicy(context, options, config) {
 		reason: { type: "noMatch" }
 	};
 }
+function getApprovalRule(rule) {
+	if (rule == null) return null;
+	const automaticApprovals = rule.automaticApprovals ?? [];
+	const manualApprovals = rule.manualApprovals ?? [];
+	if (automaticApprovals.length < 1 && manualApprovals.length < 1) return null;
+	return {
+		automaticApprovals,
+		manualApprovals
+	};
+}
 async function matchImplicitAutomaticActors(subject, requester, options, config) {
 	if (config.getImplicitAutomaticActors == null) return null;
 	for await (const actor of config.getImplicitAutomaticActors(subject, options)) if (idsEqual(actor, requester)) return {
@@ -553,7 +736,8 @@ function missingRuleDecision(config) {
 		reason: { type: "missingRule" }
 	};
 }
-async function matchRule(entries, requester, context, matchesApprovalCollection, options = {}) {
+async function matchRule(entries, options) {
+	const { requester, matchesApprovalCollection } = options;
 	for (const entry of entries) if (entry.href === requester.href) return {
 		result: "matched",
 		reason: {
@@ -567,14 +751,18 @@ async function matchRule(entries, requester, context, matchesApprovalCollection,
 		reason: { type: "public" }
 	};
 	if (matchesApprovalCollection != null) {
-		let unverifiableCollection = null;
+		let unverifiable = null;
 		for (const entry of entries) {
 			if (entry.href === _fedify_vocab.PUBLIC_COLLECTION.href || entry.href === requester.href) continue;
 			let matched;
 			try {
-				matched = await matchesApprovalCollection(entry, requester, context);
-			} catch {
-				unverifiableCollection ??= entry;
+				matched = await matchesApprovalCollection(entry, requester, options.context);
+			} catch (cause) {
+				if (options.throwCollectionErrors) throw cause;
+				unverifiable ??= {
+					collection: entry,
+					cause
+				};
 				continue;
 			}
 			if (matched) return {
@@ -585,19 +773,20 @@ async function matchRule(entries, requester, context, matchesApprovalCollection,
 				}
 			};
 		}
-		if (unverifiableCollection != null) return {
+		if (unverifiable != null) return {
 			result: "unverifiableCollection",
-			collection: unverifiableCollection
+			...unverifiable
 		};
 	}
 	return null;
 }
-function deniedUnverifiableCollection(collection) {
+function deniedUnverifiableCollection(failure) {
 	return {
 		result: "denied",
 		reason: {
 			type: "unverifiableCollection",
-			collection
+			collection: failure.collection,
+			cause: failure.cause
 		}
 	};
 }
@@ -798,20 +987,23 @@ const quoteInteraction = createInteractionControl({
 		_fedify_vocab.ChatMessage.typeId
 	],
 	getInteractionTarget: (request, options) => request.getObject(options),
-	validateRequest: (_request, quote, target, requester) => {
+	validateRequest: (_request, quote, target, requester, options) => {
 		const targetId = getRequiredId(target, "interactionTarget");
-		if (quote.quoteId != null && quote.quoteUrl != null && !idsEqual(quote.quoteUrl, quote.quoteId)) return {
+		const quoteReference = options.quoteReference ?? "strict";
+		if (quoteReference === "strict" && quote.quoteId != null && quote.quoteUrl != null && !idsEqual(quote.quoteUrl, quote.quoteId)) return {
 			type: "objectMismatch",
 			expected: quote.quoteId,
 			actual: quote.quoteUrl
 		};
 		const quoteTargetId = getQuoteTargetId(quote);
-		if (!idsEqual(quoteTargetId, targetId)) return {
+		if (!(quoteReference === "any" ? idsEqual(quote.quoteId, targetId) || idsEqual(quote.quoteUrl, targetId) : idsEqual(quoteTargetId, targetId))) return {
 			type: "objectMismatch",
 			expected: targetId,
 			actual: quoteTargetId ?? void 0
 		};
-		if (!idsEqual(quote.attributionId, requester)) return {
+		const attributionIds = quote.attributionIds;
+		if (attributionIds.length < 1 && options.missingAttribution === "requester") return null;
+		if (!(options.attribution === "any" ? attributionIds.some((id) => idsEqual(id, requester)) : idsEqual(quote.attributionId, requester))) return {
 			type: "requesterMismatch",
 			expected: requester,
 			actual: quote.attributionId ?? void 0