@fedify/fedify 2.4.0-dev.1490 → 2.4.0-dev.1508

package/dist/federation/tasks/codec.test.mjs

@@ -0,0 +1,292 @@
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as TaskCodec } from "../../codec-CmlPqjNX.mjs";
+import { Create, Link, Note, Person } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+//#region src/federation/tasks/codec.test.ts
+const loaders = {
+	contextLoader: mockDocumentLoader,
+	documentLoader: mockDocumentLoader
+};
+const codec = new TaskCodec(loaders);
+function makeSchema(check) {
+	return { "~standard": {
+		version: 1,
+		vendor: "fedify-test",
+		validate(value) {
+			return check(value) ? { value } : { issues: [{ message: "Invalid task data." }] };
+		}
+	} };
+}
+test("TaskCodec.serialize() / deserialize()", async (t) => {
+	const note = new Note({
+		id: new URL("https://example.com/notes/1"),
+		content: "Hello, world!"
+	});
+	const person = new Person({
+		id: new URL("https://example.com/users/alice"),
+		name: "Alice"
+	});
+	const link = new Link({
+		href: new URL("https://example.com/"),
+		mediaType: "text/html"
+	});
+	const create = new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/users/alice"),
+		object: note
+	});
+	await t.step("round-trips a mixed payload", async () => {
+		const payload = {
+			note,
+			when: /* @__PURE__ */ new Date("2026-01-02T03:04:05Z"),
+			big: 1234567890123456789n,
+			url: new URL("https://example.com/some/path"),
+			list: [person, link],
+			map: new Map([["create", create], ["n", 42]]),
+			set: new Set([
+				1,
+				2,
+				3
+			]),
+			nested: { create }
+		};
+		const encoded = await codec.serialize(payload);
+		strictEqual(typeof encoded, "string");
+		const decoded = await codec.deserialize(encoded);
+		ok(decoded.note instanceof Note);
+		strictEqual(decoded.note.content?.toString(), "Hello, world!");
+		strictEqual(decoded.note.id?.href, "https://example.com/notes/1");
+		ok(decoded.when instanceof Date);
+		strictEqual(decoded.when.toISOString(), "2026-01-02T03:04:05.000Z");
+		strictEqual(decoded.big, 1234567890123456789n);
+		ok(decoded.url instanceof URL);
+		strictEqual(decoded.url.href, "https://example.com/some/path");
+		const list = decoded.list;
+		ok(list[0] instanceof Person);
+		strictEqual(list[0].name?.toString(), "Alice");
+		ok(list[1] instanceof Link);
+		strictEqual(list[1].href?.href, "https://example.com/");
+		const map = decoded.map;
+		ok(map.get("create") instanceof Create);
+		strictEqual(map.get("n"), 42);
+		deepStrictEqual(decoded.set, new Set([
+			1,
+			2,
+			3
+		]));
+		const nested = decoded.nested;
+		ok(nested.create instanceof Create);
+		const nestedObject = await nested.create.getObject({
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		ok(nestedObject instanceof Note);
+		strictEqual(nestedObject.content?.toString(), "Hello, world!");
+	});
+	await t.step("encodes vocab objects in expand form (no @context)", async () => {
+		ok(!(await codec.serialize({ note })).includes("@context"));
+	});
+	await t.step("leaves a non-vocab payload untouched", async () => {
+		const payload = {
+			text: "plain",
+			n: 1,
+			flag: true,
+			nothing: null,
+			when: /* @__PURE__ */ new Date("2026-06-10T00:00:00Z"),
+			list: [
+				1,
+				"two",
+				3n
+			]
+		};
+		const encoded = await codec.serialize(payload);
+		deepStrictEqual(await codec.deserialize(encoded), payload);
+	});
+	await t.step("throws on a malformed wire string", async () => {
+		await rejects(async () => await codec.deserialize("garbage"));
+	});
+	await t.step("preserves circular and repeated references", async () => {
+		const shared = new Note({ content: "shared" });
+		const payload = {
+			name: "root",
+			notes: [shared, shared]
+		};
+		payload.self = payload;
+		const encoded = await codec.serialize(payload);
+		const decoded = await codec.deserialize(encoded);
+		strictEqual(decoded.self, decoded);
+		ok(decoded.notes[0] instanceof Note);
+		strictEqual(decoded.notes[0], decoded.notes[1]);
+		strictEqual(decoded.notes[0].content?.toString(), "shared");
+	});
+	await t.step("preserves a cycle through an array", async () => {
+		const list = ["head"];
+		list.push(list);
+		const encoded = await codec.serialize({ list });
+		const decoded = await codec.deserialize(encoded);
+		strictEqual(decoded.list[0], "head");
+		strictEqual(decoded.list[1], decoded.list);
+	});
+	await t.step("preserves cycles re-entering at a Map and a Set", async () => {
+		const set = /* @__PURE__ */ new Set();
+		set.add({ set });
+		const map = /* @__PURE__ */ new Map();
+		map.set("entry", { map });
+		const encoded = await codec.serialize({
+			set,
+			map
+		});
+		const decoded = await codec.deserialize(encoded);
+		const [member] = decoded.set;
+		strictEqual(member.set, decoded.set);
+		strictEqual(decoded.map.get("entry")?.map, decoded.map);
+	});
+	await t.step("revives a vocab object nested in a null-prototype object", async () => {
+		const nullProto = Object.create(null);
+		nullProto.note = note;
+		const encoded = await codec.serialize({ wrap: nullProto });
+		const decoded = await codec.deserialize(encoded);
+		ok(decoded.wrap.note instanceof Note);
+		strictEqual(decoded.wrap.note.content?.toString(), "Hello, world!");
+	});
+	await t.step("revives a payload nested far deeper than any fixed depth cap", async () => {
+		const depth = 1e3;
+		let payload = new Note({ content: "deep" });
+		for (let i = 0; i < depth; i++) payload = i % 2 === 0 ? { inner: payload } : [payload];
+		const encoded = await codec.serialize(payload);
+		let decoded = await codec.deserialize(encoded);
+		for (let i = depth - 1; i >= 0; i--) decoded = i % 2 === 0 ? decoded.inner : decoded[0];
+		ok(decoded instanceof Note);
+		strictEqual(decoded.content?.toString(), "deep");
+	});
+	await t.step("round-trips an array too large to spread into push()", async () => {
+		const length = 2e5;
+		const payload = { big: Array.from({ length }, (_, i) => i) };
+		const encoded = await codec.serialize(payload);
+		const decoded = await codec.deserialize(encoded);
+		strictEqual(decoded.big.length, length);
+		strictEqual(decoded.big[0], 0);
+		strictEqual(decoded.big[length - 1], length - 1);
+	});
+	await t.step({
+		name: "round-trips Temporal values",
+		ignore: "Bun" in globalThis,
+		async fn() {
+			const payload = {
+				instant: Temporal.Instant.from("2026-01-02T03:04:05Z"),
+				duration: Temporal.Duration.from({
+					hours: 1,
+					minutes: 30
+				})
+			};
+			const encoded = await codec.serialize(payload);
+			const decoded = await codec.deserialize(encoded);
+			ok(decoded.instant instanceof Temporal.Instant);
+			ok(decoded.instant.equals(payload.instant));
+			ok(decoded.duration instanceof Temporal.Duration);
+			strictEqual(decoded.duration.toString(), payload.duration.toString());
+		}
+	});
+});
+test("TaskCodec (one instance reused across decodes)", async (t) => {
+	await t.step("two sequential decodes stay independent", async () => {
+		const codec = new TaskCodec(loaders);
+		const first = await codec.serialize({ note: new Note({ content: "A" }) });
+		const second = await codec.serialize({ note: new Note({ content: "B" }) });
+		const a = await codec.deserialize(first);
+		const b = await codec.deserialize(second);
+		ok(a.note instanceof Note);
+		ok(b.note instanceof Note);
+		strictEqual(a.note.content?.toString(), "A");
+		strictEqual(b.note.content?.toString(), "B");
+	});
+});
+test("TaskCodec.validate()", async (t) => {
+	const schema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
+	await t.step("accepts a payload with a vocab instanceof leaf", async () => {
+		const payload = {
+			note: new Note({ content: "Hi" }),
+			title: "greeting"
+		};
+		deepStrictEqual(await TaskCodec.validate(schema, payload), payload);
+	});
+	await t.step("rejects a wrong-shaped payload", async () => {
+		await rejects(() => TaskCodec.validate(schema, {
+			note: "not a Note",
+			title: 42
+		}), {
+			name: "TypeError",
+			message: /Task data failed schema validation/
+		});
+	});
+	await t.step("supports async validation", async () => {
+		const asyncSchema = { "~standard": {
+			version: 1,
+			vendor: "fedify-test",
+			validate: (value) => Promise.resolve(typeof value === "number" ? { value } : { issues: [{ message: "not a number" }] })
+		} };
+		strictEqual(await TaskCodec.validate(asyncSchema, 42), 42);
+		await rejects(() => TaskCodec.validate(asyncSchema, "nope"));
+	});
+	await t.step("round-trip then validate (same schema on both sides)", async () => {
+		const payload = {
+			note: new Note({ content: "Hi" }),
+			title: "greeting"
+		};
+		const encoded = await codec.serialize(payload);
+		const decoded = await codec.deserialize(encoded);
+		const validated = await TaskCodec.validate(schema, decoded);
+		ok(validated.note instanceof Note);
+		strictEqual(validated.title, "greeting");
+		strictEqual(validated.note.content?.toString(), "Hi");
+	});
+});
+test("TaskCodec.encode() / decode()", async (t) => {
+	const schema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
+	await t.step("encode() validates then serializes; decode() round-trips", async () => {
+		const payload = {
+			note: new Note({ content: "Hi" }),
+			title: "greeting"
+		};
+		const wire = await codec.encode(schema, payload);
+		strictEqual(typeof wire, "string");
+		const back = await codec.decode(schema, wire);
+		ok(back.note instanceof Note);
+		strictEqual(back.note.content?.toString(), "Hi");
+		strictEqual(back.title, "greeting");
+	});
+	await t.step("encode() rejects a wrong-shaped payload", async () => {
+		await rejects(() => codec.encode(schema, {
+			note: "nope",
+			title: 42
+		}), {
+			name: "TypeError",
+			message: /Task data failed schema validation/
+		});
+	});
+	await t.step("decode() re-validates and rejects a drifted payload", async () => {
+		const loose = makeSchema((_data) => true);
+		const wire = await codec.encode(loose, { note: "not a note" });
+		await rejects(() => codec.decode(schema, wire), {
+			name: "TypeError",
+			message: /Task data failed schema validation/
+		});
+	});
+	await t.step("a non-idempotent (transforming) schema fails to round-trip", async () => {
+		const transforming = { "~standard": {
+			version: 1,
+			vendor: "fedify-test",
+			validate: (value) => typeof value === "string" ? { value: value.length } : { issues: [{ message: "Expected a string." }] }
+		} };
+		const wire = await codec.encode(transforming, "hello");
+		await rejects(() => codec.decode(transforming, wire), {
+			name: "TypeError",
+			message: /Task data failed schema validation/
+		});
+	});
+});
+//#endregion
+export {};

package/dist/federation/tasks/enqueue.test.d.mts

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