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

package/dist/cjs/mutex/exceptions/MutexDriverException.d.ts

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by the {@link Mutex} methods when the lock store fails (unreachable, a failed query, a file error), its
+ * message carrying the driver's error. An automatic renewal failing this way makes the lock lost instead. Its `errno` is
+ * `'E_MUTEX_DRIVER'`.
+ */
+export declare class MutexDriverException extends Exception {
+    /**
+     * `'E_MUTEX_DRIVER'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/mutex/exceptions/MutexDriverException.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutexDriverException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown by the {@link Mutex} methods when the lock store fails (unreachable, a failed query, a file error), its
+ * message carrying the driver's error. An automatic renewal failing this way makes the lock lost instead. Its `errno` is
+ * `'E_MUTEX_DRIVER'`.
+ */
+class MutexDriverException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MUTEX_DRIVER'`.
+         */
+        this.errno = 'E_MUTEX_DRIVER';
+    }
+}
+exports.MutexDriverException = MutexDriverException;

package/dist/cjs/mutex/exceptions/MutexDriverNotFoundException.d.ts

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by the first acquisition of a {@link Mutex} (or a driver) whose client package is not installed: `redis` for
+ * the Redis driver, `pg` for PostgreSQL, `mysql2` for MySQL. Its message names the package to install. Its `errno` is
+ * `'E_MUTEX_DRIVER_NOT_FOUND'`.
+ */
+export declare class MutexDriverNotFoundException extends Exception {
+    /**
+     * `'E_MUTEX_DRIVER_NOT_FOUND'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/mutex/exceptions/MutexDriverNotFoundException.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutexDriverNotFoundException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown by the first acquisition of a {@link Mutex} (or a driver) whose client package is not installed: `redis` for
+ * the Redis driver, `pg` for PostgreSQL, `mysql2` for MySQL. Its message names the package to install. Its `errno` is
+ * `'E_MUTEX_DRIVER_NOT_FOUND'`.
+ */
+class MutexDriverNotFoundException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MUTEX_DRIVER_NOT_FOUND'`.
+         */
+        this.errno = 'E_MUTEX_DRIVER_NOT_FOUND';
+    }
+}
+exports.MutexDriverNotFoundException = MutexDriverNotFoundException;

package/dist/cjs/mutex/exceptions/MutexLostException.d.ts

@@ -0,0 +1,13 @@
+import { Exception } from '@lakutata/core';
+/**
+ * The abort reason of {@link MutexLock.signal} when a lock is lost: a renewal found it expired or taken by another
+ * holder, a renewal failed, or the connection holding it closed. It is not thrown by the component: the work holding the
+ * lock meets it through the signal (`signal.throwIfAborted()`, an `AbortSignal`-aware API). Its `errno` is
+ * `'E_MUTEX_LOST'`.
+ */
+export declare class MutexLostException extends Exception {
+    /**
+     * `'E_MUTEX_LOST'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/mutex/exceptions/MutexLostException.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutexLostException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * The abort reason of {@link MutexLock.signal} when a lock is lost: a renewal found it expired or taken by another
+ * holder, a renewal failed, or the connection holding it closed. It is not thrown by the component: the work holding the
+ * lock meets it through the signal (`signal.throwIfAborted()`, an `AbortSignal`-aware API). Its `errno` is
+ * `'E_MUTEX_LOST'`.
+ */
+class MutexLostException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MUTEX_LOST'`.
+         */
+        this.errno = 'E_MUTEX_LOST';
+    }
+}
+exports.MutexLostException = MutexLostException;

package/dist/cjs/mutex/exceptions/MutexTimeoutException.d.ts

@@ -0,0 +1,16 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by {@link Mutex.acquire} and {@link Mutex.synchronized} when the lock is not acquired before the timeout
+ * (another holder kept it), and by a {@link Synchronized} action whose lock is held by another request (HTTP 409
+ * Conflict). Its `errno` is `'E_MUTEX_TIMEOUT'`.
+ */
+export declare class MutexTimeoutException extends Exception {
+    /**
+     * `'E_MUTEX_TIMEOUT'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status the transports answer with: 409 (Conflict).
+     */
+    statusCode: number;
+}

package/dist/cjs/mutex/exceptions/MutexTimeoutException.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutexTimeoutException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown by {@link Mutex.acquire} and {@link Mutex.synchronized} when the lock is not acquired before the timeout
+ * (another holder kept it), and by a {@link Synchronized} action whose lock is held by another request (HTTP 409
+ * Conflict). Its `errno` is `'E_MUTEX_TIMEOUT'`.
+ */
+class MutexTimeoutException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MUTEX_TIMEOUT'`.
+         */
+        this.errno = 'E_MUTEX_TIMEOUT';
+        /**
+         * The HTTP status the transports answer with: 409 (Conflict).
+         */
+        this.statusCode = 409;
+    }
+}
+exports.MutexTimeoutException = MutexTimeoutException;

