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

package/dist/mq-03vS-C9P.mjs

@@ -1,276 +0,0 @@
-import { Temporal } from "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-//#region src/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;
-	#delayedMessages;
-	/**
-	* Tracks which ordering keys are currently being processed to ensure
-	* sequential processing for messages with the same key.
-	*/
-	#processingKeys;
-	/**
-	* In-process message queue does not provide native retry mechanisms.
-	* @since 1.7.0
-	*/
-	nativeRetrial = false;
-	/**
-	* In-process message queue does not deduplicate messages natively.
-	* @since 2.4.0
-	*/
-	nativeDeduplication = false;
-	/**
-	* 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");
-		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) {
-			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]();
-	}
-	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) {
-			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
-		});
-		this.#notifyMonitors();
-	}
-	async listen(handler, options = {}) {
-		const signal = options.signal;
-		while (signal == null || !signal.aborted) {
-			const idx = this.#messages.findIndex((m) => m.orderingKey == null || !this.#processingKeys.has(m.orderingKey));
-			if (idx >= 0) {
-				const { message, orderingKey } = this.#messages.splice(idx, 1)[0];
-				if (orderingKey != null) this.#processingKeys.add(orderingKey);
-				try {
-					await handler(message);
-				} finally {
-					if (orderingKey != null) this.#processingKeys.delete(orderingKey);
-				}
-			} else if (this.#messages.length === 0) await this.#wait(this.#pollIntervalMs, signal);
-			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) => {
-			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.
-*
-* When using `ParallelMessageQueue`, the ordering guarantee is preserved
-* *only if* the underlying queue implementation delivers messages in a wrapper
-* format that includes the `__fedify_ordering_key__` property.  Currently,
-* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
-* For other queue implementations (e.g., `InProcessMessageQueue`,
-* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
-* `AmqpMessageQueue`), the ordering key cannot be detected by
-* `ParallelMessageQueue`, so ordering guarantees are handled by those
-* implementations directly rather than at the `ParallelMessageQueue` level.
-*
-* Messages with the same ordering key will never be processed concurrently
-* by different workers, ensuring sequential processing within each key.
-* Messages with different ordering keys (or no ordering key) can still be
-* processed in parallel.
-*
-* @since 1.0.0
-*/
-var ParallelMessageQueue = class ParallelMessageQueue {
-	queue;
-	workers;
-	/**
-	* Inherits the native retry capability from the wrapped queue.
-	* @since 1.7.0
-	*/
-	nativeRetrial;
-	/**
-	* Inherits the native deduplication capability from the wrapped queue.
-	* @since 2.4.0
-	*/
-	nativeDeduplication;
-	getDepth;
-	/**
-	* Tracks which ordering keys are currently being processed to ensure
-	* sequential processing for messages with the same key.
-	*/
-	#processingKeys = /* @__PURE__ */ new Set();
-	/**
-	* Pending messages waiting for their ordering key to become available.
-	*/
-	#pendingMessages = [];
-	/**
-	* 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;
-		this.nativeRetrial = queue.nativeRetrial;
-		this.nativeDeduplication = queue.nativeDeduplication;
-		if (queue.getDepth != null) this.getDepth = () => queue.getDepth();
-	}
-	enqueue(message, options) {
-		return this.queue.enqueue(message, options);
-	}
-	async enqueueMany(messages, options) {
-		if (this.queue.enqueueMany == null) {
-			if (messages.length === 1) {
-				await this.queue.enqueue(messages[0], options);
-				return;
-			}
-			if (options?.deduplicationKey != null) throw new TypeError("Cannot enqueue a batch with a deduplicationKey: the wrapped queue does not implement enqueueMany, so ParallelMessageQueue would have to fan out to individual enqueue() calls that cannot share one deduplicationKey atomically.  Wrap a queue that implements enqueueMany instead.");
-			const errors = (await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)))).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);
-	}
-	/**
-	* Extracts ordering key from a message if present.
-	*
-	* This method only works for queue implementations that deliver messages
-	* in the wrapper format with `__fedify_ordering_key__` property.  Currently,
-	* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
-	*
-	* For other queue implementations (`InProcessMessageQueue`,
-	* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
-	* `AmqpMessageQueue`), messages are delivered as raw payloads without the
-	* wrapper, so the ordering key cannot be detected here.  Those
-	* implementations handle ordering guarantees internally.
-	*/
-	#extractOrderingKey(message) {
-		if (message != null && typeof message === "object") {
-			if ("__fedify_ordering_key__" in message) return message.__fedify_ordering_key__;
-		}
-	}
-	listen(handler, options = {}) {
-		const workers = /* @__PURE__ */ 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 orderingKey = this.#extractOrderingKey(message);
-			if (orderingKey != null && this.#processingKeys.has(orderingKey)) await new Promise((resolve) => {
-				this.#pendingMessages.push({
-					message,
-					orderingKey,
-					resolve
-				});
-			});
-			if (orderingKey != null) this.#processingKeys.add(orderingKey);
-			const promise = this.#work(workerId, handler, message, orderingKey);
-			workers.set(workerId, promise);
-		}, options);
-	}
-	async #work(workerId, handler, message, orderingKey) {
-		await this.#sleep(0);
-		try {
-			await handler(message);
-		} finally {
-			if (orderingKey != null) {
-				this.#processingKeys.delete(orderingKey);
-				const pendingIdx = this.#pendingMessages.findIndex((p) => p.orderingKey === orderingKey);
-				if (pendingIdx >= 0) this.#pendingMessages.splice(pendingIdx, 1)[0].resolve();
-			}
-		}
-		return workerId;
-	}
-	#sleep(ms) {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-};
-//#endregion
-export { ParallelMessageQueue as n, InProcessMessageQueue as t };

