@fedify/vocab 2.4.0-dev.2122 → 2.4.0-dev.2129

package/dist-tests/vocab.test.mjs

@@ -1,10 +1,11 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1, B as QuoteAuthorization, C as Intent, D as Measure, E as Link, F as Person, G as Tombstone, H as Reject, I as Place, L as PropertyValue, N as OrderedCollectionPage, O as Multikey, P as Organization, R as Proposal, S as Image, T as InteractionRule, U as Service, V as QuoteRequest, W as Source, X as vocab_exports, _ as FeaturedCollection, a as Application, b as Group, d as CryptographicKey, f as Delete, g as FeatureRequest, h as FeatureAuthorization, i as Announce, j as Offer, k as Note, l as Commitment, m as Endpoints, n as Activity, p as Document, r as Agreement, s as Collection, t as Accept, u as Create, v as FeaturedItem, w as InteractionPolicy, x as Hashtag, y as Follow, z as Question } from "./vocab-BHtBRusa.mjs";
+import { A as Object$1, B as QuoteAuthorization, C as Intent, D as Measure, E as Link, F as Person, G as Tombstone, H as Reject, I as Place, L as PropertyValue, N as OrderedCollectionPage, O as Multikey, P as Organization, R as Proposal, S as Image, T as InteractionRule, U as Service, V as QuoteRequest, W as Source, X as vocab_exports, _ as FeaturedCollection, a as Application, b as Group, d as CryptographicKey, f as Delete, g as FeatureRequest, h as FeatureAuthorization, i as Announce, j as Offer, k as Note, l as Commitment, m as Endpoints, n as Activity, p as Document, r as Agreement, s as Collection, t as Accept, u as Create, v as FeaturedItem, w as InteractionPolicy, x as Hashtag, y as Follow, z as Question } from "./vocab-DFtGFGsb.mjs";
+import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, notDeepStrictEqual, ok, rejects, throws } from "node:assert/strict";
-import { LanguageString, decodeMultibase, parseDecimal } from "@fedify/vocab-runtime";
+import { FetchError, LanguageString, decodeMultibase, getDocumentLoader, parseDecimal } from "@fedify/vocab-runtime";
 import { configure, reset } from "@logtape/logtape";
 import { pascalCase } from "es-toolkit";
 import { areAllScalarTypes, loadSchemaFiles } from "@fedify/vocab-tools";
@@ -1203,6 +1204,59 @@ test({
 		});
 	}
 });