package/dist/cjs/mutex/lib/LoadDriver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Load the client package of a driver (an optional dependency)
+ * @param member a member of its API, to find it in the ESM namespace or the CommonJS exports
+ * @param packageName
+ */
+export declare function loadDriver<T = any>(member: string, packageName: string): Promise<T>;

package/dist/cjs/mutex/lib/LoadDriver.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDriver = loadDriver;
+const MutexDriverNotFoundException_js_1 = require("../exceptions/MutexDriverNotFoundException.js");
+/**
+ * Whether an error reports the package itself as missing
+ * @param error
+ * @param packageName
+ */
+function isPackageMissing(error, packageName) {
+    const { code, message } = error;
+    if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND')
+        return false;
+    return !!message && (message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`));
+}
+/**
+ * Load the client package of a driver (an optional dependency)
+ * @param member a member of its API, to find it in the ESM namespace or the CommonJS exports
+ * @param packageName
+ */
+async function loadDriver(member, packageName) {
+    try {
+        const driver = await Promise.resolve(`${packageName}`).then(s => __importStar(require(s)));
+        return (driver[member] === undefined && driver.default ? driver.default : driver);
+    }
+    catch (e) {
+        if (!isPackageMissing(e, packageName))
+            throw e;
+    }
+    throw new MutexDriverNotFoundException_js_1.MutexDriverNotFoundException('Package "{packageName}" is required for this driver of the locks. Run "npm install {packageName}".', { packageName: packageName });
+}

package/dist/cjs/mutex/lib/Names.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The token of a lock acquired (its holder checked by it)
+ */
+export declare function lockToken(): string;
+/**
+ * The digest of the name of a lock (hexadecimal)
+ * @param name
+ */
+export declare function nameDigest(name: string): string;
+/**
+ * The key of 64 bits of the name of a lock (the advisory locks of PostgreSQL), a signed bigint as a string
+ * @param name
+ */
+export declare function nameKey64(name: string): string;

package/dist/cjs/mutex/lib/Names.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockToken = lockToken;
+exports.nameDigest = nameDigest;
+exports.nameKey64 = nameKey64;
+const node_crypto_1 = require("node:crypto");
+/**
+ * The token of a lock acquired (its holder checked by it)
+ */
+function lockToken() {
+    return (0, node_crypto_1.randomBytes)(16).toString('hex');
+}
+/**
+ * The digest of the name of a lock (hexadecimal)
+ * @param name
+ */
+function nameDigest(name) {
+    return (0, node_crypto_1.createHash)('sha256').update(name).digest('hex');
+}
+/**
+ * The key of 64 bits of the name of a lock (the advisory locks of PostgreSQL), a signed bigint as a string
+ * @param name
+ */
+function nameKey64(name) {
+    return (0, node_crypto_1.createHash)('sha256').update(name).digest().readBigInt64BE(0).toString();
+}

package/dist/cjs/mutex/options/FileMutexOptions.d.ts

@@ -0,0 +1,33 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the file driver ({@link FileMutexDriver}): one lock file per lock in a directory, shared by the
+ * processes of one host using the same directory (several workers or applications of a machine). It needs no package.
+ * The locks expire after their `ttl` unless renewed, a lock whose process is gone is taken over at once, and there is no
+ * fencing token.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'file-mutex.app',
+ *     name: 'FileMutex',
+ *     components: {
+ *         //Every worker of this machine uses the same directory
+ *         mutex: {class: Mutex, driver: {type: 'file', directory: '/var/lock/my-app'}}
+ *     }
+ * }))
+ * ```
+ */
+export declare class FileMutexOptions extends DTO {
+    /**
+     * The driver type: `'file'`.
+     */
+    type: 'file';
+    /**
+     * The directory of the lock files, created when missing. The processes sharing the locks must use the same one; the
+     * default depends on the operating system's temporary directory, which can differ between users.
+     * @default path.join(os.tmpdir(), 'lakutata-mutex')
+     */
+    directory?: string;
+}

package/dist/cjs/mutex/options/FileMutexOptions.js

@@ -0,0 +1,45 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMutexOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the file driver ({@link FileMutexDriver}): one lock file per lock in a directory, shared by the
+ * processes of one host using the same directory (several workers or applications of a machine). It needs no package.
+ * The locks expire after their `ttl` unless renewed, a lock whose process is gone is taken over at once, and there is no
+ * fencing token.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'file-mutex.app',
+ *     name: 'FileMutex',
+ *     components: {
+ *         //Every worker of this machine uses the same directory
+ *         mutex: {class: Mutex, driver: {type: 'file', directory: '/var/lock/my-app'}}
+ *     }
+ * }))
+ * ```
+ */
+class FileMutexOptions extends core_1.DTO {
+}
+exports.FileMutexOptions = FileMutexOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('file').required()),
+    __metadata("design:type", String)
+], FileMutexOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], FileMutexOptions.prototype, "directory", void 0);

package/dist/cjs/mutex/options/MemoryMutexOptions.d.ts

@@ -0,0 +1,27 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the memory driver ({@link MemoryMutexDriver}), the default of a {@link Mutex}: the locks live in the
+ * process memory, shared by the components of the process and invisible to the other processes. For development, tests
+ * and an application running as a single process; it needs no package. The locks expire after their `ttl` unless
+ * renewed, and carry fencing tokens counted by the process.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'memory-mutex.app',
+ *     name: 'MemoryMutex',
+ *     components: {
+ *         //The same as {class: Mutex}
+ *         mutex: {class: Mutex, driver: {type: 'memory'}}
+ *     }
+ * }))
+ * ```
+ */
+export declare class MemoryMutexOptions extends DTO {
+    /**
+     * The driver type: `'memory'`.
+     */
+    type: 'memory';
+}

