@fedify/fedify 2.3.0-dev.994 → 2.3.0-pr.809.36

package/dist/federation/mq.test.mjs

@@ -1,10 +1,10 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import { n as assertGreater, r as assertGreaterOrEqual } from "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { n as assertGreater } from "../std__assert-BBjXFNOb.mjs";
+import { n as assertGreaterOrEqual, r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
 import { test } from "@fedify/fixture";
 import { delay } from "es-toolkit";
 //#region src/federation/mq.ts
@@ -19,6 +19,7 @@ var InProcessMessageQueue = class {
 	#messages;
 	#monitors;
 	#pollIntervalMs;
+	#delayedMessages;
 	/**
 	* Tracks which ordering keys are currently being processed to ensure
 	* sequential processing for messages with the same key.
@@ -37,42 +38,56 @@ var InProcessMessageQueue = class {
 		this.#messages = [];
 		this.#monitors = {};
 		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+		this.#delayedMessages = 0;
 		this.#processingKeys = /* @__PURE__ */ new Set();
 	}
 	enqueue(message, options) {
 		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
 		if (delay > 0) {
-			setTimeout(() => this.enqueue(message, {
-				...options,
-				delay: void 0
-			}), delay);
+			this.#delayedMessages++;
+			setTimeout(() => {
+				this.#delayedMessages--;
+				this.#enqueueReady(message, options);
+			}, delay);
 			return Promise.resolve();
 		}
+		this.#enqueueReady(message, options);
+		return Promise.resolve();
+	}
+	#enqueueReady(message, options) {
 		const orderingKey = options?.orderingKey ?? null;
 		this.#messages.push({
 			message,
 			orderingKey
 		});
+		this.#notifyMonitors();
+	}
+	#notifyMonitors() {
 		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
-		return Promise.resolve();
 	}
 	enqueueMany(messages, options) {
 		if (messages.length === 0) return Promise.resolve();
 		const delay = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
 		if (delay > 0) {
-			setTimeout(() => this.enqueueMany(messages, {
-				...options,
-				delay: void 0
-			}), delay);
+			const delayedCount = messages.length;
+			const deferredMessages = [...messages];
+			this.#delayedMessages += delayedCount;
+			setTimeout(() => {
+				this.#delayedMessages -= delayedCount;
+				this.#enqueueManyReady(deferredMessages, options);
+			}, delay);
 			return Promise.resolve();
 		}
+		this.#enqueueManyReady(messages, options);
+		return Promise.resolve();
+	}
+	#enqueueManyReady(messages, options) {
 		const orderingKey = options?.orderingKey ?? null;
 		for (const message of messages) this.#messages.push({
 			message,
 			orderingKey
 		});
-		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
-		return Promise.resolve();
+		this.#notifyMonitors();
 	}
 	async listen(handler, options = {}) {
 		const signal = options.signal;
@@ -90,6 +105,15 @@ var InProcessMessageQueue = class {
 			else await this.#wait(10, signal);
 		}
 	}