package/dist/testing-Dy-WhqpN.mjs

@@ -1,77 +0,0 @@
-import "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { i as mockDocumentLoader } from "./context-BBRTgkrs.mjs";
-import { t as MemoryKvStore } from "./kv-CIvR3Non.mjs";
-import { Note } from "@fedify/vocab";
-//#region src/testing/tasks.ts
-/**
-* Test-only utilities shared by the task suites: the schema factory and stock
-* schemas, the base federation options, and the recording {@link MockQueue}.
-*
-* These helpers live beside the suites that use them rather than in a shared
-* package because {@link MockQueue} needs the package-internal
-* {@link TaskMessage} type, and *deno.json*'s `publish.exclude` keeps this
-* module out of the published sources.
-*
-* @module
-*/
-/** Federation options (sans `queue`) shared by the task suites. */
-const baseOptions = {
-	kv: new MemoryKvStore(),
-	documentLoaderFactory: () => mockDocumentLoader,
-	contextLoaderFactory: () => mockDocumentLoader,
-	manuallyStartQueue: true
-};
-/**
-* Builds a minimal [Standard Schema](https://standardschema.dev/) from a type
-* guard, for use as a task payload schema in tests.
-*/
-const makeSchema = (check) => ({ "~standard": {
-	version: 1,
-	vendor: "fedify-test",
-	validate: (value) => check(value) ? { value } : { issues: [{ message: "Invalid task data." }] }
-} });
-const stringSchema = makeSchema((d) => typeof d === "string");
-const numberSchema = makeSchema((d) => typeof d === "number");
-const envelopeSchema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
-/**
-* An in-memory {@link MessageQueue} that records task enqueues for assertions
-* instead of delivering anything.  Its {@link listen} resolves only when the
-* abort signal fires.
-*/
-var MockQueue = class {
-	nativeRetrial;
-	nativeDeduplication;
-	enqueued = [];
-	enqueuedMany = [];
-	listenCount = 0;
-	enqueueMany;
-	constructor(options = {}) {
-		this.nativeRetrial = options.nativeRetrial ?? false;
-		this.nativeDeduplication = options.nativeDeduplication ?? false;
-		if (options.supportsEnqueueMany) this.enqueueMany = (messages, opts) => {
-			this.enqueuedMany.push({
-				messages,
-				options: opts
-			});
-			return Promise.resolve();
-		};
-	}
-	enqueue(message, options) {
-		this.enqueued.push({
-			message,
-			options
-		});
-		return Promise.resolve();
-	}
-	listen(_handler, options) {
-		this.listenCount++;
-		if (options?.signal?.aborted) return Promise.resolve();
-		return new Promise((resolve) => {
-			options?.signal?.addEventListener("abort", () => resolve(), { once: true });
-		});
-	}
-};
-//#endregion
-export { numberSchema as a, makeSchema as i, baseOptions as n, stringSchema as o, envelopeSchema as r, MockQueue as t };