@fedify/fedify 1.6.1-dev.869 → 1.6.1-dev.873

package/dist/federation/mq.test.js

@@ -1,14 +1,161 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { InProcessMessageQueue, ParallelMessageQueue } from "./mq.js";
-import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
-import { test } from "../testing/mod.js";
-import { assertGreaterOrEqual } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater_or_equal.js";
-import { assertGreater } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater.js";
+import { assertEquals } from "../assert_equals-ClvzlhZu.js";
+import "../assert-Dv75vaGI.js";
+import "../assert_instance_of--9UCVKsi.js";
+import { test } from "../testing-jcGLO9Lp.js";
+import { assertGreater, assertGreaterOrEqual } from "../std__assert-CaBUULmX.js";
+import "../assert_rejects-FOHCtlD2.js";
+import "../assert_is_error-D162gXcM.js";
+import "../assert_not_equals-Cyf5m9Ke.js";
+import "../assert_throws-CRfQJvVx.js";
 import { delay } from "@es-toolkit/es-toolkit";
 
+//#region federation/mq.ts
+/**
+* A message queue that processes messages in the same process.
+* Do not use this in production as it does neither persist messages nor
+* distribute them across multiple processes.
+*
+* @since 0.5.0
+*/
+var InProcessMessageQueue = class {
+	#messages;
+	#monitors;
+	#pollIntervalMs;
+	/**
+	* Constructs a new {@link InProcessMessageQueue} with the given options.
+	* @param options Additional options for the in-process message queue.
+	*/
+	constructor(options = {}) {
+		this.#messages = [];
+		this.#monitors = {};
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+	}
+	enqueue(message, options) {
+		const delay$1 = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay$1 > 0) {
+			setTimeout(() => this.enqueue(message, {
+				...options,
+				delay: void 0
+			}), delay$1);
+			return Promise.resolve();
+		}
+		this.#messages.push(message);
+		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
+		return Promise.resolve();
+	}
+	enqueueMany(messages, options) {
+		if (messages.length === 0) return Promise.resolve();
+		const delay$1 = options?.delay == null ? 0 : Math.max(options.delay.total("millisecond"), 0);
+		if (delay$1 > 0) {
+			setTimeout(() => this.enqueueMany(messages, {
+				...options,
+				delay: void 0
+			}), delay$1);
+			return Promise.resolve();
+		}
+		this.#messages.push(...messages);
+		for (const monitorId in this.#monitors) this.#monitors[monitorId]();
+		return Promise.resolve();
+	}
+	async listen(handler, options = {}) {
+		const signal = options.signal;
+		while (signal == null || !signal.aborted) {
+			while (this.#messages.length > 0) {
+				const message = this.#messages.shift();
+				await handler(message);
+			}
+			await this.#wait(this.#pollIntervalMs, signal);
+		}
+	}
+	#wait(ms, signal) {
+		let timer = null;
+		return Promise.any([new Promise((resolve) => {
+			signal?.addEventListener("abort", () => {
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			}, { once: true });
+			const monitorId = crypto.randomUUID();
+			this.#monitors[monitorId] = () => {
+				delete this.#monitors[monitorId];
+				if (timer != null) clearTimeout(timer);
+				resolve();
+			};
+		}), new Promise((resolve) => timer = setTimeout(resolve, ms))]);
+	}
+};
+/**
+* A message queue that processes messages in parallel.  It takes another
+* {@link MessageQueue}, and processes messages in parallel up to a certain
+* number of workers.
+*
+* Actually, it's rather a decorator than a queue itself.
+*
+* Note that the workers do not run in truly parallel, in the sense that they
+* are not running in separate threads or processes.  They are running in the
+* same process, but are scheduled to run in parallel.  Hence, this is useful
+* for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
+* workloads.
+*
+* @since 1.0.0
+*/
+var ParallelMessageQueue = class ParallelMessageQueue {
+	queue;
+	workers;
+	/**
+	* Constructs a new {@link ParallelMessageQueue} with the given queue and
+	* number of workers.
+	* @param queue The message queue to use under the hood.  Note that
+	*              {@link ParallelMessageQueue} cannot be nested.
+	* @param workers The number of workers to process messages in parallel.
+	* @throws {TypeError} If the given queue is an instance of
+	*                     {@link ParallelMessageQueue}.
+	*/
+	constructor(queue, workers) {
+		if (queue instanceof ParallelMessageQueue) throw new TypeError("Cannot nest ParallelMessageQueue.");
+		this.queue = queue;
+		this.workers = workers;
+	}
+	enqueue(message, options) {
+		return this.queue.enqueue(message, options);
+	}
+	async enqueueMany(messages, options) {
+		if (this.queue.enqueueMany == null) {
+			const results = await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)));
+			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to enqueue messages.");
+			else if (errors.length === 1) throw errors[0];
+			return;
+		}
+		await this.queue.enqueueMany(messages, options);
+	}
+	listen(handler, options = {}) {
+		const workers = new Map();
+		return this.queue.listen(async (message) => {
+			while (workers.size >= this.workers) {
+				const consumedId = await Promise.any(workers.values());
+				workers.delete(consumedId);
+			}
+			const workerId = crypto.randomUUID();
+			const promise = this.#work(workerId, handler, message);
+			workers.set(workerId, promise);
+		}, options);
+	}
+	async #work(workerId, handler, message) {
+		await this.#sleep(0);
+		await handler(message);
+		return workerId;
+	}
+	#sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
 //#region federation/mq.test.ts
 test("InProcessMessageQueue", async (t) => {
 	const mq = new InProcessMessageQueue();
@@ -64,7 +211,7 @@ test("InProcessMessageQueue", async (t) => {
 });
 const queues = { InProcessMessageQueue: () => Promise.resolve(new InProcessMessageQueue()) };
 if ("Deno" in globalThis && "openKv" in globalThis.Deno && typeof globalThis.Deno.openKv === "function") {
-	const { DenoKvMessageQueue } = await import("../x/denokv.js");
+	const { DenoKvMessageQueue } = await import("../denokv-iB_ggPGm.js");
 	queues.DenoKvMessageQueue = async () => new DenoKvMessageQueue(await globalThis.Deno.openKv(":memory:"));
 }
 for (const mqName in queues) test({

package/dist/federation/retry.test.d.ts

@@ -1,2 +1,3 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+globalThis.addEventListener = () => {};

package/dist/federation/retry.test.js

@@ -1,12 +1,12 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { createExponentialBackoffPolicy } from "./retry.js";
-import { AssertionError } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assertion_error.js";
-import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
-import { test } from "../testing/mod.js";
-import { assertNotEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_not_equals.js";
+import { AssertionError, assertEquals } from "../assert_equals-ClvzlhZu.js";
+import { createExponentialBackoffPolicy } from "../retry-BiIhZWgD.js";
+import { test } from "../testing-jcGLO9Lp.js";
+import { assertNotEquals } from "../assert_not_equals-Cyf5m9Ke.js";
 
 //#region federation/retry.test.ts
 test("createExponentialBackoffPolicy()", () => {

package/dist/federation/router.test.d.ts

@@ -1,2 +1,3 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+globalThis.addEventListener = () => {};

package/dist/federation/router.test.js

@@ -1,13 +1,18 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { Router, RouterError } from "./router.js";
-import { assert } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js";
-import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
-import { test } from "../testing/mod.js";
-import { assertFalse } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js";
-import { assertThrows } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js";
+import { assertEquals } from "../assert_equals-ClvzlhZu.js";
+import { assert } from "../assert-Dv75vaGI.js";
+import "../assert_instance_of--9UCVKsi.js";
+import { Router, RouterError } from "../router-D_aVZZUc.js";
+import { test } from "../testing-jcGLO9Lp.js";
+import "../std__assert-CaBUULmX.js";
+import { assertFalse } from "../assert_rejects-FOHCtlD2.js";
+import "../assert_is_error-D162gXcM.js";
+import "../assert_not_equals-Cyf5m9Ke.js";
+import { assertThrows } from "../assert_throws-CRfQJvVx.js";
 
 //#region federation/router.test.ts
 function setUp(options = {}) {

package/dist/federation/send.test.d.ts

@@ -1,2 +1,3 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+globalThis.addEventListener = () => {};

package/dist/federation/send.test.js

@@ -1,20 +1,32 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { Activity, Application, Endpoints, Group, Person, Service } from "../vocab/vocab.js";
-import { verifyRequest } from "../sig/http.js";
-import { doesActorOwnKey } from "../sig/owner.js";
-import { extractInboxes, sendActivity } from "./send.js";
-import { assert } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js";
-import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
-import { test } from "../testing/mod.js";
-import { assertFalse } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js";
-import { assertNotEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_not_equals.js";
-import { assertRejects } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js";
-import { mockDocumentLoader } from "../testing/docloader.js";
-import { ed25519Multikey, ed25519PrivateKey, rsaPrivateKey2, rsaPublicKey2 } from "../testing/keys.js";
-import { esm_default } from "../node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/index.js";
+import { assertEquals } from "../assert_equals-ClvzlhZu.js";
+import { assert } from "../assert-Dv75vaGI.js";
+import "../assert_instance_of--9UCVKsi.js";
+import "../docloader-CMlE_DQr.js";
+import "../url-kTAI6_KP.js";
+import "../multibase-DeCHcK8L.js";
+import { Activity, Application, Endpoints, Group, Person, Service } from "../vocab-Dwop3xOF.js";
+import "../langstr-DbWheeIS.js";
+import "../lookup-BDLFt_tc.js";
+import "../type-D2s5lmbZ.js";
+import "../actor-DhyIYEBl.js";
+import "../key-CkoTQfVN.js";
+import { verifyRequest } from "../http-CFQSpmJT.js";
+import { doesActorOwnKey } from "../owner-2Gouxs6Y.js";
+import { extractInboxes, sendActivity } from "../send-BFMnzlj7.js";
+import { test } from "../testing-jcGLO9Lp.js";
+import "../std__assert-CaBUULmX.js";
+import { assertFalse, assertRejects } from "../assert_rejects-FOHCtlD2.js";
+import "../assert_is_error-D162gXcM.js";
+import { assertNotEquals } from "../assert_not_equals-Cyf5m9Ke.js";
+import "../assert_throws-CRfQJvVx.js";
+import { mockDocumentLoader } from "../docloader-09nVWLAZ.js";
+import { ed25519Multikey, ed25519PrivateKey, rsaPrivateKey2, rsaPublicKey2 } from "../keys-DxEMe-K1.js";
+import { esm_default } from "../esm-BxIKwi-M.js";
 
 //#region federation/send.test.ts
 test("extractInboxes()", () => {

package/dist/{federation/mq.js → federation-Bmj7soSg.js}

@@ -2,6 +2,52 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
+//#region federation/kv.ts
+/**
+* A key-value store that stores values in memory.
+* Do not use this in production as it does not persist values.
+*
+* @since 0.5.0
+*/
+var MemoryKvStore = class {
+	#values = {};
+	#encodeKey(key) {
+		return JSON.stringify(key);
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	get(key) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		if (entry == null) return Promise.resolve(void 0);
+		const [value, expiration] = entry;
+		if (expiration != null && Temporal.Now.instant().until(expiration).sign < 0) {
+			delete this.#values[encodedKey];
+			return Promise.resolve(void 0);
+		}
+		return Promise.resolve(value);
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	set(key, value, options) {
+		const encodedKey = this.#encodeKey(key);
+		const expiration = options?.ttl == null ? null : Temporal.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [value, expiration];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		const encodedKey = this.#encodeKey(key);
+		delete this.#values[encodedKey];
+		return Promise.resolve();
+	}
+};
+
+//#endregion
 //#region federation/mq.ts
 /**
 * A message queue that processes messages in the same process.
@@ -144,4 +190,4 @@ var ParallelMessageQueue = class ParallelMessageQueue {
 };
 
 //#endregion
-export { InProcessMessageQueue, ParallelMessageQueue };
+export { InProcessMessageQueue, MemoryKvStore, ParallelMessageQueue };

package/dist/{node_modules/.pnpm/@jsr_hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/router.js → hongminhee__deno-mock-fetch-DJKLj_H-.js}

@@ -1,6 +1,7 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
 //#region node_modules/.pnpm/@jsr+hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/router.js
 /**
@@ -90,4 +91,98 @@ const methodRegex = new RegExp(`(?<=^(?:${METHODS.join("|")}))@`);
 }
 
 //#endregion
-export { router };
+//#region node_modules/.pnpm/@jsr+hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/mod.js
+var UnhandledRouteError = class extends Error {
+	routes;
+	request;
+	constructor(init) {
+		const { request, routes } = init;
+		const method = request.method;
+		const reqPath = new URL(request.url).pathname;
+		const routesNumber = Object.entries(routes).length;
+		const routePlural = routesNumber === 1 ? "route has a handler" : "routes have handlers";
+		super(`${method} ${reqPath} (${routesNumber} ${routePlural})`);
+		this.name = this.constructor.name;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		this.routes = routes;
+		this.request = request;
+	}
+};
+/**
+* Get a set of functions that do not share any state with the globals.
+*
+* The returned object can be destructured.
+*
+* ```
+* const { fetch, mock, remove, reset } = sandbox()
+* ```
+*/ function sandbox() {
+	const routeStore = new Map();
+	async function fetch(input, init) {
+		if (input instanceof URL) input = input.toString();
+		const req = new Request(input, init);
+		const routes = Object.fromEntries(routeStore.entries());
+		return await router(routes, (request) => {
+			throw new UnhandledRouteError({
+				request,
+				routes
+			});
+		}, (_, error) => {
+			throw error;
+		})(req);
+	}
+	function mock$1(route, handler) {
+		routeStore.set(route, handler);
+	}
+	function remove$1(route) {
+		routeStore.delete(route);
+	}
+	function reset$1() {
+		routeStore.clear();
+	}
+	return {
+		reset: reset$1,
+		mock: mock$1,
+		remove: remove$1,
+		fetch
+	};
+}
+const globalMockFetch = sandbox();
+/** This is the function that replaces `fetch` when you call `install()`. */ const mockedFetch = globalMockFetch.fetch;
+/**
+* Mock a new route, or override an existing handler.
+*
+* The route uses URLPattern syntax, with the additional extension of
+* (optional) method routing by prefixing with the method,
+* eg. `"POST@/user/:id"`.
+*
+* The handler function may be asynchronous.
+*
+* ```
+* mock("GET@/users/:id", async (_req, params) => {
+*   const id = parseInt(params["id"]);
+*   const data = await magicallyGetMyUserData(id);
+*   return new Response(JSON.stringify(data));
+* })
+* ```
+*/ const mock = globalMockFetch.mock;
+/** Remove an existing route handler. */ const remove = globalMockFetch.remove;
+/** Remove all existing route handlers. */ const reset = globalMockFetch.reset;
+const originalFetch = globalThis.fetch;
+/**
+* Replace `globalThis.fetch` with `mockedFetch` (or another function that
+* matches the `fetch` signature)
+*
+* To restore the original `globalThis.fetch`, call `uninstall()`.
+*/ const install = (replacement) => {
+	globalThis.fetch = replacement ?? mockedFetch;
+};
+/**
+* Restore `globalThis.fetch` to what it was before this library was imported.
+*/ const uninstall = () => {
+	globalThis.fetch = originalFetch;
+	reset();
+};
+
+//#endregion
+export { install, mock, uninstall };