package/dist/cjs/mutex/options/MemoryMutexOptions.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMutexOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the memory driver ({@link MemoryMutexDriver}), the default of a {@link Mutex}: the locks live in the
+ * process memory, shared by the components of the process and invisible to the other processes. For development, tests
+ * and an application running as a single process; it needs no package. The locks expire after their `ttl` unless
+ * renewed, and carry fencing tokens counted by the process.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'memory-mutex.app',
+ *     name: 'MemoryMutex',
+ *     components: {
+ *         //The same as {class: Mutex}
+ *         mutex: {class: Mutex, driver: {type: 'memory'}}
+ *     }
+ * }))
+ * ```
+ */
+class MemoryMutexOptions extends core_1.DTO {
+}
+exports.MemoryMutexOptions = MemoryMutexOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('memory').required()),
+    __metadata("design:type", String)
+], MemoryMutexOptions.prototype, "type", void 0);

package/dist/cjs/mutex/options/MysqlMutexOptions.d.ts

@@ -0,0 +1,70 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the MySQL driver ({@link MysqlMutexDriver}), for MySQL or MariaDB: the locks are shared by every
+ * instance connected to the same server. It needs the optional peer dependency `mysql2` (`npm install mysql2`, 3):
+ * without it, the first acquisition fails with {@link MutexDriverNotFoundException}. The driver connects at the first
+ * acquisition, not when the component is created.
+ *
+ * In the `'advisory'` mode (the default), the locks are named locks (`GET_LOCK`) of one connection: they do not expire,
+ * MySQL releases them when the connection closes (a crashed process frees them at once), and they are all lost when it
+ * closes or fails. They have no fencing token, and are not replicated by the clusters (Galera, Group Replication): every
+ * holder must connect to the same server. In the `'table'` mode, the locks are rows of a table created at the first use:
+ * they expire after their `ttl` unless renewed, work through the poolers and the clusters, and carry fencing tokens.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'mysql-mutex.app',
+ *     name: 'MysqlMutex',
+ *     components: {
+ *         mutex: {
+ *             class: Mutex,
+ *             driver: {type: 'mysql', host: 'db', database: 'app', username: 'app', password: process.env.DB_PASSWORD ?? ''}
+ *         }
+ *     }
+ * }))
+ * ```
+ */
+export declare class MysqlMutexOptions extends DTO {
+    /**
+     * The driver type: `'mysql'`.
+     */
+    type: 'mysql';
+    /**
+     * 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 (`''` for none).
+     */
+    password: string;
+    /**
+     * How the locks are held: `'advisory'`, named locks of one connection, released when it closes (no expiration, no
+     * fencing token, not replicated by the clusters); `'table'`, rows of a table expiring unless renewed, with fencing
+     * tokens, through the poolers and the clusters.
+     * @default 'advisory'
+     */
+    mode?: 'advisory' | 'table';
+    /**
+     * The table of the `table` mode, in the connection's database, created at the first use with its counter table
+     * `<table>_fence`; a name of letters, digits and `_`. An invalid name fails the validation of the options
+     * (`InvalidValueException`).
+     * @default 'lakutata_mutex'
+     */
+    table?: string;
+}