+	getDepth() {
+		const ready = this.#messages.length;
+		const delayed = this.#delayedMessages;
+		return Promise.resolve({
+			queued: ready + delayed,
+			ready,
+			delayed
+		});
+	}
 	#wait(ms, signal) {
 		let timer = null;
 		return Promise.any([new Promise((resolve) => {
@@ -144,6 +168,7 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 	* @since 1.7.0
 	*/
 	nativeRetrial;
+	getDepth;
 	/**
 	* Tracks which ordering keys are currently being processed to ensure
 	* sequential processing for messages with the same key.
@@ -167,6 +192,7 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 		this.queue = queue;
 		this.workers = workers;
 		this.nativeRetrial = queue.nativeRetrial;
+		if (queue.getDepth != null) this.getDepth = () => queue.getDepth();
 	}
 	enqueue(message, options) {
 		return this.queue.enqueue(message, options);
@@ -256,6 +282,13 @@ test("InProcessMessageQueue", async (t) => {
 	await t.step("nativeRetrial property", () => {
 		assertFalse(mq.nativeRetrial);
 	});
+	await t.step("getDepth() [empty]", async () => {
+		assertEquals(await mq.getDepth(), {
+			queued: 0,
+			ready: 0,
+			delayed: 0
+		});
+	});
 	const messages = [];
 	const controller = new AbortController();
 	const listening = mq.listen((message) => {
@@ -306,6 +339,130 @@ test("InProcessMessageQueue", async (t) => {
 	controller.abort();
 	await listening;
 });
+test("InProcessMessageQueue.getDepth()", async () => {
+	const mq = new InProcessMessageQueue();
+	assertEquals(await mq.getDepth(), {
+		queued: 0,
+		ready: 0,
+		delayed: 0
+	});
+	await mq.enqueue("Ready message");
+	await mq.enqueue("Delayed message", { delay: Temporal.Duration.from({ seconds: 1 }) });
+	assertEquals(await mq.getDepth(), {
+		queued: 2,
+		ready: 1,
+		delayed: 1
+	});
+	const messages = [];
+	const controller = new AbortController();
+	const listening = mq.listen((message) => {
+		messages.push(message);
+		if (messages.length >= 2) controller.abort();
+	}, { signal: controller.signal });
+	await waitFor(() => messages.length >= 2, 15e3);
+	await listening;
+	assertEquals(await mq.getDepth(), {
+		queued: 0,
+		ready: 0,
+		delayed: 0
+	});
+});
+test("InProcessMessageQueue.getDepth() snapshots delayed batches", async () => {
+	const mq = new InProcessMessageQueue();
+	const messages = ["first", "second"];
+	await mq.enqueueMany(messages, { delay: Temporal.Duration.from({ milliseconds: 250 }) });
+	messages.length = 0;
+	assertEquals(await mq.getDepth(), {
+		queued: 2,
+		ready: 0,
+		delayed: 2
+	});
+	const handled = [];
+	const controller = new AbortController();
+	const listening = mq.listen((message) => {
+		handled.push(message);
+		if (handled.length >= 2) controller.abort();
+	}, { signal: controller.signal });
+	await waitFor(() => handled.length >= 2, 15e3);
+	await listening;
+	assertEquals(handled, ["first", "second"]);
+});
+test("InProcessMessageQueue.getDepth() excludes in-flight messages", async () => {
+	const mq = new InProcessMessageQueue();
+	let resolveHandler;
+	const controller = new AbortController();
+	const handled = new Promise((resolve) => {
+		resolveHandler = resolve;
+	});
+	let notifyStarted = () => {};
+	const handlerStarted = new Promise((resolve) => {
+		notifyStarted = resolve;
+	});
+	const listening = mq.listen(async () => {
+		notifyStarted();
+		await handled;
+		controller.abort();
+	}, { signal: controller.signal });
+	try {
+		await mq.enqueue("in-flight");
+		await handlerStarted;
+		assertEquals(await mq.getDepth(), {
+			queued: 0,
+			ready: 0,
+			delayed: 0
+		});
+	} finally {
+		resolveHandler?.();
+		controller.abort();
+		await listening;
+	}
+});
+test("InProcessMessageQueue delayed enqueue uses the internal ready path", async () => {
+	class RejectingReadyQueue extends InProcessMessageQueue {
+		enqueue(message, options) {
+			if (options?.delay == null) return Promise.reject(/* @__PURE__ */ new Error("ready enqueue should not be called"));
+			return super.enqueue(message, options);
+		}
+	}
+	const mq = new RejectingReadyQueue({ pollInterval: { milliseconds: 10 } });
+	const messages = [];
+	const controller = new AbortController();
+	const listening = mq.listen((message) => {
+		messages.push(message);
+		controller.abort();
+	}, { signal: controller.signal });
+	try {
+		await mq.enqueue("delayed", { delay: Temporal.Duration.from({ milliseconds: 10 }) });
+		await waitFor(() => messages.length > 0, 2e3);
+		assertEquals(messages, ["delayed"]);
+	} finally {
+		controller.abort();
+		await listening;
+	}
+});
+test("InProcessMessageQueue delayed enqueueMany uses the internal ready path", async () => {
+	class RejectingReadyQueue extends InProcessMessageQueue {
+		enqueueMany(messages, options) {
+			if (options?.delay == null) return Promise.reject(/* @__PURE__ */ new Error("ready enqueueMany should not be called"));
+			return super.enqueueMany(messages, options);
+		}
+	}
+	const mq = new RejectingReadyQueue({ pollInterval: { milliseconds: 10 } });
+	const messages = [];
+	const controller = new AbortController();
+	const listening = mq.listen((message) => {
+		messages.push(message);
+		if (messages.length >= 2) controller.abort();
+	}, { signal: controller.signal });
+	try {
+		await mq.enqueueMany(["first", "second"], { delay: Temporal.Duration.from({ milliseconds: 10 }) });
+		await waitFor(() => messages.length >= 2, 2e3);
+		assertEquals(messages, ["first", "second"]);
+	} finally {
+		controller.abort();
+		await listening;
+	}
+});
 test("InProcessMessageQueue orderingKey", async (t) => {
 	const mq = new InProcessMessageQueue();
 	const orderTracker = {
@@ -425,6 +582,10 @@ for (const mqName in queues) test({
 		await t.step("nativeRetrial property inheritance", () => {
 			assertEquals(workers.nativeRetrial, mq.nativeRetrial);
 		});
+		await t.step("getDepth() delegation", async () => {
+			if (mq.getDepth == null) assertEquals(workers.getDepth, void 0);
+			else assertEquals(await workers.getDepth?.(), await mq.getDepth());
+		});
 		const messages = [];
 		const controller = new AbortController();
 		const listening = workers.listen(async (message) => {

package/dist/federation/negotiation.test.mjs

@@ -1,10 +1,10 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
-import { t as acceptsJsonLd } from "../negotiation-SQvQgUqe.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { t as acceptsJsonLd } from "../negotiation-DDstyBvc.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/negotiation.test.ts
 test("acceptsJsonLd()", () => {

package/dist/federation/retry.test.mjs

@@ -1,9 +1,9 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { l as AssertionError, t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import { t as assertNotEquals } from "../assert_not_equals--wG9hV7u.mjs";
-import { t as createExponentialBackoffPolicy } from "../retry-bMXBL97A.mjs";
+import { l as AssertionError, t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { t as assertNotEquals } from "../assert_not_equals-DkVK8oqV.mjs";
+import { t as createExponentialBackoffPolicy } from "../retry-CXg_MBI-.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/retry.test.ts
 test("createExponentialBackoffPolicy()", () => {

package/dist/federation/router.test.mjs

@@ -1,16 +1,167 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as RouterError, t as Router } from "../router-CrMLXoOr.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assertThrows } from "../assert_throws-4NwKEy2q.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assertThrows } from "../assert_throws-BOkhLGYc.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { getLogger } from "@logtape/logtape";
+import { Router, RouterError, assertPath, isPath } from "@fedify/uri-template";
 import { test } from "@fedify/fixture";
+//#region src/federation/router.ts
+const logger = getLogger([
+	"fedify",
+	"federation",
+	"router",
+	"deprecated"
+]);
+let deprecationWarned = false;
+function warnDeprecated() {
+	if (deprecationWarned) return;
+	deprecationWarned = true;
+	logger.warn("The `Router` and `RouterError` classes from `@fedify/fedify` are deprecated.  Please use `Router` from `@fedify/uri-template` instead.");
+}
+/**
+* URL router and constructor based on URI Template
+* ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
+*
+* @deprecated Import `Router` from `@fedify/uri-template` instead.  This class
+*             remains only for compatibility with older Fedify code.  The
+*             `@fedify/uri-template` router is the replacement implementation
+*             and should be used directly in new code.
+*/
+var Router$1 = class Router$1 {
+	#router;
+	/**
+	* Create a new {@link Router}.
+	* @param options Options for the router.
+	* @deprecated Use `new Router(options)` from `@fedify/uri-template`
+	*             instead.
+	*/
+	constructor(options) {
+		this.#router = convertRouterError(() => new Router(options));
+	}
+	/**
+	* Whether to ignore trailing slashes when matching paths.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  This
+	*             accessor forwards to the underlying `@fedify/uri-template`
+	*             router so that post-construction mutation keeps working as
+	*             in older Fedify code.
+	*/
+	get trailingSlashInsensitive() {
+		return this.#router.trailingSlashInsensitive;
+	}
+	set trailingSlashInsensitive(value) {
+		this.#router.trailingSlashInsensitive = value;
+	}
+	/**
+	* Clones this router.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	clone() {
+		return convertRouterError(() => {
+			const clone = new Router$1();
+			clone.#router = this.#router.clone();
+			return clone;
+		});
+	}
+	/**
+	* Checks if a path name exists in the router.
+	* @param name The name of the path.
+	* @returns `true` if the path name exists, otherwise `false`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	has(name) {
+		return convertRouterError(() => this.#router.has(name));
+	}
+	/**
+	* Adds a new path rule to the router.
+	* @param template The path pattern.
+	* @param name The name of the path.
+	* @returns The names of the variables in the path pattern.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  In this
+	*             compatibility class, `add()` both registers the route and
+	*             returns the variables in the path pattern.  In
+	*             `@fedify/uri-template`, these two responsibilities are split:
+	*             `router.add(template, name)` registers the route and returns
+	*             `void`, while the pure static method
+	*             `Router.variables(template)` returns the variable names.  To
+	*             migrate, call `Router.variables(template)` when variables are
+	*             needed, then call `router.add(template, name)` to register the
+	*             route.
+	*/
+	add(template, name) {
+		return convertRouterError(() => {
+			assertPath(template);
+			this.#router.add(template, name);
+			return Router.variables(template);
+		});
+	}
+	/**
+	* Resolves a path name and values from a URL, if any match.
+	* @param url The URL to resolve.
+	* @returns The name of the path and its values, if any match.  Otherwise,
+	*          `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  Unlike the
+	*             stricter `@fedify/uri-template` router, this compatibility
+	*             method keeps the old Fedify 2.x contract of returning `null`
+	*             (rather than throwing) for inputs that are not router paths.
+	*/
+	route(url) {
+		return convertRouterError(() => {
+			if (!isPath(url)) return null;
+			return this.#router.route(url);
+		});
+	}
+	/**
+	* Constructs a URL/path from a path name and values.
+	* @param name The name of the path.
+	* @param values The values to expand the path with.
+	* @returns The URL/path, if the name exists.  Otherwise, `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	build(name, values) {
+		return convertRouterError(() => this.#router.build(name, values));
+	}
+};
+/**
+* An error thrown by the {@link Router}.
+* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+*/
+var RouterError$1 = class extends RouterError {
+	/**
+	* Treats every `RouterError` from `@fedify/uri-template` as an instance of
+	* this deprecated class.
+	*
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	static [Symbol.hasInstance](instance) {
+		return instance instanceof RouterError;
+	}
+	/**
+	* Create a new {@link RouterError}.
+	* @param message The error message.
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	constructor(message) {
+		super(message);
+		warnDeprecated();
+	}
+};
+function convertRouterError(func) {
+	try {
+		warnDeprecated();
+		return func();
+	} catch (error) {
+		if (error instanceof RouterError) throw new RouterError$1(error.message);
+		throw error;
+	}
+}
+//#endregion
 //#region src/federation/router.test.ts
 function setUp(options = {}) {
-	const router = new Router(options);
+	const router = new Router$1(options);
 	router.add("/users/{name}", "user");
 	router.add("/users/{name}/posts/{postId}" + (options.trailingSlashInsensitive ? "/" : ""), "post");
 	return router;
@@ -29,11 +180,11 @@ test("Router.clone()", () => {
 	assertEquals(original.route("/users/alice/friends"), null);
 });
 test("Router.add()", () => {
-	const router = new Router();
+	const router = new Router$1();
 	assertEquals(router.add("/users", "users"), /* @__PURE__ */ new Set());
 	assertEquals(router.add("/users/{name}", "user"), new Set(["name"]));
 	assertEquals(router.add("/users/{name}/posts/{postId}", "post"), new Set(["name", "postId"]));
-	assertThrows(() => router.add("foo", "name"), RouterError);
+	assertThrows(() => router.add("foo", "name"), RouterError$1);
 });
 test("Router.route()", () => {
 	let router = setUp();
@@ -80,6 +231,21 @@ test("Router.route()", () => {
 		}
 	});
 });
+test("Router.trailingSlashInsensitive (post-construction mutation)", () => {
+	const router = setUp();
+	assertFalse(router.trailingSlashInsensitive);
+	assertEquals(router.route("/users/bob/"), null);
+	router.trailingSlashInsensitive = true;
+	assert(router.trailingSlashInsensitive);
+	assertEquals(router.route("/users/bob/"), {
+		name: "user",
+		template: "/users/{name}",
+		values: { name: "bob" }
+	});
+	router.trailingSlashInsensitive = false;
+	assertFalse(router.trailingSlashInsensitive);
+	assertEquals(router.route("/users/bob/"), null);
+});
 test("Router.build()", () => {
 	const router = setUp();
 	assertEquals(router.build("user", { name: "alice" }), "/users/alice");
@@ -88,5 +254,20 @@ test("Router.build()", () => {
 		postId: "123"
 	}), "/users/alice/posts/123");
 });
+test("Router.route() returns null for non-path inputs", () => {
+	const router = setUp();
+	assertEquals(router.route("https://example.com/users/alice"), null);
+	assertEquals(router.route("users/alice"), null);
+	assertEquals(router.route("not a path"), null);
+	assertEquals(router.route("/unknown"), null);
+});
+test("Compatibility between RouterErrors", () => {
+	const newError = new RouterError("boom");
+	assert(newError instanceof RouterError);
+	assert(newError instanceof RouterError$1);
+	const previousError = new RouterError$1("boom");
+	assert(previousError instanceof RouterError$1);
+	assert(previousError instanceof RouterError);
+});
 //#endregion
 export {};