@fedify/fedify 2.4.0-dev.1504 → 2.4.0-dev.1528

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

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

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

@@ -1,555 +0,0 @@
-import { Temporal } from "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../testing-Dy-WhqpN.mjs";
-import { o as createFederation } from "../../middleware-iP9VRMus.mjs";
-import { r as createFederationBuilder } from "../../builder-Ck0Fl_a5.mjs";
-import { t as TaskCodec } from "../../codec-CmlPqjNX.mjs";
-import { t as InProcessMessageQueue } from "../../mq-03vS-C9P.mjs";
-import { Note } from "@fedify/vocab";
-import { delay } from "es-toolkit";
-import { mockDocumentLoader, test } from "@fedify/fixture";
-import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
-//#region src/federation/tasks/tasks.test.ts
-const envelopeSchema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
-const makeTaskMessage = async (taskName, data, overrides = {}) => ({
-	type: "task",
-	id: crypto.randomUUID(),
-	baseUrl: "https://example.com/",
-	taskName,
-	data: await new TaskCodec({ contextLoader: mockDocumentLoader }).serialize(data),
-	started: Temporal.Now.instant().toString(),
-	attempt: 0,
-	traceContext: {},
-	...overrides
-});
-async function waitFor(predicate, timeoutMs) {
-	const started = Date.now();
-	while (!predicate()) {
-		await delay(50);
-		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
-	}
-}
-test("defineTask()", async (t) => {
-	await t.step("returns a handle carrying name and schema", () => {
-		const task = createFederation({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		}).defineTask("greet", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		strictEqual(task.name, "greet");
-		strictEqual(task.schema, stringSchema);
-	});
-	await t.step("throws on a duplicate name", () => {
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		});
-		federation.defineTask("dup", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		throws(() => federation.defineTask("dup", {
-			schema: stringSchema,
-			handler: () => {}
-		}), {
-			name: "TypeError",
-			message: /already defined/
-		});
-	});
-	await t.step("accepts names that collide with Object.prototype", () => {
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		});
-		for (const name of [
-			"constructor",
-			"toString",
-			"hasOwnProperty"
-		]) {
-			strictEqual(federation.defineTask(name, {
-				schema: stringSchema,
-				handler: () => {}
-			}).name, name);
-			strictEqual(federation.taskDefinitions.get(name)?.name, name);
-		}
-		throws(() => federation.defineTask("toString", {
-			schema: stringSchema,
-			handler: () => {}
-		}), {
-			name: "TypeError",
-			message: /already defined/
-		});
-	});
-	await t.step("build() clones the task registry", async () => {
-		const builder = createFederationBuilder();
-		builder.defineTask("first", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const f1 = await builder.build({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		});
-		builder.defineTask("second", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const f2 = await builder.build({
-			...baseOptions,
-			queue: { task: new MockQueue() }
-		});
-		deepStrictEqual([...f1.taskDefinitions.keys()], ["first"]);
-		deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
-		f1.defineTask("third", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
-	});
-});
-test("task type-level guards", () => {});
-test("Context.enqueueTask() end-to-end", async (t) => {
-	await t.step("round-trips a typed payload to the handler", async () => {
-		const queue = new InProcessMessageQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const received = [];
-		const task = federation.defineTask("notify", {
-			schema: envelopeSchema,
-			handler: (ctx, data) => {
-				received.push({
-					ctx,
-					data
-				});
-			}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, {
-			note: new Note({ content: "Hello, world!" }),
-			title: "greeting"
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, {
-			signal: controller.signal,
-			queue: "task"
-		});
-		try {
-			await waitFor(() => received.length > 0, 15e3);
-		} finally {
-			controller.abort();
-			await listening;
-		}
-		strictEqual(received.length, 1);
-		const { ctx: handlerCtx, data } = received[0];
-		ok(data.note instanceof Note);
-		strictEqual(data.note.content?.toString(), "Hello, world!");
-		strictEqual(data.title, "greeting");
-		strictEqual(handlerCtx.origin, "https://example.com");
-	});
-});
-test("task queue routing", async (t) => {
-	await t.step("prefers the per-task queue", async () => {
-		const taskQueue = new MockQueue();
-		const perTaskQueue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: taskQueue }
-		});
-		const task = federation.defineTask("isolated", {
-			schema: stringSchema,
-			handler: () => {},
-			queue: perTaskQueue
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "data");
-		strictEqual(perTaskQueue.enqueued.length, 1);
-		strictEqual(taskQueue.enqueued.length, 0);
-	});
-	await t.step("falls back to the outbox queue by default", async () => {
-		const outboxQueue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { outbox: outboxQueue }
-		});
-		const task = federation.defineTask("fallback", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "data");
-		strictEqual(outboxQueue.enqueued.length, 1);
-	});
-	await t.step("taskQueueResolution: \"strict\" throws at enqueue instead", async () => {
-		const outboxQueue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { outbox: outboxQueue },
-			taskQueueResolution: "strict"
-		});
-		const task = federation.defineTask("strict", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(task, "data"), {
-			name: "TypeError",
-			message: /No message queue is configured/
-		});
-		strictEqual(outboxQueue.enqueued.length, 0);
-	});
-	await t.step("throws when no queue is configured at all", async () => {
-		const federation = createFederation({ ...baseOptions });
-		const task = federation.defineTask("queueless", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
-		await rejects(() => ctx.enqueueTask(task, "data"), {
-			name: "TypeError",
-			message: /No message queue is configured/
-		});
-	});
-});
-test("startQueue() task worker", async (t) => {
-	await t.step("starts only the task worker for queue: \"task\"", async () => {
-		const inbox = new MockQueue();
-		const outbox = new MockQueue();
-		const fanout = new MockQueue();
-		const taskQueue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: {
-				inbox,
-				outbox,
-				fanout,
-				task: taskQueue
-			}
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, {
-			signal: controller.signal,
-			queue: "task"
-		});
-		strictEqual(taskQueue.listenCount, 1);
-		strictEqual(inbox.listenCount, 0);
-		strictEqual(outbox.listenCount, 0);
-		strictEqual(fanout.listenCount, 0);
-		controller.abort();
-		await listening;
-	});
-	await t.step("starts the worker for a task-only deployment", async () => {
-		const taskQueue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: taskQueue }
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, { signal: controller.signal });
-		strictEqual(taskQueue.listenCount, 1);
-		controller.abort();
-		await listening;
-	});
-	await t.step("does not double-listen on a shared queue", async () => {
-		const shared = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: {
-				outbox: shared,
-				task: shared
-			}
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, { signal: controller.signal });
-		strictEqual(shared.listenCount, 1);
-		controller.abort();
-		await listening;
-	});
-	await t.step("starts a worker for a dedicated per-task queue", async () => {
-		const taskQueue = new MockQueue();
-		const dedicated = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: taskQueue }
-		});
-		federation.defineTask("dedicated", {
-			schema: stringSchema,
-			handler: () => {},
-			queue: dedicated
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, { signal: controller.signal });
-		strictEqual(taskQueue.listenCount, 1);
-		strictEqual(dedicated.listenCount, 1);
-		controller.abort();
-		await listening;
-	});
-	await t.step("starts a per-task queue even without a federation queue", async () => {
-		const dedicated = new MockQueue();
-		const federation = createFederation({ ...baseOptions });
-		federation.defineTask("dedicated", {
-			schema: stringSchema,
-			handler: () => {},
-			queue: dedicated
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, { signal: controller.signal });
-		strictEqual(dedicated.listenCount, 1);
-		controller.abort();
-		await listening;
-	});
-	await t.step("does not listen twice on a per-task queue shared with a standard queue", async () => {
-		const shared = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: shared }
-		});
-		federation.defineTask("reuses-task-queue", {
-			schema: stringSchema,
-			handler: () => {},
-			queue: shared
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, { signal: controller.signal });
-		strictEqual(shared.listenCount, 1);
-		controller.abort();
-		await listening;
-	});
-	await t.step("routes an enqueued task on a dedicated queue to its handler", async () => {
-		const dedicated = new MockQueue();
-		const federation = createFederation({ ...baseOptions });
-		let received;
-		const task = federation.defineTask("dedicated-end-to-end", {
-			schema: stringSchema,
-			handler: (_ctx, data) => {
-				received = data;
-			},
-			queue: dedicated
-		});
-		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload");
-		strictEqual(dedicated.enqueued.length, 1);
-		await federation.processQueuedTask(void 0, dedicated.enqueued[0].message);
-		strictEqual(received, "payload");
-	});
-	await t.step("queue: \"task\" starts the outbox fallback when no task queue is set", async () => {
-		const inbox = new MockQueue();
-		const outbox = new MockQueue();
-		const fanout = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: {
-				inbox,
-				outbox,
-				fanout
-			}
-		});
-		federation.defineTask("fallback", {
-			schema: stringSchema,
-			handler: () => {}
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, {
-			signal: controller.signal,
-			queue: "task"
-		});
-		strictEqual(outbox.listenCount, 1);
-		strictEqual(inbox.listenCount, 0);
-		strictEqual(fanout.listenCount, 0);
-		controller.abort();
-		await listening;
-	});
-	await t.step("queue: \"task\" starts a task queue shared with the outbox once", async () => {
-		const inbox = new MockQueue();
-		const shared = new MockQueue();
-		const fanout = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: {
-				inbox,
-				outbox: shared,
-				fanout,
-				task: shared
-			}
-		});
-		const controller = new AbortController();
-		const listening = federation.startQueue(void 0, {
-			signal: controller.signal,
-			queue: "task"
-		});
-		strictEqual(shared.listenCount, 1);
-		strictEqual(inbox.listenCount, 0);
-		strictEqual(fanout.listenCount, 0);
-		controller.abort();
-		await listening;
-	});
-});
-test("MockQueue.listen() resolves on a pre-aborted signal", async () => {
-	const queue = new MockQueue();
-	const controller = new AbortController();
-	controller.abort();
-	let timer;
-	const settled = await Promise.race([queue.listen(() => {}, { signal: controller.signal }).then(() => "resolved"), new Promise((resolve) => {
-		timer = setTimeout(() => resolve("pending"), 50);
-	})]);
-	clearTimeout(timer);
-	strictEqual(settled, "resolved");
-});
-test("processQueuedTask() task dispatch", async (t) => {
-	await t.step("drops an unknown task with a warning", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const message = await makeTaskMessage("never-defined", "data");
-		await federation.processQueuedTask(void 0, message);
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("drops an undecodable payload without retry", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		let called = 0;
-		federation.defineTask("broken-wire", {
-			schema: stringSchema,
-			handler: () => {
-				called++;
-			}
-		});
-		const message = await makeTaskMessage("broken-wire", "data");
-		await federation.processQueuedTask(void 0, {
-			...message,
-			data: "garbage that is not devalue"
-		});
-		strictEqual(called, 0);
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("drops a drifted payload without retry", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		let called = 0;
-		federation.defineTask("drifted", {
-			schema: numberSchema,
-			handler: () => {
-				called++;
-			}
-		});
-		const message = await makeTaskMessage("drifted", "stringly-typed");
-		await federation.processQueuedTask(void 0, message);
-		strictEqual(called, 0);
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("re-enqueues with attempt + 1 when the handler throws", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		const errors = [];
-		federation.defineTask("flaky", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			},
-			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 }),
-			onError: (_ctx, error, data) => {
-				errors.push([error, data]);
-			}
-		});
-		const message = await makeTaskMessage("flaky", "data", { orderingKey: "k" });
-		await federation.processQueuedTask(void 0, message);
-		strictEqual(queue.enqueued.length, 1);
-		const retry = queue.enqueued[0];
-		strictEqual(retry.message.attempt, 1);
-		strictEqual(retry.message.taskName, "flaky");
-		strictEqual(retry.message.orderingKey, "k");
-		strictEqual(retry.options?.orderingKey, "k");
-		ok(retry.options?.delay instanceof Temporal.Duration);
-		strictEqual(errors.length, 1);
-		deepStrictEqual(errors[0], [/* @__PURE__ */ new Error("boom"), "data"]);
-	});
-	await t.step("gives up when the retry policy returns null", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		federation.defineTask("hopeless", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			},
-			retryPolicy: () => null
-		});
-		const message = await makeTaskMessage("hopeless", "data");
-		await federation.processQueuedTask(void 0, message);
-		strictEqual(queue.enqueued.length, 0);
-	});
-	await t.step("per-task retryPolicy overrides the federation default", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue },
-			taskRetryPolicy: () => null
-		});
-		federation.defineTask("override", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			},
-			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 })
-		});
-		federation.defineTask("default", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			}
-		});
-		await federation.processQueuedTask(void 0, await makeTaskMessage("override", "data"));
-		strictEqual(queue.enqueued.length, 1);
-		await federation.processQueuedTask(void 0, await makeTaskMessage("default", "data"));
-		strictEqual(queue.enqueued.length, 1);
-	});
-	await t.step("still retries when message.started is malformed", async () => {
-		const queue = new MockQueue();
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		federation.defineTask("bad-started", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			},
-			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 })
-		});
-		const message = await makeTaskMessage("bad-started", "data", { started: "not-an-instant" });
-		await federation.processQueuedTask(void 0, message);
-		strictEqual(queue.enqueued.length, 1);
-		strictEqual(queue.enqueued[0].message.attempt, 1);
-	});
-	await t.step("rethrows on a nativeRetrial queue", async () => {
-		const queue = new MockQueue({ nativeRetrial: true });
-		const federation = createFederation({
-			...baseOptions,
-			queue: { task: queue }
-		});
-		federation.defineTask("native", {
-			schema: stringSchema,
-			handler: () => {
-				throw new Error("boom");
-			}
-		});
-		const message = await makeTaskMessage("native", "data");
-		await rejects(() => federation.processQueuedTask(void 0, message), { message: /boom/ });
-		strictEqual(queue.enqueued.length, 0);
-	});
-});
-//#endregion
-export {};