package/dist/cjs/mutex/options/MysqlMutexOptions.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlMutexOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The options of the MySQL driver ({@link MysqlMutexDriver}), for MySQL or MariaDB: the locks are shared by every
+ * instance connected to the same server. It needs the optional peer dependency `mysql2` (`npm install mysql2`, 3):
+ * without it, the first acquisition fails with {@link MutexDriverNotFoundException}. The driver connects at the first
+ * acquisition, not when the component is created.
+ *
+ * In the `'advisory'` mode (the default), the locks are named locks (`GET_LOCK`) of one connection: they do not expire,
+ * MySQL releases them when the connection closes (a crashed process frees them at once), and they are all lost when it
+ * closes or fails. They have no fencing token, and are not replicated by the clusters (Galera, Group Replication): every
+ * holder must connect to the same server. In the `'table'` mode, the locks are rows of a table created at the first use:
+ * they expire after their `ttl` unless renewed, work through the poolers and the clusters, and carry fencing tokens.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'mysql-mutex.app',
+ *     name: 'MysqlMutex',
+ *     components: {
+ *         mutex: {
+ *             class: Mutex,
+ *             driver: {type: 'mysql', host: 'db', database: 'app', username: 'app', password: process.env.DB_PASSWORD ?? ''}
+ *         }
+ *     }
+ * }))
+ * ```
+ */
+class MysqlMutexOptions extends core_1.DTO {
+}
+exports.MysqlMutexOptions = MysqlMutexOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('mysql').required()),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "host", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().port().optional().default(3306)),
+    __metadata("design:type", Number)
+], MysqlMutexOptions.prototype, "port", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "database", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').required()),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('advisory', 'table').optional().default('advisory')),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "mode", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().pattern(/^[a-zA-Z_][a-zA-Z0-9_]*$/).optional().default('lakutata_mutex')),
+    __metadata("design:type", String)
+], MysqlMutexOptions.prototype, "table", void 0);

package/dist/cjs/mutex/options/PostgresMutexOptions.d.ts

@@ -0,0 +1,83 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The options of the PostgreSQL driver ({@link PostgresMutexDriver}): the locks are shared by every instance connected
+ * to the same database. It needs the optional peer dependency `pg` (`npm install pg`, 8): without it, the first
+ * acquisition fails with {@link MutexDriverNotFoundException}. The driver connects at the first acquisition, not when
+ * the component is created.
+ *
+ * In the `'advisory'` mode (the default), the locks are session advisory locks of one connection: they do not expire,
+ * PostgreSQL releases them when the connection closes (a crashed process frees them at once), and they are all lost
+ * when it closes or fails. They have no fencing token, and do not work through a pooler in transaction mode
+ * (PgBouncer). In the `'table'` mode, the locks are rows of a table created at the first use: they expire after their
+ * `ttl` unless renewed, work through the poolers, and carry fencing tokens.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {Mutex} from 'lakutata/com/mutex'
+ *
+ * Application.run(() => ({
+ *     id: 'postgres-mutex.app',
+ *     name: 'PostgresMutex',
+ *     components: {
+ *         mutex: {
+ *             class: Mutex,
+ *             driver: {
+ *                 type: 'postgres',
+ *                 host: 'db',
+ *                 database: 'app',
+ *                 username: 'app',
+ *                 password: process.env.DB_PASSWORD ?? '',
+ *                 //Through PgBouncer: rows of a table, with fencing tokens
+ *                 mode: 'table'
+ *             }
+ *         }
+ *     }
+ * }))
+ * ```
+ */
+export declare class PostgresMutexOptions extends DTO {
+    /**
+     * The driver type: `'postgres'`.
+     */
+    type: 'postgres';
+    /**
+     * The host name or IP address of the server.
+     */
+    host: string;
+    /**
+     * The port of the server.
+     * @default 5432
+     */
+    port?: number;
+    /**
+     * The database holding the locks (and the table of the `table` mode).
+     */
+    database: string;
+    /**
+     * The user name.
+     */
+    username: string;
+    /**
+     * The password (`''` for none).
+     */
+    password: string;
+    /**
+     * Whether to connect with TLS (`ssl: true` given to `pg`, which verifies the server certificate).
+     * @default false
+     */
+    ssl?: boolean;
+    /**
+     * How the locks are held: `'advisory'`, session advisory locks of one connection, released when it closes (no
+     * expiration, no fencing token, not through a transaction pooler); `'table'`, rows of a table expiring unless renewed,
+     * with fencing tokens, through the poolers.
+     * @default 'advisory'
+     */
+    mode?: 'advisory' | 'table';
+    /**
+     * The table of the `table` mode, created at the first use with its sequence `<table>_fence`; a name of letters,
+     * digits and `_`, optionally qualified by its schema (`locks.mutex`). An invalid name fails the validation of the options
+     * (`InvalidValueException`).
+     * @default 'lakutata_mutex'
+     */
+    table?: string;
+}