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

package/dist/types/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/types/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/types/mutex/drivers/PostgresMutexDriver.d.ts

@@ -0,0 +1,136 @@
+import { MutexDriver, type DriverLock } from './MutexDriver.js';
+/**
+ * The PostgreSQL connection of a {@link PostgresMutexDriver}.
+ */
+export type PostgresMutexConnection = {
+    /**
+     * 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.
+     */
+    password: string;
+    /**
+     * Whether to connect with TLS (`ssl: true` given to `pg`, which verifies the server certificate).
+     * @default false
+     */
+    ssl?: boolean;
+};
+/**
+ * The PostgreSQL driver (`{type: 'postgres'}`): the locks are shared by every instance connected to the same database
+ * with the same prefix. It needs the optional peer dependency `pg` (8); without it, the first acquisition fails with
+ * {@link MutexDriverNotFoundException}. It has two modes:
+ * - `'advisory'` (the default): session advisory locks (`pg_try_advisory_lock`) taken on one connection of the driver,
+ *   opened at the first use. They do not expire and need no renewal: PostgreSQL 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 lock names are hashed to 64-bit keys,
+ *   shared with the other advisory locks of the database. It does not work through a pooler in transaction mode
+ *   (PgBouncer), which does not keep the session.
+ * - `'table'`: one row per lock in a table, created at the first use with its sequence `<table>_fence`. The rows expire
+ *   by the database clock after their `ttl` unless renewed, so it works through the poolers and on the replicated
+ *   setups writing to one primary, and each acquisition gets a fencing token from the sequence. A pool of 4 connections
+ *   is used.
+ * @example
+ * ```typescript
+ * import {PostgresMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * const driver: PostgresMutexDriver = new PostgresMutexDriver({
+ *     host: '127.0.0.1',
+ *     database: 'app',
+ *     username: 'app',
+ *     password: 'secret'
+ * }, 'my-app:', 'table', 'app_locks')
+ * const lock: DriverLock | undefined = await driver.acquire('invoice:7', 30000)
+ * if (lock) await driver.release('invoice:7', lock)
+ * await driver.close()
+ * ```
+ */
+export declare class PostgresMutexDriver extends MutexDriver {
+    #private;
+    protected readonly connection: PostgresMutexConnection;
+    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 PostgreSQL database; it connects at its first use.
+     * @param connection The connection to the database.
+     * @param prefix The prefix added to the lock names.
+     * @param mode `'advisory'` (the default) or `'table'`.
+     * @param table The table of the `table` mode, optionally qualified by its schema (`locks.mutex`); `'lakutata_mutex'`
+     * by default.
+     * @throws {Error} When the table is not a valid PostgreSQL name (letters, digits and `_`, not starting with a digit).
+     */
+    constructor(connection: PostgresMutexConnection, prefix: string, mode?: 'advisory' | 'table', table?: string);
+    /**
+     * The configuration given to `pg` for the connection.
+     * @returns The `pg` client configuration.
+     */
+    protected config(): Record<string, unknown>;
+    /**
+     * The connection holding the advisory locks, opened at the first call; when it ends or fails, its locks are reported
+     * lost through {@link MutexDriver.onLost}.
+     * @returns The connected `pg` client.
+     * @throws {MutexDriverNotFoundException} When the package `pg` is not installed.
+     * @protected
+     */
+    protected client(): Promise<any>;
+    /**
+     * The connection pool of the `table` mode, created at the first call along with the table and its sequence; created
+     * again at the next call when that fails.
+     * @returns The `pg` pool.
+     * @throws {MutexDriverNotFoundException} When the package `pg` is not installed.
+     * @protected
+     */
+    protected pool(): Promise<any>;
+    /**
+     * Try to acquire a lock once: an advisory 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 `pg` is not installed.
+     */
+    acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * Release a lock still held by this holder: unlock the advisory 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 (PostgreSQL releases its advisory locks) and the pool; the rows of the `table` mode stay until
+     * they expire.
+     */
+    close(): Promise<void>;
+}

package/dist/types/mutex/drivers/RedisMutexDriver.d.ts

