@lakutata/mutex 0.0.0-stage → 3.0.0-beta.1

package/dist/cjs/mutex/drivers/MemoryMutexDriver.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMutexDriver = void 0;
+const MutexDriver_js_1 = require("./MutexDriver.js");
+const Names_js_1 = require("../lib/Names.js");
+/**
+ * The locks of the process, shared by its components: the ones of a single instance (its development, its tests)
+ */
+const LOCKS = new Map();
+let FENCE = 0;
+/**
+ * The memory driver (`{type: 'memory'}`, the default of a {@link Mutex}): the locks live in the process memory, shared
+ * by every component and driver of the process using the same prefix, and invisible to the other processes. Use it for
+ * development, tests and an application running as a single process. It needs no package.
+ *
+ * The locks expire after their `ttl` unless renewed. The fencing token is a counter of the process, starting again at 1
+ * when the process restarts. The locks are lost with the process.
+ * @example
+ * ```typescript
+ * import {MemoryMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * const driver: MemoryMutexDriver = new MemoryMutexDriver('test:')
+ * const first: DriverLock | undefined = await driver.acquire('job', 1000)
+ * console.log(await driver.acquire('job', 1000)) //undefined: held by the first
+ * if (first) console.log(await driver.release('job', first)) //true
+ * await driver.close()
+ * ```
+ */
+class MemoryMutexDriver extends MutexDriver_js_1.MutexDriver {
+    #locks;
+    /**
+     * Create a driver on the process memory.
+     * @param prefix The prefix added to the lock names; the drivers of the process with the same prefix share their
+     * locks. `''` by default.
+     */
+    constructor(prefix = '') {
+        super();
+        this.prefix = prefix;
+        /**
+         * `true`: the locks expire after their `ttl` unless renewed.
+         */
+        this.expiring = true;
+        this.#locks = LOCKS;
+    }
+    /**
+     * Try to acquire a lock once: granted when nobody holds it or its holder let it expire.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds.
+     * @returns The lock with a fencing token, or `undefined` when another holder has it.
+     */
+    async acquire(name, ttl) {
+        const key = this.prefix + name;
+        const current = this.#locks.get(key);
+        if (current && current.expires > Date.now())
+            return undefined;
+        const lock = { token: (0, Names_js_1.lockToken)(), fence: ++FENCE };
+        this.#locks.set(key, { token: lock.token, expires: Date.now() + ttl });
+        return lock;
+    }
+    /**
+     * Release a lock still held by this holder.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released (`false` when another holder has taken it since).
+     */
+    async release(name, lock) {
+        if (this.#locks.get(this.prefix + name)?.token !== lock.token)
+            return false;
+        this.#locks.delete(this.prefix + name);
+        return true;
+    }
+    /**
+     * Renew a lock still held by this holder, for `ttl` milliseconds from now. A lock expired is not renewed (lost),
+     * even when no other holder took it yet.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @param ttl How long the lock stays held without another renewal, in milliseconds.
+     * @returns Whether it was renewed.
+     */
+    async extend(name, lock, ttl) {
+        const current = this.#locks.get(this.prefix + name);
+        //Expired: lost, even when nobody took it yet
+        if (current?.token !== lock.token || current.expires <= Date.now())
+            return false;
+        current.expires = Date.now() + ttl;
+        return true;
+    }
+    /**
+     * Do nothing: the locks stay in the process memory until they are released or expire.
+     */
+    async close() {
+        //The locks of the process kept: the ones of this component are released by it
+    }
+}
+exports.MemoryMutexDriver = MemoryMutexDriver;

package/dist/cjs/mutex/drivers/MutexDriver.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A lock granted by a {@link MutexDriver}: what its holder gives back to release or renew it.
+ */
+export type DriverLock = {
+    /**
+     * The random token identifying the holder (32 hexadecimal characters); the store only releases or renews the lock
+     * for it.
+     */
+    token: string;
+    /**
+     * The fencing token: a number increasing with each acquisition in the store, given by the memory and Redis drivers
+     * and the `table` mode of PostgreSQL and MySQL; `undefined` for the file driver and the advisory locks.
+     */
+    fence?: number;
+};
+/**
+ * The base class of the lock drivers: it acquires, releases and renews the locks in a store shared by their holders.
+ * A {@link Mutex} creates its driver from its `driver` option and adds the waiting, the automatic renewal and the lost
+ * locks; a custom subclass cannot be given to it. The drivers are exported to use a store directly (scripts, tests):
+ * they neither wait nor renew, and their errors are the clients' errors, not a {@link MutexDriverException}.
+ * @example
+ * ```typescript
+ * import {MemoryMutexDriver, type DriverLock, type MutexDriver} from 'lakutata/com/mutex'
+ *
+ * async function once(driver: MutexDriver, name: string, work: () => Promise<void>): Promise<boolean> {
+ *     const lock: DriverLock | undefined = await driver.acquire(name, 10000)
+ *     if (!lock) return false
+ *     try {
+ *         await work()
+ *     } finally {
+ *         await driver.release(name, lock)
+ *     }
+ *     return true
+ * }
+ *
+ * const driver: MutexDriver = new MemoryMutexDriver('script:')
+ * console.log(await once(driver, 'migrate', async (): Promise<void> => undefined))
+ * await driver.close()
+ * ```
+ */
+export declare abstract class MutexDriver {
+    /**
+     * Whether the locks expire after their `ttl` unless renewed: `true` for the memory, file and Redis drivers and the
+     * `table` mode; `false` for the advisory locks of PostgreSQL and MySQL, which end with their connection instead.
+     */
+    abstract readonly expiring: boolean;
+    /**
+     * Called with the names of the locks the driver lost at once, when the connection holding advisory locks closes or
+     * fails. A {@link Mutex} sets it; it does nothing by default.
+     */
+    onLost: (names: string[]) => void;
+    /**
+     * Try to acquire a lock once, without waiting.
+     * @param name The lock name; the driver's prefix is added to it in the store.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds (ignored by the advisory locks).
+     * @returns The lock granted, or `undefined` when another holder has it.
+     * @throws {MutexDriverNotFoundException} When the client package of the driver is not installed.
+     */
+    abstract acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * Release a lock, when the store still has it for this holder.
+     * @param name The lock name, as acquired.
+     * @param lock The lock returned by {@link MutexDriver.acquire}.
+     * @returns Whether it was released: `false` when the store no longer has it for this holder (expired, taken, or its
+     * connection closed).
+     */
+    abstract release(name: string, lock: DriverLock): Promise<boolean>;
+    /**
+     * Renew a lock for `ttl` milliseconds from now, when the store still has it for this holder; for the advisory locks,
+     * check that it is still held.
+     * @param name The lock name, as acquired.
+     * @param lock The lock returned by {@link MutexDriver.acquire}.
+     * @param ttl How long the lock stays held without another renewal, in milliseconds.
+     * @returns Whether the lock is still held by this holder.
+     */
+    abstract extend(name: string, lock: DriverLock, ttl: number): Promise<boolean>;
+    /**
+     * Close the driver's connections; the advisory locks they hold are released by the database. The driver is not meant
+     * to be used after it.
+     */
+    abstract close(): Promise<void>;
+}

package/dist/cjs/mutex/drivers/MutexDriver.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutexDriver = void 0;
+/**
+ * The base class of the lock drivers: it acquires, releases and renews the locks in a store shared by their holders.
+ * A {@link Mutex} creates its driver from its `driver` option and adds the waiting, the automatic renewal and the lost
+ * locks; a custom subclass cannot be given to it. The drivers are exported to use a store directly (scripts, tests):
+ * they neither wait nor renew, and their errors are the clients' errors, not a {@link MutexDriverException}.
+ * @example
+ * ```typescript
+ * import {MemoryMutexDriver, type DriverLock, type MutexDriver} from 'lakutata/com/mutex'
+ *
+ * async function once(driver: MutexDriver, name: string, work: () => Promise<void>): Promise<boolean> {
+ *     const lock: DriverLock | undefined = await driver.acquire(name, 10000)
+ *     if (!lock) return false
+ *     try {
+ *         await work()
+ *     } finally {
+ *         await driver.release(name, lock)
+ *     }
+ *     return true
+ * }
+ *
+ * const driver: MutexDriver = new MemoryMutexDriver('script:')
+ * console.log(await once(driver, 'migrate', async (): Promise<void> => undefined))
+ * await driver.close()
+ * ```
+ */
+class MutexDriver {
+    constructor() {
+        /**
+         * Called with the names of the locks the driver lost at once, when the connection holding advisory locks closes or
+         * fails. A {@link Mutex} sets it; it does nothing by default.
+         */
+        this.onLost = () => undefined;
+    }
+}
+exports.MutexDriver = MutexDriver;

package/dist/cjs/mutex/drivers/MysqlMutexDriver.d.ts

@@ -0,0 +1,135 @@
+import { MutexDriver, type DriverLock } from './MutexDriver.js';
+/**
+ * The MySQL (or MariaDB) connection of a {@link MysqlMutexDriver}.
+ */
+export type MysqlMutexConnection = {
+    /**
+     * The host name or IP address of the server.
+     */
+    host: string;
+    /**
+     * The port of the server.
+     * @default 3306
+     */
+    port?: number;
+    /**
+     * The database holding the table of the `table` mode (the named locks are global to the server).
+     */
+    database: string;
+    /**
+     * The user name.
+     */
+    username: string;
+    /**
+     * The password.
+     */
+    password: string;
+};
+/**
+ * The MySQL driver (`{type: 'mysql'}`, MySQL or MariaDB): the locks are shared by every instance connected to the same
+ * server with the same prefix. It needs the optional peer dependency `mysql2` (3); without it, the first acquisition
+ * fails with {@link MutexDriverNotFoundException}. It has two modes:
+ * - `'advisory'` (the default): named locks (`GET_LOCK`) taken on one connection of the driver, opened at the first use.
+ *   They do not expire and need no renewal: MySQL releases them when the connection closes, so a crashed process frees
+ *   them at once. When the connection closes or fails, every lock it held is lost (a {@link Mutex} aborts their
+ *   signals) and the next acquisition opens a new connection. A connection cut without the client noticing it is not
+ *   detected by the renewals. No fencing token. The named locks are not replicated by the clusters (Galera, Group
+ *   Replication): every holder must connect to the same server.
+ * - `'table'`: one row per lock in a table, created at the first use with its counter table `<table>_fence`. The rows
+ *   expire by the database clock after their `ttl` unless renewed, so it works through the poolers and the clusters, and
+ *   each acquisition gets a fencing token from the counter. A pool of 4 connections is used.
+ * @example
+ * ```typescript
+ * import {MysqlMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * const driver: MysqlMutexDriver = new MysqlMutexDriver({
+ *     host: '127.0.0.1',
+ *     database: 'app',
+ *     username: 'app',
+ *     password: 'secret'
+ * }, 'my-app:')
+ * const lock: DriverLock | undefined = await driver.acquire('invoice:7', 30000)
+ * if (lock) await driver.release('invoice:7', lock)
+ * //Closing the connection releases its named locks
+ * await driver.close()
+ * ```
+ */
+export declare class MysqlMutexDriver extends MutexDriver {
+    #private;
+    protected readonly connection: MysqlMutexConnection;
+    protected readonly prefix: string;
+    protected readonly mode: 'advisory' | 'table';
+    protected readonly table: string;
+    /**
+     * `true` in the `table` mode (the rows expire), `false` in the `advisory` mode (the locks end with the connection).
+     */
+    readonly expiring: boolean;
+    /**
+     * Create a driver on a MySQL server; it connects at its first use.
+     * @param connection The connection to the server.
+     * @param prefix The prefix added to the lock names.
+     * @param mode `'advisory'` (the default) or `'table'`.
+     * @param table The table of the `table` mode, in the connection's database; `'lakutata_mutex'` by default.
+     * @throws {Error} When the table is not a valid name (letters, digits and `_`, not starting with a digit, without a
+     * database qualifier).
+     */
+    constructor(connection: MysqlMutexConnection, prefix: string, mode?: 'advisory' | 'table', table?: string);
+    /**
+     * The configuration given to `mysql2` for the connections.
+     * @returns The `mysql2` connection configuration.
+     */
+    protected config(): Record<string, unknown>;
+    /**
+     * The name of a lock for `GET_LOCK`: `lakutata:` and the start of the SHA-256 digest of the prefixed name, 64
+     * characters in all (the limit of MySQL).
+     * @param name The lock name.
+     * @returns The MySQL lock name.
+     */
+    protected lockName(name: string): string;
+    /**
+     * The connection holding the named locks, opened at the first call; when it ends or fails, its locks are reported
+     * lost through {@link MutexDriver.onLost}.
+     * @returns The `mysql2` connection.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    protected session(): Promise<any>;
+    /**
+     * The connection pool of the `table` mode, created at the first call along with the tables; created again at the
+     * next call when that fails.
+     * @returns The `mysql2` pool.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    protected pool(): Promise<any>;
+    /**
+     * Try to acquire a lock once: a named lock of the driver's connection, or a row inserted (or taken over when
+     * expired) in the table.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds (the `table` mode only).
+     * @returns The lock (with a fencing token in the `table` mode), or `undefined` when another holder has it, this
+     * driver included.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * Release a lock still held by this holder: `RELEASE_LOCK`, or delete the row.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released (`false` when the row expired and was taken, or the connection was lost).
+     */
+    release(name: string, lock: DriverLock): Promise<boolean>;
+    /**
+     * Renew a lock: in the `table` mode, push back the expiration of its row when it still holds this holder's token; in
+     * the `advisory` mode, check that the driver still holds it on its connection, by a query (a connection cut without
+     * notice fails it).
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @param ttl How long the lock stays held without another renewal, in milliseconds (the `table` mode only).
+     * @returns Whether the lock is still held by this holder.
+     */
+    extend(name: string, lock: DriverLock, ttl: number): Promise<boolean>;
+    /**
+     * Close the connection (MySQL releases its named locks) and the pool; the rows of the `table` mode stay until they
+     * expire.
+     */
+    close(): Promise<void>;
+}

package/dist/cjs/mutex/drivers/MysqlMutexDriver.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlMutexDriver = void 0;
+const MutexDriver_js_1 = require("./MutexDriver.js");
+const LoadDriver_js_1 = require("../lib/LoadDriver.js");
+const Names_js_1 = require("../lib/Names.js");
+/**
+ * The MySQL driver (`{type: 'mysql'}`, MySQL or MariaDB): the locks are shared by every instance connected to the same
+ * server with the same prefix. It needs the optional peer dependency `mysql2` (3); without it, the first acquisition
+ * fails with {@link MutexDriverNotFoundException}. It has two modes:
+ * - `'advisory'` (the default): named locks (`GET_LOCK`) taken on one connection of the driver, opened at the first use.
+ *   They do not expire and need no renewal: MySQL releases them when the connection closes, so a crashed process frees
+ *   them at once. When the connection closes or fails, every lock it held is lost (a {@link Mutex} aborts their
+ *   signals) and the next acquisition opens a new connection. A connection cut without the client noticing it is not
+ *   detected by the renewals. No fencing token. The named locks are not replicated by the clusters (Galera, Group
+ *   Replication): every holder must connect to the same server.
+ * - `'table'`: one row per lock in a table, created at the first use with its counter table `<table>_fence`. The rows
+ *   expire by the database clock after their `ttl` unless renewed, so it works through the poolers and the clusters, and
+ *   each acquisition gets a fencing token from the counter. A pool of 4 connections is used.
+ * @example
+ * ```typescript
+ * import {MysqlMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * const driver: MysqlMutexDriver = new MysqlMutexDriver({
+ *     host: '127.0.0.1',
+ *     database: 'app',
+ *     username: 'app',
+ *     password: 'secret'
+ * }, 'my-app:')
+ * const lock: DriverLock | undefined = await driver.acquire('invoice:7', 30000)
+ * if (lock) await driver.release('invoice:7', lock)
+ * //Closing the connection releases its named locks
+ * await driver.close()
+ * ```
+ */
+class MysqlMutexDriver extends MutexDriver_js_1.MutexDriver {
+    #connection;
+    #pool;
+    #connecting;
+    #table;
+    #held = new Map();
+    /**
+     * Create a driver on a MySQL server; it connects at its first use.
+     * @param connection The connection to the server.
+     * @param prefix The prefix added to the lock names.
+     * @param mode `'advisory'` (the default) or `'table'`.
+     * @param table The table of the `table` mode, in the connection's database; `'lakutata_mutex'` by default.
+     * @throws {Error} When the table is not a valid name (letters, digits and `_`, not starting with a digit, without a
+     * database qualifier).
+     */
+    constructor(connection, prefix, mode = 'advisory', table = 'lakutata_mutex') {
+        super();
+        this.connection = connection;
+        this.prefix = prefix;
+        this.mode = mode;
+        this.table = table;
+        this.expiring = mode === 'table';
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table))
+            throw new Error(`The table of the locks "${table}" is not a name of MySQL`);
+    }
+    /**
+     * The configuration given to `mysql2` for the connections.
+     * @returns The `mysql2` connection configuration.
+     */
+    config() {
+        return { host: this.connection.host, port: this.connection.port ?? 3306, database: this.connection.database, user: this.connection.username, password: this.connection.password };
+    }
+    /**
+     * The name of a lock for `GET_LOCK`: `lakutata:` and the start of the SHA-256 digest of the prefixed name, 64
+     * characters in all (the limit of MySQL).
+     * @param name The lock name.
+     * @returns The MySQL lock name.
+     */
+    lockName(name) {
+        return `lakutata:${(0, Names_js_1.nameDigest)(this.prefix + name).slice(0, 55)}`;
+    }
+    /**
+     * The connection holding the named locks, opened at the first call; when it ends or fails, its locks are reported
+     * lost through {@link MutexDriver.onLost}.
+     * @returns The `mysql2` connection.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    async session() {
+        if (this.#connection)
+            return this.#connection;
+        this.#connecting ??= (async () => {
+            const mysql = await (0, LoadDriver_js_1.loadDriver)('createConnection', 'mysql2/promise');
+            const connection = await mysql.createConnection(this.config());
+            const lost = () => {
+                if (this.#connection !== connection)
+                    return;
+                this.#connection = undefined;
+                const names = [...this.#held.keys()];
+                this.#held.clear();
+                if (names.length)
+                    this.onLost(names);
+            };
+            connection.on('error', lost);
+            connection.on('end', lost);
+            this.#connection = connection;
+            return connection;
+        })().finally(() => {
+            this.#connecting = undefined;
+        });
+        return await this.#connecting;
+    }
+    /**
+     * The connection pool of the `table` mode, created at the first call along with the tables; created again at the
+     * next call when that fails.
+     * @returns The `mysql2` pool.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    async pool() {
+        //Created once: the first uses at the same time share it
+        this.#table ??= (async () => {
+            const mysql = await (0, LoadDriver_js_1.loadDriver)('createPool', 'mysql2/promise');
+            const pool = mysql.createPool({ ...this.config(), connectionLimit: 4 });
+            this.#pool = pool;
+            await this.#pool.query(`CREATE TABLE IF NOT EXISTS \`${this.table}\` (\`key\` VARCHAR(64) PRIMARY KEY, name TEXT NOT NULL, token VARCHAR(64) NOT NULL, fence BIGINT NOT NULL, expires_at DATETIME(3) NOT NULL)`);
+            await this.#pool.query(`CREATE TABLE IF NOT EXISTS \`${this.table}_fence\` (id TINYINT PRIMARY KEY, value BIGINT NOT NULL)`);
+            await this.#pool.query(`INSERT IGNORE INTO \`${this.table}_fence\` (id, value) VALUES (1, 0)`);
+        })().catch(async (error) => {
+            //Created again at the next use: this pool closed
+            this.#table = undefined;
+            const failed = this.#pool;
+            this.#pool = undefined;
+            await failed?.end().catch(() => undefined);
+            throw error;
+        });
+        await this.#table;
+        return this.#pool;
+    }
+    /**
+     * Try to acquire a lock once: a named lock of the driver's connection, or a row inserted (or taken over when
+     * expired) in the table.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds (the `table` mode only).
+     * @returns The lock (with a fencing token in the `table` mode), or `undefined` when another holder has it, this
+     * driver included.
+     * @throws {MutexDriverNotFoundException} When the package `mysql2` is not installed.
+     */
+    async acquire(name, ttl) {
+        const token = (0, Names_js_1.lockToken)();
+        if (this.mode === 'table') {
+            const connection = await (await this.pool()).getConnection();
+            try {
+                //The fencing token: the counter incremented, read by the connection (LAST_INSERT_ID)
+                await connection.query(`UPDATE \`${this.table}_fence\` SET value = LAST_INSERT_ID(value + 1) WHERE id = 1`);
+                const [[{ fence }]] = await connection.query('SELECT LAST_INSERT_ID() AS fence');
+                const key = (0, Names_js_1.nameDigest)(this.prefix + name);
+                //Taken when it is expired: the columns kept otherwise (expires_at assigned last, read before)
+                await connection.query(`INSERT INTO \`${this.table}\` (\`key\`, name, token, fence, expires_at) VALUES (?, ?, ?, ?, NOW(3) + INTERVAL ? MICROSECOND)
+                     ON DUPLICATE KEY UPDATE name = IF(expires_at <= NOW(3), VALUES(name), name), token = IF(expires_at <= NOW(3), VALUES(token), token),
+                     fence = IF(expires_at <= NOW(3), VALUES(fence), fence), expires_at = IF(expires_at <= NOW(3), VALUES(expires_at), expires_at)`, [key, name, token, fence, Math.ceil(ttl) * 1000]);
+                const [rows] = await connection.query(`SELECT token FROM \`${this.table}\` WHERE \`key\` = ?`, [key]);
+                return rows[0]?.token === token ? { token: token, fence: Number(fence) } : undefined;
+            }
+            finally {
+                connection.release();
+            }
+        }
+        if (this.#held.has(name))
+            return undefined;
+        this.#held.set(name, undefined);
+        try {
+            const [[{ locked }]] = await (await this.session()).query('SELECT GET_LOCK(?, 0) AS locked', [this.lockName(name)]);
+            //NULL: an error of the server (the thread killed, out of memory), not a lock held by another
+            if (locked === null)
+                throw new Error(`GET_LOCK failed for the lock ${name}`);
+            if (Number(locked) !== 1) {
+                this.#held.delete(name);
+                return undefined;
+            }
+            this.#held.set(name, token);
+            return { token: token };
+        }
+        catch (error) {
+            this.#held.delete(name);
+            throw error;
+        }
+    }
+    /**
+     * Release a lock still held by this holder: `RELEASE_LOCK`, or delete the row.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released (`false` when the row expired and was taken, or the connection was lost).
+     */
+    async release(name, lock) {
+        if (this.mode === 'table') {
+            const [result] = await (await this.pool()).query(`DELETE FROM \`${this.table}\` WHERE \`key\` = ? AND token = ?`, [(0, Names_js_1.nameDigest)(this.prefix + name), lock.token]);
+            return result.affectedRows === 1;
+        }
+        if (this.#held.get(name) !== lock.token)
+            return false;
+        this.#held.delete(name);
+        const connection = this.#connection;
+        if (!connection)
+            return false;
+        const [[{ released }]] = await connection.query('SELECT RELEASE_LOCK(?) AS released', [this.lockName(name)]);
+        return Number(released) === 1;
+    }
+    /**
+     * Renew a lock: in the `table` mode, push back the expiration of its row when it still holds this holder's token; in
+     * the `advisory` mode, check that the driver still holds it on its connection, by a query (a connection cut without
+     * notice fails it).
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @param ttl How long the lock stays held without another renewal, in milliseconds (the `table` mode only).
+     * @returns Whether the lock is still held by this holder.
+     */
+    async extend(name, lock, ttl) {
+        if (this.mode === 'table') {
+            const [result] = await (await this.pool()).query(`UPDATE \`${this.table}\` SET expires_at = NOW(3) + INTERVAL ? MICROSECOND WHERE \`key\` = ? AND token = ?`, [Math.ceil(ttl) * 1000, (0, Names_js_1.nameDigest)(this.prefix + name), lock.token]);
+            return result.affectedRows === 1;
+        }
+        //Held as long as its connection: checked by a query (a connection cut silently fails it)
+        const connection = this.#connection;
+        if (this.#held.get(name) !== lock.token || !connection)
+            return false;
+        try {
+            await connection.query('SELECT 1');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Close the connection (MySQL releases its named locks) and the pool; the rows of the `table` mode stay until they
+     * expire.
+     */
+    async close() {
+        const connection = this.#connection;
+        this.#connection = undefined;
+        this.#held.clear();
+        await connection?.end().catch(() => undefined);
+        const pool = this.#pool;
+        this.#pool = undefined;
+        //Created again at the next use
+        this.#table = undefined;
+        await pool?.end().catch(() => undefined);
+    }
+}
+exports.MysqlMutexDriver = MysqlMutexDriver;