@fedify/mysql 2.1.0-dev.0

package/dist/kv.js

@@ -0,0 +1,234 @@
+
+        import { Temporal } from "@js-temporal/polyfill";
+      
+import { isEqual } from "es-toolkit";
+import { getLogger } from "@logtape/logtape";
+
+//#region src/kv.ts
+const logger = getLogger([
+	"fedify",
+	"mysql",
+	"kv"
+]);
+/**
+* A key-value store that uses MySQL (or MariaDB) as the underlying storage.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { MysqlKvStore } from "@fedify/mysql";
+* import mysql from "mysql2/promise";
+*
+* const pool = mysql.createPool("mysql://user:pass@localhost/db");
+*
+* const federation = createFederation({
+*   // ...
+*   kv: new MysqlKvStore(pool),
+* });
+* ```
+*
+* @since 2.1.0
+*/
+var MysqlKvStore = class {
+	#pool;
+	#tableName;
+	#expireCleanupRate;
+	#initialized;
+	/**
+	* Creates a new MySQL key-value store.
+	* @param pool The MySQL connection pool to use.
+	* @param options The options for the key-value store.
+	* @since 2.1.0
+	*/
+	constructor(pool, options = {}) {
+		this.#pool = pool;
+		const tableName = options.tableName ?? "fedify_kv";
+		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 > 50) throw new RangeError(`Invalid table name: ${JSON.stringify(tableName)}. Table names must be at most 50 characters long (MySQL identifier limit is 64 chars; the derived index "idx_<name>_expires" uses 12 more).`);
+		this.#tableName = tableName;
+		const expireCleanupRate = options.expireCleanupRate ?? 1;
+		if (expireCleanupRate < 0 || expireCleanupRate > 1) throw new RangeError(`Invalid expireCleanupRate: ${expireCleanupRate}. Must be a number between 0 and 1 inclusive.`);
+		this.#expireCleanupRate = expireCleanupRate;
+		this.#initialized = options.initialized ?? false;
+	}
+	async #expire() {
+		if (this.#expireCleanupRate <= 0) return;
+		if (this.#expireCleanupRate < 1 && Math.random() >= this.#expireCleanupRate) return;
+		await this.#pool.query(`DELETE FROM \`${this.#tableName}\`
+       WHERE \`expires\` IS NOT NULL AND \`expires\` < NOW(6)`);
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	* @since 2.1.0
+	*/
+	async get(key) {
+		await this.initialize();
+		const serializedKey = JSON.stringify([...key]);
+		const [rows] = await this.#pool.query(`SELECT \`value\` FROM \`${this.#tableName}\`
+       WHERE \`key\` = ?
+         AND (\`expires\` IS NULL OR \`expires\` > NOW(6))`, [serializedKey]);
+		if (rows.length < 1) return void 0;
+		return rows[0].value;
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	* @since 2.1.0
+	*/
+	async set(key, value, options) {
+		if (value === void 0) return;
+		await this.initialize();
+		const serializedKey = JSON.stringify([...key]);
+		const jsonValue = JSON.stringify(value);
+		if (options?.ttl != null) {
+			const ttlSeconds = durationToSeconds(options.ttl);
+			await this.#pool.query(`INSERT INTO \`${this.#tableName}\` (\`key\`, \`value\`, \`expires\`)
+         VALUES (?, CAST(? AS JSON),
+                 DATE_ADD(NOW(6), INTERVAL ? SECOND))
+         ON DUPLICATE KEY UPDATE
+           \`value\` = VALUES(\`value\`),
+           \`expires\` = VALUES(\`expires\`)`, [
+				serializedKey,
+				jsonValue,
+				ttlSeconds
+			]);
+		} else await this.#pool.query(`INSERT INTO \`${this.#tableName}\` (\`key\`, \`value\`, \`expires\`)
+         VALUES (?, CAST(? AS JSON), NULL)
+         ON DUPLICATE KEY UPDATE
+           \`value\` = VALUES(\`value\`),
+           \`expires\` = NULL`, [serializedKey, jsonValue]);
+		await this.#expire();
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	* @since 2.1.0
+	*/
+	async delete(key) {
+		await this.initialize();
+		const serializedKey = JSON.stringify([...key]);
+		await this.#pool.query(`DELETE FROM \`${this.#tableName}\` WHERE \`key\` = ?`, [serializedKey]);
+		await this.#expire();
+	}
+	/**
+	* {@inheritDoc KvStore.cas}
+	* @since 2.1.0
+	*/
+	async cas(key, expectedValue, newValue, options) {
+		await this.initialize();
+		const serializedKey = JSON.stringify([...key]);
+		let conn;
+		try {
+			conn = await this.#pool.getConnection();
+			await conn.beginTransaction();
+			const [rows] = await conn.query(`SELECT
+           \`value\`,
+           (\`expires\` IS NOT NULL AND \`expires\` <= NOW(6)) AS \`is_expired\`
+         FROM \`${this.#tableName}\`
+         WHERE \`key\` = ?
+         FOR UPDATE`, [serializedKey]);
+			const row = rows[0];
+			const currentValue = !row || row.is_expired ? void 0 : row.value;
+			if (!isEqual(currentValue, expectedValue)) {
+				await conn.rollback();
+				return false;
+			}
+			if (newValue === void 0) await conn.query(`DELETE FROM \`${this.#tableName}\` WHERE \`key\` = ?`, [serializedKey]);
+			else {
+				const jsonValue = JSON.stringify(newValue);
+				if (options?.ttl != null) {
+					const ttlSeconds = durationToSeconds(options.ttl);
+					await conn.query(`INSERT INTO \`${this.#tableName}\`
+               (\`key\`, \`value\`, \`expires\`)
+             VALUES (?, CAST(? AS JSON),
+                     DATE_ADD(NOW(6), INTERVAL ? SECOND))
+             ON DUPLICATE KEY UPDATE
+               \`value\` = VALUES(\`value\`),
+               \`expires\` = VALUES(\`expires\`)`, [
+						serializedKey,
+						jsonValue,
+						ttlSeconds
+					]);
+				} else await conn.query(`INSERT INTO \`${this.#tableName}\`
+               (\`key\`, \`value\`, \`expires\`)
+             VALUES (?, CAST(? AS JSON), NULL)
+             ON DUPLICATE KEY UPDATE
+               \`value\` = VALUES(\`value\`),
+               \`expires\` = NULL`, [serializedKey, jsonValue]);
+			}
+			await conn.commit();
+			await this.#expire();
+			return true;
+		} catch (e) {
+			if (conn) await conn.rollback();
+			throw e;
+		} finally {
+			if (conn) conn.release();
+		}
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	* @since 2.1.0
+	*/
+	async *list(prefix) {
+		await this.initialize();
+		let rows;
+		if (prefix == null || prefix.length === 0) [rows] = await this.#pool.query(`SELECT \`key\`, \`value\` FROM \`${this.#tableName}\`
+         WHERE \`expires\` IS NULL OR \`expires\` > NOW(6)
+         ORDER BY \`key\``);
+		else {
+			const serializedPrefix = JSON.stringify([...prefix]);
+			const likePrefix = serializedPrefix.slice(0, -1).replace(/[%_\\]/g, "\\$&") + ",%";
+			[rows] = await this.#pool.query(`SELECT \`key\`, \`value\` FROM \`${this.#tableName}\`
+         WHERE (\`key\` = ? OR \`key\` LIKE ? ESCAPE '\\\\')
+           AND (\`expires\` IS NULL OR \`expires\` > NOW(6))
+         ORDER BY \`key\``, [serializedPrefix, likePrefix]);
+		}
+		for (const row of rows) yield {
+			key: JSON.parse(row.key),
+			value: row.value
+		};
+	}
+	/**
+	* Creates the table used by the key-value store if it does not already exist.
+	* Does nothing if the table already exists.
+	*
+	* @since 2.1.0
+	*/
+	async initialize() {
+		if (this.#initialized) return;
+		logger.debug("Initializing the key-value store table {tableName}...", { tableName: this.#tableName });
+		await this.#pool.query(`CREATE TABLE IF NOT EXISTS \`${this.#tableName}\` (
+        \`key\` VARCHAR(768) NOT NULL,
+        \`value\` JSON NOT NULL,
+        \`expires\` DATETIME(6) NULL DEFAULT NULL,
+        PRIMARY KEY (\`key\`)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin`);
+		try {
+			await this.#pool.query(`CREATE INDEX \`idx_${this.#tableName}_expires\`
+         ON \`${this.#tableName}\` (\`expires\`)`);
+		} catch (e) {
+			if (e.code !== "ER_DUP_KEYNAME") throw e;
+		}
+		this.#initialized = true;
+		logger.debug("Initialized the key-value store table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Drops the table used by the key-value store.  Does nothing if the table
+	* does not exist.  Resets the initialized flag so that
+	* {@link MysqlKvStore.initialize} can recreate the table on the next call.
+	*
+	* @since 2.1.0
+	*/
+	async drop() {
+		await this.#pool.query(`DROP TABLE IF EXISTS \`${this.#tableName}\``);
+		this.#initialized = false;
+	}
+};
+function durationToSeconds(duration) {
+	return duration.total({
+		unit: "second",
+		relativeTo: Temporal.Now.plainDateTimeISO()
+	});
+}
+
+//#endregion
+export { MysqlKvStore };

package/dist/mod.cjs

@@ -0,0 +1,8 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_kv = require('./kv.cjs');
+const require_mq = require('./mq.cjs');
+
+exports.MysqlKvStore = require_kv.MysqlKvStore;
+exports.MysqlMessageQueue = require_mq.MysqlMessageQueue;

package/dist/mod.d.cts

@@ -0,0 +1,3 @@
+import { MysqlKvStore, MysqlKvStoreOptions } from "./kv.cjs";
+import { MysqlMessageQueue, MysqlMessageQueueOptions } from "./mq.cjs";
+export { MysqlKvStore, MysqlKvStoreOptions, MysqlMessageQueue, MysqlMessageQueueOptions };

package/dist/mod.d.ts

@@ -0,0 +1,4 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { MysqlKvStore, MysqlKvStoreOptions } from "./kv.js";
+import { MysqlMessageQueue, MysqlMessageQueueOptions } from "./mq.js";
+export { MysqlKvStore, MysqlKvStoreOptions, MysqlMessageQueue, MysqlMessageQueueOptions };

package/dist/mod.js

@@ -0,0 +1,7 @@
+
+        import { Temporal } from "@js-temporal/polyfill";
+      
+import { MysqlKvStore } from "./kv.js";
+import { MysqlMessageQueue } from "./mq.js";
+
+export { MysqlKvStore, MysqlMessageQueue };

package/dist/mq.cjs

@@ -0,0 +1,395 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mq.ts
+const logger = (0, __logtape_logtape.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
+exports.MysqlMessageQueue = MysqlMessageQueue;