@@ -0,0 +1,129 @@
+import { MutexDriver, type DriverLock } from './MutexDriver.js';
+/**
+ * The Redis connection of a {@link RedisMutexDriver}: a `url`, or a `host` and a `port`.
+ */
+export type RedisMutexConnection = {
+    /**
+     * The server URL (`redis://user:password@host:6379/0`, `rediss://` for TLS). When set, `host`, `port` and `tls` are
+     * ignored; `username`, `password` and `database` apply when the URL does not give them.
+     * @default none
+     */
+    url?: string;
+    /**
+     * The host name or IP address of the server.
+     * @default '127.0.0.1'
+     */
+    host?: string;
+    /**
+     * The port of the server.
+     * @default 6379
+     */
+    port?: number;
+    /**
+     * The index of the Redis database.
+     * @default 0
+     */
+    database?: number;
+    /**
+     * The user name (Redis 6 ACL).
+     * @default none (the default user)
+     */
+    username?: string;
+    /**
+     * The password.
+     * @default none
+     */
+    password?: string;
+    /**
+     * Whether to connect with TLS (ignored with a `url`: use `rediss://`).
+     * @default false
+     */
+    tls?: boolean;
+};
+/**
+ * The Redis driver (`{type: 'redis'}`): the locks are Redis keys holding their holder's token, shared by every instance
+ * connected to the same server (or cluster) with the same prefix. It needs the optional peer dependency `redis` (4.6 or
+ * 5); without it, the first acquisition fails with {@link MutexDriverNotFoundException}.
+ *
+ * The keys expire after their `ttl` unless renewed (`PEXPIRE`), and are released and renewed only for their holder's
+ * token. Each acquisition increments a fencing token kept in a second key (`<key>:fence`, never expiring); the lock's
+ * name is the key's hash tag, so both keys stay in the same slot of a cluster. Configure the server with
+ * `maxmemory-policy noeviction`: an evicted key is a lock lost. The locks of one primary are lost if it fails over before
+ * replicating them.
+ *
+ * The client connects at the first use. While the server cannot be reached, the calls wait for it to come back
+ * instead of failing (the client retries without limit): an acquisition does not end at its timeout, and the renewals
+ * do not complete, so the held locks are not marked lost while their keys may expire in Redis.
+ * @example
+ * ```typescript
+ * import {RedisMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * const driver: RedisMutexDriver = new RedisMutexDriver({url: 'redis://127.0.0.1:6379'}, 'my-app:')
+ * const lock: DriverLock | undefined = await driver.acquire('invoice:7', 30000)
+ * if (lock) {
+ *     //Increases with each acquisition: written along with the data to refuse an older holder's writes
+ *     console.log(lock.fence)
+ *     await driver.release('invoice:7', lock)
+ * }
+ * await driver.close()
+ * ```
+ */
+export declare class RedisMutexDriver extends MutexDriver {
+    #private;
+    protected readonly connection: RedisMutexConnection;
+    protected readonly prefix: string;
+    /**
+     * `true`: the locks expire after their `ttl` unless renewed.
+     */
+    readonly expiring: boolean;
+    /**
+     * Create a driver on a Redis server; it connects at its first use.
+     * @param connection The connection to the server.
+     * @param prefix The prefix of the keys.
+     */
+    constructor(connection: RedisMutexConnection, prefix: string);
+    /**
+     * The Redis client, connected at the first call; the concurrent first calls share one connection. An unreachable
+     * server fails the calls: the first connection is given up after 5 seconds, and while the client reconnects the
+     * calls fail at once (its commands are not queued).
+     * @returns The connected client.
+     * @throws {MutexDriverNotFoundException} When the package `redis` is not installed.
+     * @throws {Error} When the server is not reachable.
+     * @protected
+     */
+    protected client(): Promise<any>;
+    /**
+     * The key of a lock: `<prefix>{<name>}`, the name being the hash tag that keeps the lock and its fencing token in the
+     * same slot of a cluster.
+     * @param name The lock name.
+     * @returns The Redis key.
+     */
+    protected key(name: string): string;
+    /**
+     * Try to acquire a lock once: set its key when it does not exist, with a fencing token incremented.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds (rounded up).
+     * @returns The lock with its fencing token, or `undefined` when another holder has it.
+     * @throws {MutexDriverNotFoundException} When the package `redis` is not installed.
+     */
+    acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * Release a lock by deleting its key, when it still holds this holder's token.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released (`false` when the key expired or was taken).
+     */
+    release(name: string, lock: DriverLock): Promise<boolean>;
+    /**
+     * Renew a lock whose key still holds this holder's token, for `ttl` milliseconds from now.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @param ttl How long the lock stays held without another renewal, in milliseconds (rounded up).
+     * @returns Whether it was renewed (`false` when the key expired or was taken).
+     */
+    extend(name: string, lock: DriverLock, ttl: number): Promise<boolean>;
+    /**
+     * Close the connection (`QUIT`, or a disconnection when it fails); the keys stay until they expire.
+     */
+    close(): Promise<void>;
+}

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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';
+}