+test({
+	name: "Announce.getObject() logs suppressed failures as warnings",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const records = [];
+		const notFoundUrl = "https://example.com/suppressed-not-found";
+		const invalidObjectUrl = "https://example.com/invalid-object";
+		await reset();
+		esm_default.spyGlobal();
+		try {
+			await configure({
+				sinks: { buffer(record) {
+					records.push(record);
+				} },
+				filters: {},
+				loggers: [{
+					category: [],
+					sinks: ["buffer"]
+				}]
+			});
+			esm_default.get(notFoundUrl, { status: 404 });
+			deepStrictEqual(await new Announce({ object: new URL(notFoundUrl) }).getObject({ suppressError: true }), null);
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to fetch document: {status} {url} {headers}"));
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to fetch {url}: {error}"));
+			deepStrictEqual(records.some((record) => record.level === "error" && (record.rawMessage === "Failed to fetch document: {status} {url} {headers}" || record.rawMessage === "Failed to fetch {url}: {error}")), false);
+			records.length = 0;
+			const unsuppressedFetch = new Announce({ object: new URL(notFoundUrl) });
+			await rejects(() => unsuppressedFetch.getObject(), FetchError);
+			ok(records.some((record) => record.level === "error" && record.rawMessage === "Failed to fetch document: {status} {url} {headers}"));
+			records.length = 0;
+			const invalidDocumentLoader = async (url) => ({
+				contextUrl: null,
+				documentUrl: url,
+				document: null
+			});
+			deepStrictEqual(await new Announce({ object: new URL(invalidObjectUrl) }).getObject({
+				documentLoader: invalidDocumentLoader,
+				suppressError: true
+			}), null);
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to parse {url}: {error}"));
+			deepStrictEqual(records.some((record) => record.level === "error" && record.rawMessage === "Failed to parse {url}: {error}"), false);
+			records.length = 0;
+			const unsuppressedParsing = new Announce({ object: new URL(invalidObjectUrl) });
+			await rejects(() => unsuppressedParsing.getObject({ documentLoader: invalidDocumentLoader }), TypeError);
+		} finally {
+			esm_default.hardReset();
+			await reset();
+		}
+	}
+});
 test("Activity.getObject() fetches canonical portable IRIs", async () => {
 	const fetchedUrls = [];
 	const documentLoader = async (url) => {
@@ -3636,5 +3690,309 @@ for (const typeUri in types) {
 		deepStrictEqual(cls.typeId, new URL(type.uri));
 	});
 }
+test("Announce.getObject() suppresses redirect, context, and private URL logs", async () => {
+	const records = [];
+	const objectUrl = "https://example.com/suppression-object";
+	const contextUrl = "https://example.com/suppression-context";
+	const scenarios = [
+		"redirect limit",
+		"redirect loop",
+		"context",
+		"private",
+		"private redirect"
+	];
+	await reset();
+	await configure({
+		sinks: { capture: (record) => {
+			records.push(record);
+		} },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const scenario of scenarios) {
+			esm_default.spyGlobal();
+			let fetches = 0;
+			esm_default.get("begin:https://example.com/", (call) => {
+				fetches++;
+				if (scenario === "redirect limit") return Response.redirect(`https://example.com/redirect-${fetches}`, 302);
+				if (scenario === "redirect loop") return Response.redirect(objectUrl, 302);
+				if (scenario === "private redirect") return Response.redirect("http://127.0.0.1/private", 302);
+				if (call.url === contextUrl) return new Response(null, { status: 404 });
+				return new Response(JSON.stringify({
+					"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+					id: objectUrl,
+					type: "Note"
+				}), { headers: { "Content-Type": "application/activity+json" } });
+			});
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					fetches = 0;
+					const announce = new Announce({ object: new URL(scenario === "private" ? "http://127.0.0.1/private" : objectUrl) });
+					if (suppressError) {
+						deepStrictEqual(await announce.getObject({ suppressError }), null);
+						deepStrictEqual(records.filter((r) => r.level === "error"), [], scenario);
+						ok(records.some((r) => r.level === "warning"), scenario);
+					} else {
+						await rejects(() => announce.getObject({ suppressError }));
+						ok(records.some((r) => r.level === "error"), scenario);
+					}
+					if (scenario === "private") deepStrictEqual(fetches, 0);
+					if (scenario === "private redirect") deepStrictEqual(fetches, 1);
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
+test("suppressed context loading does not persist on fetched objects", async () => {
+	const states = [];
+	const contextLoader = (url, options) => {
+		if (url === "https://www.w3.org/ns/activitystreams") return mockDocumentLoader(url);
+		states.push(options?.suppressError);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": {
+				as: "https://www.w3.org/ns/activitystreams#",
+				name: "as:name"
+			} }
+		});
+	};
+	const documentLoader = (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: {
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://example.com/scoped-context"],
+			id: url,
+			type: url.endsWith("actor") ? "Person" : "Note",
+			attributedTo: "https://example.com/scoped-actor"
+		}
+	});
+	const note = await new Announce({ object: new URL("https://example.com/scoped-note") }).getObject({
+		documentLoader,
+		contextLoader,
+		suppressError: true
+	});
+	assertInstanceOf(note, Note);
+	ok(states.includes(true));
+	states.length = 0;
+	assertInstanceOf(await note.getAttribution(), Person);
+	ok(states.length > 0);
+	deepStrictEqual(states.includes(true), false);
+});
+test("attribution chains alternate ordinary and portable suppression", async () => {
+	const states = [];
+	const depths = [];
+	let hop = 0;
+	const contextUrl = "https://example.com/attribution-context";
+	const contextLoader = (url, options) => {
+		if (url !== contextUrl) return mockDocumentLoader(url, options);
+		states.push(options?.suppressError);
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		ok(stack);
+		depths[hop]?.push(stack.split("\n").length);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": { name: "https://www.w3.org/ns/activitystreams#name" } }
+		});
+	};
+	const documentLoader = (url) => {
+		const hop = Number(new URL(url).pathname.split("/").at(-1));
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: {
+				"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+				id: url,
+				type: "Person",
+				name: `Actor ${hop}`,
+				attributedTo: `https://example.com/actors/${hop + 1}`
+			}
+		});
+	};
+	let person = new Person({
+		id: new URL("https://example.com/actors/root"),
+		attribution: new URL("https://example.com/actors/0")
+	}, {
+		documentLoader,
+		contextLoader
+	});
+	const stackTraceLimit = globalThis.Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	try {
+		ok(Reflect.set(Error, "stackTraceLimit", Infinity));
+		for (; hop < 100; hop++) {
+			depths[hop] = [];
+			const next = await person.getAttribution({
+				suppressError: true,
+				...hop % 2 === 0 ? {} : { verifyPortableObject: () => Promise.resolve({ verified: true }) }
+			});
+			assertInstanceOf(next, Person);
+			deepStrictEqual(next.id, new URL(`https://example.com/actors/${hop}`));
+			person = next;
+		}
+		ok(depths.every((values) => values.length > 0));
+		deepStrictEqual(depths[98], depths[2]);
+		deepStrictEqual(depths[99], depths[3]);
+		ok(states.length >= 100);
+		ok(states.every((state) => state === true));
+		states.length = 0;
+		assertInstanceOf(await person.getAttribution(), Person);
+		ok(states.length > 0);
+		ok(states.every((state) => state !== true));
+	} finally {
+		if (stackTraceLimit == null) Reflect.deleteProperty(Error, "stackTraceLimit");
+		else globalThis.Object.defineProperty(Error, "stackTraceLimit", stackTraceLimit);
+	}
+});
+test("portable accessors suppress document and context failure logs", async () => {
+	const records = [];
+	const id = new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/1");
+	const contextUrl = "https://example.com/portable-suppression-context";
+	await reset();
+	await configure({
+		sinks: { capture: (record) => {
+			records.push(record);
+		} },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const failContext of [false, true]) {
+			esm_default.spyGlobal();
+			esm_default.get("begin:https://example.com/", (call) => {
+				if (!failContext || call.url === contextUrl) return new Response(null, { status: 404 });
+				return new Response(JSON.stringify({
+					"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+					id: "ap://did:key:z6Mkabc/objects/1",
+					type: "Note"
+				}), { headers: { "Content-Type": "application/activity+json" } });
+			});
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					const announce = new Announce({ object: id });
+					const options = {
+						suppressError,
+						gateways: ["https://example.com/"],
+						verifyPortableObject: () => Promise.resolve({ verified: true })
+					};
+					if (suppressError) {
+						deepStrictEqual(await announce.getObject(options), null);
+						deepStrictEqual(records.filter((r) => r.level === "error"), []);
+						ok(records.some((r) => r.level === "warning"));
+					} else {
+						await rejects(() => announce.getObject(options));
+						ok(records.some((r) => r.level === "error"));
+					}
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
+test("portable verifiers suppress document logs only during dereferencing", async () => {
+	const records = [];
+	const id = new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/1");
+	const verificationUrl = "https://example.com/verification-document";
+	const missingUrl = "https://example.com/missing-verification-document";
+	const signal = new AbortController().signal;
+	await reset();
+	await configure({
+		sinks: { capture: (record) => records.push(record) },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const failVerification of [false, true]) {
+			esm_default.spyGlobal();
+			esm_default.get("begin:https://example.com/.well-known/", {
+				headers: { "Content-Type": "application/activity+json" },
+				body: {
+					"@context": "https://www.w3.org/ns/activitystreams",
+					id: "ap://did:key:z6Mkabc/objects/1",
+					type: "Note"
+				}
+			});
+			esm_default.get(verificationUrl, {
+				status: failVerification ? 404 : 200,
+				headers: { "Content-Type": "application/ld+json" },
+				body: {}
+			});
+			esm_default.get(missingUrl, { status: 404 });
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					const baseLoader = getDocumentLoader();
+					const calls = [];
+					const documentLoader = (url, options) => {
+						calls.push(options);
+						return baseLoader(url, options);
+					};
+					let retainedLoader;
+					const loaderOptions = { signal };
+					const object = await new Announce({ object: id }).getObject({
+						suppressError,
+						documentLoader,
+						gateways: ["https://example.com/"],
+						verifyPortableObject: async (_document, options) => {
+							retainedLoader = options.documentLoader;
+							ok(options.documentLoader);
+							await options.documentLoader(verificationUrl, loaderOptions);
+							return { verified: true };
+						}
+					});
+					if (failVerification) {
+						deepStrictEqual(object, null);
+						deepStrictEqual(records.some((record) => record.level === "error"), !suppressError);
+						ok(records.some((record) => record.level === "warning"));
+					} else assertInstanceOf(object, Note);
+					deepStrictEqual(calls.at(-1)?.signal, signal);
+					deepStrictEqual(calls.at(-1)?.suppressError, suppressError ? true : void 0);
+					deepStrictEqual(loaderOptions, { signal });
+					records.length = 0;
+					const releasedLoader = retainedLoader;
+					ok(releasedLoader);
+					await rejects(() => releasedLoader(missingUrl, loaderOptions), FetchError);
+					deepStrictEqual(calls.at(-1), loaderOptions);
+					ok(records.some((record) => record.level === "error"));
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab",
-  "version": "2.4.0-dev.2122+bdc0ce8d",
+  "version": "2.4.0-dev.2129+c0ddb433",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",
@@ -43,9 +43,9 @@
     "jsonld": "^9.0.0",
     "pkijs": "^3.3.3",
     "temporal-polyfill": "^1.0.1",
-    "@fedify/vocab-tools": "2.4.0-dev.2122+bdc0ce8d",
-    "@fedify/webfinger": "2.4.0-dev.2122+bdc0ce8d",
-    "@fedify/vocab-runtime": "2.4.0-dev.2122+bdc0ce8d"
+    "@fedify/vocab-runtime": "2.4.0-dev.2129+c0ddb433",
+    "@fedify/webfinger": "2.4.0-dev.2129+c0ddb433",
+    "@fedify/vocab-tools": "2.4.0-dev.2129+c0ddb433"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",