@fedify/mysql 2.1.0-dev.0

package/dist/mq.d.cts

@@ -0,0 +1,126 @@
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { Pool } from "mysql2/promise";
+
+//#region src/mq.d.ts
+/**
+* Options for the MySQL message queue.
+*
+* @since 2.1.0
+*/
+interface MysqlMessageQueueOptions {
+  /**
+  * The table name to use for the message queue.
+  * `"fedify_mq"` by default.
+  * @default `"fedify_mq"`
+  * @since 2.1.0
+  */
+  readonly tableName?: string;
+  /**
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  * @since 2.1.0
+  */
+  readonly initialized?: boolean;
+  /**
+  * The poll interval for the message queue.  1 second by default.
+  *
+  * Since MySQL/MariaDB has no `LISTEN`/`NOTIFY` equivalent, messages are
+  * discovered using periodic polling.  A shorter interval reduces message
+  * delivery latency at the cost of additional database load.
+  *
+  * @default `{ seconds: 1 }`
+  * @since 2.1.0
+  */
+  readonly pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  /**
+  * The maximum time to wait for a message handler to complete before
+  * the queue moves on.  This is a *soft* timeout: when a handler exceeds
+  * the limit, the queue stops waiting and logs a timeout error, but it
+  * cannot cancel the handler itself — the handler's promise continues
+  * running in the background.  In the ordered-key path the advisory lock
+  * is always released in a `finally` block, so a timed-out handler will
+  * not permanently block the same ordering key.  However, concurrent
+  * side-effects from the still-running handler may interleave with the
+  * next handler for the same key; callers should be aware of this.
+  *
+  * Set to zero to disable the timeout (not recommended in production).
+  *
+  * 60 seconds by default.
+  * @default `{ seconds: 60 }`
+  * @since 2.1.0
+  */
+  readonly handlerTimeout?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+* A message queue that uses MySQL or MariaDB as the underlying storage.
+* Messages are delivered via periodic polling, since MySQL and MariaDB do not
+* provide a `LISTEN`/`NOTIFY` equivalent.
+*
+* Concurrent workers are supported via `SELECT … FOR UPDATE SKIP LOCKED`
+* (requires MySQL 8.0+ or MariaDB 10.6+) and MySQL advisory locks
+* (`GET_LOCK`/`RELEASE_LOCK`) for ordering-key serialization.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { MysqlKvStore, MysqlMessageQueue } from "@fedify/mysql";
+* import mysql from "mysql2/promise";
+*
+* const pool = mysql.createPool("mysql://user:pass@localhost/db");
+*
+* const federation = createFederation({
+*   kv: new MysqlKvStore(pool),
+*   queue: new MysqlMessageQueue(pool),
+* });
+* ```
+*
+* @since 2.1.0
+*/
+declare class MysqlMessageQueue implements MessageQueue {
+  #private;
+  /**
+  * MySQL/MariaDB does not provide native retry mechanisms; Fedify handles
+  * retries itself.
+  * @since 2.1.0
+  */
+  readonly nativeRetrial: false;
+  /**
+  * Creates a new MySQL message queue.
+  * @param pool The MySQL connection pool to use.
+  * @param options Options for the message queue.
+  * @since 2.1.0
+  */
+  constructor(pool: Pool, options?: MysqlMessageQueueOptions);
+  /**
+  * {@inheritDoc MessageQueue.enqueue}
+  * @since 2.1.0
+  */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+  * {@inheritDoc MessageQueue.enqueueMany}
+  * @since 2.1.0
+  */
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+  * {@inheritDoc MessageQueue.listen}
+  * @since 2.1.0
+  */
+  listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+  * Initializes the message queue table if it does not already exist.
+  * Concurrent calls are coalesced — only one initialization runs at a time.
+  *
+  * @since 2.1.0
+  */
+  initialize(): Promise<void>;
+  /**
+  * Drops the message queue table if it exists.  Resets the initialized flag
+  * so that {@link MysqlMessageQueue.initialize} can recreate the table on
+  * the next call.
+  *
+  * @since 2.1.0
+  */
+  drop(): Promise<void>;
+}
+//#endregion
+export { MysqlMessageQueue, MysqlMessageQueueOptions };

package/dist/mq.d.ts

@@ -0,0 +1,127 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { Pool } from "mysql2/promise";
+
+//#region src/mq.d.ts
+/**
+* Options for the MySQL message queue.
+*
+* @since 2.1.0
+*/
+interface MysqlMessageQueueOptions {
+  /**
+  * The table name to use for the message queue.
+  * `"fedify_mq"` by default.
+  * @default `"fedify_mq"`
+  * @since 2.1.0
+  */
+  readonly tableName?: string;
+  /**
+  * Whether the table has been initialized.  `false` by default.
+  * @default `false`
+  * @since 2.1.0
+  */
+  readonly initialized?: boolean;
+  /**
+  * The poll interval for the message queue.  1 second by default.
+  *
+  * Since MySQL/MariaDB has no `LISTEN`/`NOTIFY` equivalent, messages are
+  * discovered using periodic polling.  A shorter interval reduces message
+  * delivery latency at the cost of additional database load.
+  *
+  * @default `{ seconds: 1 }`
+  * @since 2.1.0
+  */
+  readonly pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  /**
+  * The maximum time to wait for a message handler to complete before
+  * the queue moves on.  This is a *soft* timeout: when a handler exceeds
+  * the limit, the queue stops waiting and logs a timeout error, but it
+  * cannot cancel the handler itself — the handler's promise continues
+  * running in the background.  In the ordered-key path the advisory lock
+  * is always released in a `finally` block, so a timed-out handler will
+  * not permanently block the same ordering key.  However, concurrent
+  * side-effects from the still-running handler may interleave with the
+  * next handler for the same key; callers should be aware of this.
+  *
+  * Set to zero to disable the timeout (not recommended in production).
+  *
+  * 60 seconds by default.
+  * @default `{ seconds: 60 }`
+  * @since 2.1.0
+  */
+  readonly handlerTimeout?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+* A message queue that uses MySQL or MariaDB as the underlying storage.
+* Messages are delivered via periodic polling, since MySQL and MariaDB do not
+* provide a `LISTEN`/`NOTIFY` equivalent.
+*
+* Concurrent workers are supported via `SELECT … FOR UPDATE SKIP LOCKED`
+* (requires MySQL 8.0+ or MariaDB 10.6+) and MySQL advisory locks
+* (`GET_LOCK`/`RELEASE_LOCK`) for ordering-key serialization.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { MysqlKvStore, MysqlMessageQueue } from "@fedify/mysql";
+* import mysql from "mysql2/promise";
+*
+* const pool = mysql.createPool("mysql://user:pass@localhost/db");
+*
+* const federation = createFederation({
+*   kv: new MysqlKvStore(pool),
+*   queue: new MysqlMessageQueue(pool),
+* });
+* ```
+*
+* @since 2.1.0
+*/
+declare class MysqlMessageQueue implements MessageQueue {
+  #private;
+  /**
+  * MySQL/MariaDB does not provide native retry mechanisms; Fedify handles
+  * retries itself.
+  * @since 2.1.0
+  */
+  readonly nativeRetrial: false;
+  /**
+  * Creates a new MySQL message queue.
+  * @param pool The MySQL connection pool to use.
+  * @param options Options for the message queue.
+  * @since 2.1.0
+  */
+  constructor(pool: Pool, options?: MysqlMessageQueueOptions);
+  /**
+  * {@inheritDoc MessageQueue.enqueue}
+  * @since 2.1.0
+  */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+  * {@inheritDoc MessageQueue.enqueueMany}
+  * @since 2.1.0
+  */
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+  * {@inheritDoc MessageQueue.listen}
+  * @since 2.1.0
+  */
+  listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+  * Initializes the message queue table if it does not already exist.
+  * Concurrent calls are coalesced — only one initialization runs at a time.
+  *
+  * @since 2.1.0
+  */
+  initialize(): Promise<void>;
+  /**
+  * Drops the message queue table if it exists.  Resets the initialized flag
+  * so that {@link MysqlMessageQueue.initialize} can recreate the table on
+  * the next call.
+  *
+  * @since 2.1.0
+  */
+  drop(): Promise<void>;
+}
+//#endregion
+export { MysqlMessageQueue, MysqlMessageQueueOptions };

package/dist/mq.js

@@ -0,0 +1,394 @@
+
+        import { Temporal } from "@js-temporal/polyfill";
+      
+import { getLogger } from "@logtape/logtape";
+
+//#region src/mq.ts
+const logger = getLogger([
+	"fedify",
+	"mysql",
+	"mq"
+]);
+const INITIALIZE_MAX_ATTEMPTS = 5;
+const INITIALIZE_BACKOFF_MS = 10;
+const ORDERING_KEY_CANDIDATE_LIMIT = 10;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withTimeout(result, timeoutMs) {
+	const resolved = Promise.resolve(result);
+	if (timeoutMs <= 0) return resolved;
+	let timer;
+	const timeoutPromise = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Message handler timed out after ${timeoutMs}ms`)), timeoutMs);
+	});
+	return Promise.race([resolved, timeoutPromise]).finally(() => clearTimeout(timer));
+}
+/**
+* Computes a MySQL advisory lock name for the given table name and ordering
+* key.  The result is always at most 64 characters, which is well within
+* MySQL's advisory lock name length limit.
+*/
+function getMysqlLockName(tableName, orderingKey) {
+	const raw = `${tableName}:${orderingKey}`;
+	if (raw.length <= 64) return raw;
+	let h1 = 0;
+	let h2 = 5381;
+	for (let i = 0; i < raw.length; i++) {
+		const c = raw.charCodeAt(i);
+		h1 = (h1 << 5) - h1 + c | 0;
+		h2 = (h2 << 5) + h2 + c | 0;
+	}
+	return `fdy:${(h1 >>> 0).toString(16).padStart(8, "0")}${(h2 >>> 0).toString(16).padStart(8, "0")}`;
+}
+/**
+* A message queue that uses MySQL or MariaDB as the underlying storage.
+* Messages are delivered via periodic polling, since MySQL and MariaDB do not
+* provide a `LISTEN`/`NOTIFY` equivalent.
+*
+* Concurrent workers are supported via `SELECT … FOR UPDATE SKIP LOCKED`
+* (requires MySQL 8.0+ or MariaDB 10.6+) and MySQL advisory locks
+* (`GET_LOCK`/`RELEASE_LOCK`) for ordering-key serialization.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { MysqlKvStore, MysqlMessageQueue } from "@fedify/mysql";
+* import mysql from "mysql2/promise";
+*
+* const pool = mysql.createPool("mysql://user:pass@localhost/db");
+*
+* const federation = createFederation({
+*   kv: new MysqlKvStore(pool),
+*   queue: new MysqlMessageQueue(pool),
+* });
+* ```
+*
+* @since 2.1.0
+*/
+var MysqlMessageQueue = class {
+	/**
+	* MySQL/MariaDB does not provide native retry mechanisms; Fedify handles
+	* retries itself.
+	* @since 2.1.0
+	*/
+	nativeRetrial = false;
+	#pool;
+	#tableName;
+	#pollIntervalMs;
+	#handlerTimeoutMs;
+	#initialized;
+	#initPromise;
+	/**
+	* Creates a new MySQL message queue.
+	* @param pool The MySQL connection pool to use.
+	* @param options Options for the message queue.
+	* @since 2.1.0
+	*/
+	constructor(pool, options = {}) {
+		this.#pool = pool;
+		const tableName = options.tableName ?? "fedify_mq";
+		if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) throw new RangeError(`Invalid table name: ${JSON.stringify(tableName)}. Table names must start with a letter or underscore and contain only letters, digits, and underscores.`);
+		if (tableName.length > 46) throw new RangeError(`Invalid table name: ${JSON.stringify(tableName)}. Table names must be at most 46 characters long (MySQL identifier limit is 64 chars; the derived index "idx_<name>_deliver_after" uses 18 more).`);
+		this.#tableName = tableName;
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 1 }).total("millisecond");
+		this.#handlerTimeoutMs = Temporal.Duration.from(options.handlerTimeout ?? { seconds: 60 }).total("millisecond");
+		this.#initialized = options.initialized ?? false;
+	}
+	/**
+	* {@inheritDoc MessageQueue.enqueue}
+	* @since 2.1.0
+	*/
+	async enqueue(message, options) {
+		await this.initialize();
+		const delayMs = options?.delay == null ? 0 : Math.max(Math.round(options.delay.total("millisecond")), 0);
+		const orderingKey = options?.orderingKey ?? null;
+		if (options?.delay) logger.debug("Enqueuing a message with a delay of {delayMs}ms...", {
+			delayMs,
+			message,
+			orderingKey
+		});
+		else logger.debug("Enqueuing a message...", {
+			message,
+			orderingKey
+		});
+		await this.#pool.query(`INSERT INTO \`${this.#tableName}\`
+         (\`id\`, \`message\`, \`deliver_after\`, \`ordering_key\`)
+       VALUES (
+         UUID(),
+         ?,
+         DATE_ADD(NOW(6), INTERVAL ? MICROSECOND),
+         ?
+       )`, [
+			JSON.stringify(message),
+			delayMs * 1e3,
+			orderingKey
+		]);
+		logger.debug("Enqueued a message.", {
+			message,
+			orderingKey
+		});
+	}
+	/**
+	* {@inheritDoc MessageQueue.enqueueMany}
+	* @since 2.1.0
+	*/
+	async enqueueMany(messages, options) {
+		if (messages.length === 0) return;
+		await this.initialize();
+		const delayMs = options?.delay == null ? 0 : Math.max(Math.round(options.delay.total("millisecond")), 0);
+		const orderingKey = options?.orderingKey ?? null;
+		if (options?.delay) logger.debug("Enqueuing {count} messages with a delay of {delayMs}ms...", {
+			count: messages.length,
+			delayMs,
+			orderingKey
+		});
+		else logger.debug("Enqueuing {count} messages...", {
+			count: messages.length,
+			orderingKey
+		});
+		const placeholders = messages.map(() => "(UUID(), ?, DATE_ADD(NOW(6), INTERVAL ? MICROSECOND), ?)").join(", ");
+		const values = messages.flatMap((message, index) => [
+			JSON.stringify(message),
+			delayMs * 1e3 + index,
+			orderingKey
+		]);
+		let conn;
+		try {
+			conn = await this.#pool.getConnection();
+			await conn.beginTransaction();
+			await conn.query(`INSERT INTO \`${this.#tableName}\`
+           (\`id\`, \`message\`, \`deliver_after\`, \`ordering_key\`)
+         VALUES ${placeholders}`, values);
+			await conn.commit();
+		} catch (e) {
+			if (conn != null) await conn.rollback();
+			throw e;
+		} finally {
+			conn?.release();
+		}
+		logger.debug("Enqueued {count} messages.", {
+			count: messages.length,
+			orderingKey
+		});
+	}
+	/**
+	* {@inheritDoc MessageQueue.listen}
+	* @since 2.1.0
+	*/
+	async listen(handler, options = {}) {
+		await this.initialize();
+		const { signal } = options;
+		const poll = async () => {
+			while (!signal?.aborted) {
+				let processed = false;
+				const noKeyMsg = await this.#dequeueWithoutOrderingKey();
+				if (noKeyMsg !== void 0) {
+					if (signal?.aborted) return;
+					await withTimeout(handler(noKeyMsg), this.#handlerTimeoutMs);
+					processed = true;
+					continue;
+				}
+				const candidates = await this.#findOrderingKeyCandidates();
+				for (const orderingKey of candidates) {
+					if (signal?.aborted) break;
+					const lockName = getMysqlLockName(this.#tableName, orderingKey);
+					let conn;
+					try {
+						conn = await this.#pool.getConnection();
+						const [lockResult] = await conn.query(`SELECT GET_LOCK(?, 0) AS acquired`, [lockName]);
+						if (lockResult[0].acquired === null) logger.warn("GET_LOCK({lockName}) returned NULL (server error); skipping ordering key {orderingKey}.", {
+							lockName,
+							orderingKey
+						});
+						else if (lockResult[0].acquired === 1) {
+							try {
+								const msg = await this.#dequeueOrderedMessage(conn, orderingKey);
+								if (msg !== void 0) {
+									if (signal?.aborted) return;
+									await withTimeout(handler(msg), this.#handlerTimeoutMs);
+									processed = true;
+								}
+							} finally {
+								await conn.query(`SELECT RELEASE_LOCK(?)`, [lockName]);
+							}
+							if (processed) break;
+						}
+					} finally {
+						conn?.release();
+					}
+				}
+				if (!processed) break;
+			}
+		};
+		const safePoll = async (trigger) => {
+			try {
+				await poll();
+			} catch (error) {
+				logger.error("Error while polling for messages ({trigger}); will retry on next poll: {error}", {
+					trigger,
+					error
+				});
+			}
+		};
+		await safePoll("initial");
+		while (!signal?.aborted) {
+			await new Promise((resolve) => {
+				const timeoutId = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve(0);
+				}, this.#pollIntervalMs);
+				function onAbort() {
+					clearTimeout(timeoutId);
+					resolve(void 0);
+				}
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+			if (signal?.aborted) break;
+			await safePoll("interval");
+		}
+	}
+	/**
+	* Atomically dequeues the oldest ready message that has no ordering key,
+	* using `FOR UPDATE SKIP LOCKED` within a transaction.
+	* Returns `undefined` when no such message is available.
+	*/
+	async #dequeueWithoutOrderingKey() {
+		let conn;
+		try {
+			conn = await this.#pool.getConnection();
+			await conn.beginTransaction();
+			const [rows] = await conn.query(`SELECT \`id\`, \`message\`
+         FROM \`${this.#tableName}\`
+         WHERE \`deliver_after\` <= NOW(6) AND \`ordering_key\` IS NULL
+         ORDER BY \`deliver_after\`
+         LIMIT 1
+         FOR UPDATE SKIP LOCKED`);
+			if (rows.length === 0) {
+				await conn.rollback();
+				return void 0;
+			}
+			const { id, message } = rows[0];
+			await conn.query(`DELETE FROM \`${this.#tableName}\` WHERE \`id\` = ?`, [id]);
+			await conn.commit();
+			return message;
+		} catch (e) {
+			if (conn != null) await conn.rollback();
+			throw e;
+		} finally {
+			conn?.release();
+		}
+	}
+	/**
+	* Returns up to {@link ORDERING_KEY_CANDIDATE_LIMIT} distinct ordering keys
+	* that have at least one ready message, ordered by their earliest
+	* `deliver_after`.  Fetching a batch in one query avoids the growing
+	* `NOT IN (…)` list that results from repeatedly calling a single-result
+	* version after each failed lock attempt.
+	*/
+	async #findOrderingKeyCandidates() {
+		const [rows] = await this.#pool.query(`SELECT \`ordering_key\`
+       FROM \`${this.#tableName}\`
+       WHERE \`deliver_after\` <= NOW(6) AND \`ordering_key\` IS NOT NULL
+       GROUP BY \`ordering_key\`
+       ORDER BY MIN(\`deliver_after\`)
+       LIMIT ?`, [ORDERING_KEY_CANDIDATE_LIMIT]);
+		return rows.map((r) => r.ordering_key);
+	}
+	/**
+	* Dequeues the oldest ready message for the given ordering key using
+	* the supplied (dedicated) connection.  The caller MUST hold the advisory
+	* lock for `orderingKey` before calling this method.
+	* Returns `undefined` when no ready message exists for the ordering key.
+	*/
+	async #dequeueOrderedMessage(conn, orderingKey) {
+		await conn.beginTransaction();
+		try {
+			const [rows] = await conn.query(`SELECT \`id\`, \`message\`
+         FROM \`${this.#tableName}\`
+         WHERE \`deliver_after\` <= NOW(6) AND \`ordering_key\` = ?
+         ORDER BY \`deliver_after\`
+         LIMIT 1`, [orderingKey]);
+			if (rows.length === 0) {
+				await conn.rollback();
+				return void 0;
+			}
+			const { id, message } = rows[0];
+			await conn.query(`DELETE FROM \`${this.#tableName}\` WHERE \`id\` = ?`, [id]);
+			await conn.commit();
+			return message;
+		} catch (e) {
+			await conn.rollback();
+			throw e;
+		}
+	}
+	/**
+	* Initializes the message queue table if it does not already exist.
+	* Concurrent calls are coalesced — only one initialization runs at a time.
+	*
+	* @since 2.1.0
+	*/
+	initialize() {
+		if (this.#initialized) return Promise.resolve();
+		return this.#initPromise ??= this.#doInitialize();
+	}
+	async #doInitialize() {
+		logger.debug("Initializing the message queue table {tableName}...", { tableName: this.#tableName });
+		for (let attempt = 1; attempt <= INITIALIZE_MAX_ATTEMPTS; attempt++) try {
+			await this.#pool.query(`CREATE TABLE IF NOT EXISTS \`${this.#tableName}\` (
+            \`id\`            CHAR(36)    NOT NULL,
+            \`message\`       JSON        NOT NULL,
+            \`deliver_after\` DATETIME(6) NOT NULL DEFAULT NOW(6),
+            \`ordering_key\`  TEXT        NULL     DEFAULT NULL,
+            PRIMARY KEY (\`id\`)
+          ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin`);
+			try {
+				await this.#pool.query(`CREATE INDEX \`idx_${this.#tableName}_deliver_after\`
+             ON \`${this.#tableName}\` (\`deliver_after\`)`);
+			} catch (e) {
+				if (e.code !== "ER_DUP_KEYNAME") throw e;
+			}
+			try {
+				await this.#pool.query(`CREATE INDEX \`idx_${this.#tableName}_ok_da\`
+             ON \`${this.#tableName}\` (\`ordering_key\`(766), \`deliver_after\`)`);
+			} catch (e) {
+				if (e.code !== "ER_DUP_KEYNAME") throw e;
+			}
+			break;
+		} catch (error) {
+			if (attempt >= INITIALIZE_MAX_ATTEMPTS) {
+				logger.error("Failed to initialize the message queue table: {error}", { error });
+				throw error;
+			}
+			const backoffMs = INITIALIZE_BACKOFF_MS * 2 ** (attempt - 1);
+			logger.debug("Initialization race for table {tableName}; retrying in {backoffMs}ms (attempt {attempt}/{maxAttempts}).", {
+				tableName: this.#tableName,
+				backoffMs,
+				attempt,
+				maxAttempts: INITIALIZE_MAX_ATTEMPTS,
+				error
+			});
+			await sleep(backoffMs);
+		}
+		this.#initialized = true;
+		logger.debug("Initialized the message queue table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Drops the message queue table if it exists.  Resets the initialized flag
+	* so that {@link MysqlMessageQueue.initialize} can recreate the table on
+	* the next call.
+	*
+	* @since 2.1.0
+	*/
+	async drop() {
+		if (this.#initPromise != null) try {
+			await this.#initPromise;
+		} catch {}
+		await this.#pool.query(`DROP TABLE IF EXISTS \`${this.#tableName}\``);
+		this.#initialized = false;
+		this.#initPromise = void 0;
+	}
+};
+
+//#endregion
+export { MysqlMessageQueue };