@fedify/fedify 2.5.0-dev.2597 → 2.5.0-dev.2614

package/dist/federation/outbound-dispatch.test.mjs

@@ -0,0 +1,368 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { i as rsaPrivateKey2, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { o as createFederation, t as ContextImpl } from "../middleware-BkRqMGPU.mjs";
+import { configure, getLogger, reset, withContext } from "@logtape/logtape";
+import { Create, Person } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/federation/outbound-dispatch.test.ts
+const activity = new Create({
+	id: new URL("https://example.com/dispatch"),
+	actor: new URL("https://example.com/person2")
+});
+const target = new Person({
+	id: new URL("https://remote.example/bob"),
+	inbox: new URL("https://remote.example/inbox")
+});
+const sender = {
+	keyId: rsaPublicKey2.id,
+	privateKey: rsaPrivateKey2
+};
+const loaders = {
+	documentLoaderFactory: () => mockDocumentLoader,
+	contextLoaderFactory: () => mockDocumentLoader
+};
+const modes = [
+	"send",
+	"outbox-send",
+	"inbox-forward",
+	"outbox-forward"
+];
+function entry(federation, mode, identity = sender) {
+	const base = federation.createContext(new URL("https://example.com"), void 0);
+	ok(base instanceof ContextImpl);
+	const outbox = base.toOutboxContext("alice", {}, activity.id.href, Create.typeId.href);
+	const inbox = base.toInboxContext(null, {}, activity.id.href, Create.typeId.href);
+	if (mode === "send") return {
+		context: base,
+		invoke: (options) => base.sendActivity(identity, target, activity, Object.assign(options, { fanout: "force" }))
+	};
+	if (mode === "outbox-send") return {
+		context: outbox,
+		invoke: (options) => outbox.sendActivity(identity, target, activity, Object.assign(options, { fanout: "skip" }))
+	};
+	const context = mode === "inbox-forward" ? inbox : outbox;
+	return {
+		context,
+		invoke: (options) => context.forwardActivity(identity, target, Object.assign(options, { skipIfUnsigned: false }))
+	};
+}
+test("dispatch ID validation precedes send and forward side effects", async (t) => {
+	for (const { mode, observed } of [{
+		mode: "send",
+		observed: false
+	}, ...modes.map((mode) => ({
+		mode,
+		observed: true
+	}))]) await t.step(`${mode}: ${observed ? "observed" : "unobserved"}`, async () => {
+		let sideEffects = 0;
+		const queue = {
+			enqueue() {
+				sideEffects++;
+				return Promise.resolve();
+			},
+			listen: () => Promise.resolve()
+		};
+		const federation = createFederation({
+			...loaders,
+			kv: new MemoryKvStore(),
+			manuallyStartQueue: true,
+			queue: {
+				outbox: queue,
+				fanout: queue
+			}
+		});
+		federation.setActorDispatcher("/users/{identifier}", () => {
+			sideEffects++;
+			return new Person({});
+		}).setKeyPairsDispatcher(() => {
+			sideEffects++;
+			return [];
+		});
+		const { context, invoke } = entry(federation, mode, { identifier: "alice" });
+		const provider = context.tracerProvider;
+		Object.defineProperty(context, "tracerProvider", { get() {
+			sideEffects++;
+			return provider;
+		} });
+		const events = [];
+		let deliveries = 0;
+		if (observed) federation.setOutboundObservers({
+			onBroadcast(_ctx, event) {
+				events.push(event);
+			},
+			onDelivery() {
+				deliveries++;
+			}
+		});
+		for (const value of [
+			null,
+			"x".repeat(1025),
+			"😀".repeat(257)
+		]) {
+			const start = events.length;
+			let original;
+			await rejects(invoke({ dispatchId: value }), (error) => {
+				original = error;
+				ok(value === null ? error instanceof TypeError : error instanceof RangeError);
+				ok(error.message.includes("dispatchId"));
+				return true;
+			});
+			strictEqual(sideEffects, 0);
+			strictEqual(deliveries, 0);
+			if (observed) {
+				deepStrictEqual(events.slice(start).map((event) => event.stage), ["started", "preparation-finished"]);
+				const finished = events.at(-1);
+				ok(finished.stage === "preparation-finished" && finished.result.type === "failed");
+				strictEqual(finished.result.failure.phase, "validation");
+				strictEqual(finished.result.failure.error, original);
+				strictEqual(finished.provenance.dispatchId, void 0);
+			}
+		}
+	});
+});
+test("dispatch IDs correlate send and forward entries without deduplication or context leakage", async (t) => {
+	for (const mode of modes) await t.step(mode, async () => {
+		const messages = [];
+		const queue = {
+			enqueue(message) {
+				messages.push(message);
+				return Promise.resolve();
+			},
+			listen: () => Promise.resolve()
+		};
+		const federation = createFederation({
+			...loaders,
+			kv: new MemoryKvStore(),
+			manuallyStartQueue: true,
+			queue: {
+				fanout: queue,
+				outbox: queue
+			}
+		});
+		const { context, invoke } = entry(federation, mode);
+		const broadcasts = [];
+		const deliveries = [];
+		const contexts = [];
+		let current = {};
+		federation.setOutboundObservers({
+			onBroadcast(ctx, event) {
+				broadcasts.push(event);
+				contexts.push(ctx);
+				if (event.stage === "started") current.dispatchId = "observer-mutated";
+			},
+			onDelivery(ctx, event) {
+				deliveries.push(event);
+				contexts.push(ctx);
+			}
+		});
+		const dispatchId = "  app\\dispatch\"\n한글  ";
+		for (const value of [
+			dispatchId,
+			dispatchId,
+			void 0
+		]) {
+			current = { dispatchId: value };
+			await invoke(current);
+		}
+		strictEqual(messages.length, 3);
+		const starts = broadcasts.filter((event) => event.stage === "started");
+		strictEqual(starts.length, 3);
+		strictEqual(new Set(starts.map((event) => event.broadcastId)).size, 3);
+		deepStrictEqual(starts.map((event) => event.activity), [
+			{},
+			{},
+			{}
+		]);
+		const finishes = broadcasts.filter((event) => event.stage === "preparation-finished");
+		strictEqual(finishes.length, 3);
+		for (const event of finishes) {
+			deepStrictEqual(event.activity, {
+				id: activity.id.href,
+				type: Create.typeId.href
+			});
+			ok(Object.isFrozen(event.activity));
+		}
+		for (const ctx of contexts) strictEqual(ctx, context);
+		for (let index = 0; index < 3; index++) {
+			const message = messages[index];
+			ok(message.type === "outbox" || message.type === "fanout");
+			const expected = index < 2 ? dispatchId : void 0;
+			strictEqual(message.provenance?.dispatchId, expected);
+			strictEqual(starts[index].provenance.dispatchId, expected);
+			deepStrictEqual(JSON.parse(JSON.stringify(message.provenance ?? {})), message.provenance ?? {});
+			const delivery = deliveries[index * 2];
+			strictEqual(delivery.provenance.dispatchId, expected);
+		}
+		if (mode === "send") {
+			const fanout = messages[0];
+			ok(fanout.type === "fanout");
+			await federation.processQueuedTask(void 0, JSON.parse(JSON.stringify(fanout)));
+			await federation.processQueuedTask(void 0, structuredClone(fanout));
+			for (const child of messages.slice(3)) {
+				ok(child.type === "outbox");
+				strictEqual(child.provenance?.dispatchId, dispatchId);
+				deepStrictEqual(child.outbound, fanout.inboxes[target.inboxId.href].outbound);
+			}
+			strictEqual(messages.length, 5);
+			strictEqual(broadcasts.length, 6);
+		}
+	});
+});
+test("dispatch ID byte limits and queue fallback preserve exact values", async () => {
+	const messages = [];
+	const queue = {
+		enqueue(message) {
+			messages.push(message);
+			return Promise.resolve();
+		},
+		listen: () => Promise.resolve()
+	};
+	const { invoke } = entry(createFederation({
+		...loaders,
+		kv: new MemoryKvStore(),
+		manuallyStartQueue: true,
+		queue: { outbox: queue }
+	}), "outbox-send");
+	const valid = [
+		"",
+		"x".repeat(1024),
+		"😀".repeat(256)
+	];
+	for (const dispatchId of valid) await invoke({ dispatchId });
+	strictEqual(messages.length, 3);
+	const records = [];
+	await reset();
+	await configure({
+		sinks: { buffer: (record) => records.push(record) },
+		loggers: [
+			{
+				category: ["test", "dispatch"],
+				sinks: ["buffer"],
+				lowestLevel: "info"
+			},
+			{
+				category: [
+					"fedify",
+					"federation",
+					"queue"
+				],
+				sinks: ["buffer"],
+				lowestLevel: "warning"
+			},
+			{
+				category: ["logtape", "meta"],
+				sinks: []
+			}
+		],
+		contextLocalStorage: new AsyncLocalStorage()
+	});
+	const consumer = createFederation({
+		kv: new MemoryKvStore(),
+		allowPrivateAddress: true,
+		manuallyStartQueue: true,
+		queue: { outbox: queue }
+	});
+	const descendants = [];
+	consumer.setOutboundObservers({ onBroadcast(_ctx, event) {
+		descendants.push(event);
+	} });
+	consumer.setOutboxPermanentFailureHandler(async (ctx) => {
+		getLogger(["test", "dispatch"]).info("original dispatch");
+		await ctx.sendActivity(sender, [], activity);
+	});
+	esm_default.mockGlobal().post(target.inboxId.href, 410);
+	try {
+		const queued = messages[0];
+		ok(queued.type === "outbox");
+		const malformed = [
+			{ dispatchId: null },
+			{ dispatchId: "x".repeat(1025) },
+			{ dispatchId: "😀".repeat(257) },
+			{ inboxRequest: {
+				inboxRequestId: "",
+				requestId: "bad",
+				context: {
+					origin: "x",
+					host: "x",
+					hostname: "x",
+					canonicalOrigin: "x"
+				}
+			} }
+		];
+		for (const provenance of malformed) await withContext({
+			requestId: "current-request",
+			dispatchId: "ambient-dispatch"
+		}, () => consumer.processQueuedTask(void 0, {
+			...queued,
+			provenance
+		}));
+		ok(esm_default.callHistory.calls().length >= malformed.length);
+		const warnings = records.filter((record) => record.rawMessage === "Ignoring invalid provenance in queue message {messageId}: {error}");
+		strictEqual(warnings.length, malformed.length);
+		for (const warning of warnings) strictEqual(warning.properties.messageId, queued.id);
+		for (let index = 0; index < messages.length; index++) {
+			const message = messages[index];
+			ok(message.type === "outbox");
+			strictEqual(message.provenance?.dispatchId, valid[index]);
+			await withContext({
+				requestId: "current-request",
+				dispatchId: "ambient-dispatch"
+			}, () => consumer.processQueuedTask(void 0, JSON.parse(JSON.stringify(message))));
+		}
+		const logs = records.filter((record) => record.rawMessage === "original dispatch");
+		deepStrictEqual(logs.map((record) => record.properties.dispatchId), [...malformed.map(() => void 0), ...valid]);
+		for (const record of logs) strictEqual(record.properties.requestId, "current-request");
+		strictEqual(descendants.length, 2 * (malformed.length + valid.length));
+		for (const event of descendants) strictEqual(event.provenance.dispatchId, void 0);
+	} finally {
+		esm_default.hardReset();
+		await reset();
+	}
+});
+test("malformed queued provenance does not poison a retry", async () => {
+	const messages = [];
+	const federation = createFederation({
+		kv: new MemoryKvStore(),
+		allowPrivateAddress: true,
+		manuallyStartQueue: true,
+		outboxRetryPolicy: () => Temporal.Duration.from({ milliseconds: 1 }),
+		queue: { outbox: {
+			enqueue(message) {
+				messages.push(message);
+				return Promise.resolve();
+			},
+			listen: () => Promise.resolve()
+		} }
+	});
+	await federation.createContext(new URL("https://example.com"), void 0).sendActivity(sender, target, activity, { fanout: "skip" });
+	const original = messages[0];
+	ok(original.type === "outbox");
+	const malformed = {
+		...original,
+		provenance: { inboxRequest: { inboxRequestId: "" } }
+	};
+	esm_default.mockGlobal().post(target.inboxId.href, 503);
+	try {
+		await federation.processQueuedTask(void 0, malformed);
+		strictEqual(messages.length, 2);
+		const retry = messages[1];
+		ok(retry.type === "outbox");
+		deepStrictEqual(retry.provenance, {});
+		strictEqual(retry.attempt, 1);
+		await federation.processQueuedTask(void 0, retry);
+		strictEqual(messages.length, 3);
+		const next = messages[2];
+		ok(next.type === "outbox");
+		deepStrictEqual(next.provenance, {});
+	} finally {
+		esm_default.hardReset();
+	}
+});
+//#endregion
+export {};

package/dist/federation/outbound-document.test.d.mts

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

package/dist/federation/outbound-document.test.mjs

@@ -0,0 +1,171 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as projectSenderPayload } from "../outbound-document-BMgwLXTY.mjs";
+import { n as FederationBuilderImpl, r as createFederationBuilder } from "../builder-B2H8GsyI.mjs";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, strictEqual, throws } from "node:assert/strict";
+//#region src/federation/outbound-document.test.ts
+const as = "https://www.w3.org/ns/activitystreams";
+const secret = "https://private.example/recipient";
+test("sender payload projects nested compact expanded and proof-bearing blind fields", () => {
+	const source = {
+		"@context": [as, "https://w3id.org/security/data-integrity/v2"],
+		type: "Create",
+		bto: [secret],
+		object: {
+			bcc: [secret],
+			children: [{
+				"as:bto": secret,
+				[`${as}#bcc`]: secret,
+				content: "visible"
+			}],
+			proof: {
+				"@context": "https://w3id.org/identity/v1",
+				type: "DataIntegrityProof",
+				proofValue: "retained-proof",
+				"as:bcc": secret
+			}
+		},
+		signature: {
+			signatureValue: "retained-signature",
+			[`${as}#bto`]: secret
+		}
+	};
+	const original = structuredClone(source);
+	const result = projectSenderPayload(source);
+	ok(result.type === "available");
+	strictEqual(result.representation, "privacy-projection");
+	strictEqual(result.redacted, true);
+	strictEqual(JSON.stringify(result.value).includes(secret), false);
+	ok(JSON.stringify(result.value).includes("retained-proof"));
+	ok(JSON.stringify(result.value).includes("retained-signature"));
+	deepStrictEqual(source, original);
+	ok(Object.isFrozen(result));
+	ok(Object.isFrozen(result.value));
+	const value = result.value;
+	ok(Object.isFrozen(value.object));
+	source.object.children[0].content = "changed";
+	ok(JSON.stringify(result.value).includes("visible"));
+	const expanded = projectSenderPayload([{
+		"@type": [`${as}#Create`],
+		[`${as}#object`]: [{
+			[`${as}#bcc`]: [{ "@id": secret }],
+			[`${as}#content`]: [{ "@value": "visible" }]
+		}]
+	}]);
+	ok(expanded.type === "available");
+	strictEqual(expanded.redacted, true);
+	strictEqual(JSON.stringify(expanded.value).includes(secret), false);
+});
+test("sender payload fails closed without evaluating getters or JSON conversion", () => {
+	let getters = 0;
+	let conversions = 0;
+	const getter = {
+		"@context": as,
+		get object() {
+			getters++;
+			return "private";
+		}
+	};
+	const conversion = { "@context": as };
+	Object.defineProperty(conversion, "toJSON", { value() {
+		conversions++;
+		return {};
+	} });
+	const context = [as];
+	Object.defineProperty(context, "includes", {
+		get() {
+			getters++;
+			throw new Error("must not run");
+		},
+		enumerable: true
+	});
+	const cycle = { "@context": as };
+	cycle.object = cycle;
+	let deep = "leaf";
+	for (let i = 0; i < 65; i++) deep = { object: deep };
+	for (const source of [
+		{
+			"@context": [as, { private: `${as}#bcc` }],
+			private: secret
+		},
+		{
+			"@context": as,
+			object: {
+				"@context": { as: "https://other.example/" },
+				"as:bcc": secret
+			}
+		},
+		{
+			"@context": [as, "https://unknown.example/context"],
+			private: secret
+		},
+		{
+			"@context": [as, { sensitive: "as:bcc" }],
+			sensitive: secret
+		},
+		{
+			"@context": [as, {
+				toot: `${as}#`,
+				Emoji: "toot:bcc"
+			}],
+			Emoji: secret
+		},
+		{
+			type: "Create",
+			object: secret
+		},
+		getter,
+		conversion,
+		{ "@context": context },
+		cycle,
+		{
+			"@context": as,
+			object: deep
+		},
+		{
+			"@context": as,
+			object: NaN
+		},
+		{
+			"@context": as,
+			object: /* @__PURE__ */ new Date()
+		},
+		{
+			"@context": as,
+			object: [void 0]
+		}
+	]) deepStrictEqual(projectSenderPayload(source), {
+		stage: "sender-payload",
+		type: "unavailable",
+		reason: "privacy-filter-unavailable"
+	});
+	strictEqual(getters, 0);
+	strictEqual(conversions, 0);
+});
+test("sender payload opt-in validates atomically and retains builder selection", () => {
+	const builder = createFederationBuilder();
+	ok(builder instanceof FederationBuilderImpl);
+	const config = {
+		senderPayload: true,
+		onAttempt() {}
+	};
+	builder.setOutboundObservers(config);
+	const original = builder.outboundObservers;
+	config.senderPayload = false;
+	strictEqual(original.senderPayload, true);
+	for (const value of [
+		null,
+		1,
+		"true",
+		{}
+	]) {
+		throws(() => builder.setOutboundObservers({ senderPayload: value }), TypeError);
+		strictEqual(builder.outboundObservers, original);
+	}
+	builder.setOutboundObservers({});
+	strictEqual(builder.outboundObservers.senderPayload, false);
+});
+//#endregion
+export {};

package/dist/federation/outbound-provenance.test.d.mts

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