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

package/dist/cjs/mutex/Synchronized.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The options of {@link Synchronized}: the lock component used, and how the lock is waited for and held.
+ */
+export type SynchronizedOptions = {
+    /**
+     * The name under which the {@link Mutex} component is registered, resolved from the controller's container.
+     * @default 'mutex'
+     */
+    mutex?: string;
+    /**
+     * How long the request waits for the lock, in milliseconds, before failing with a {@link MutexTimeoutException}.
+     * Ignored when `wait` is `false`.
+     * @default the component's `timeout` option (10000)
+     */
+    timeout?: number;
+    /**
+     * Whether to wait for the lock; `false` fails the request at once with a {@link MutexTimeoutException} (HTTP 409)
+     * when another request holds the lock.
+     * @default true
+     */
+    wait?: boolean;
+    /**
+     * How long the lock stays held without a renewal, in milliseconds (renewed automatically while the action runs).
+     * @default the component's `ttl` option (30000)
+     */
+    ttl?: number;
+};
+/**
+ * Build a lock name from a template, replacing each `{field}` with that field of the input (`{a.b}` reads a nested
+ * field). {@link Synchronized} uses it for its template names; a template without `{}` is returned as it is.
+ * @param template The template, such as `'order:{id}'` or `'user:{user.id}:export'`.
+ * @param input The object whose fields fill the template (an action's validated input).
+ * @returns The lock name.
+ * @throws {TypeError} When a field of the template is missing, `null`, or an object (only strings, numbers and other
+ * primitives are accepted).
+ * @example
+ * ```typescript
+ * import {lockNameOf} from 'lakutata/com/mutex'
+ *
+ * console.log(lockNameOf('order:{id}', {id: 42})) //order:42
+ * console.log(lockNameOf('user:{user.id}:export', {user: {id: 'u7'}})) //user:u7:export
+ * ```
+ */
+export declare function lockNameOf(template: string, input: unknown): string;
+/**
+ * Run a controller action holding a lock, acquired once its input is validated and its access control passed, released
+ * after it (whether it returns or throws). The requests needing the same lock run one at a time in every instance
+ * sharing the lock store, whatever their transport (HTTP, CLI, service); the others run in parallel.
+ *
+ * The lock comes from the {@link Mutex} component registered as `mutex` (or `options.mutex`); a missing component
+ * fails the request. The wait for the lock stops when the request is aborted (its client gone), and a request not
+ * getting the lock in time fails with a {@link MutexTimeoutException} (HTTP 409). The action is not interrupted when
+ * its lock is lost: check the controller's `this.signal` for a long work.
+ * @param name The lock name: a template filled from the fields of the action's input (`'order:{id}'`, see
+ * {@link lockNameOf}; a missing field fails the request with a `TypeError`), or a function of the input and the
+ * request's context returning it.
+ * @param options The lock component, the wait and the lock's `ttl`.
+ * @returns The method decorator.
+ * @throws {TypeError} When the class is declared, if the name is neither a non-empty string nor a function, or if the
+ * decorated member is not a method.
+ * @throws {MutexTimeoutException} From the action, when the lock is not acquired in time (HTTP 409).
+ * @throws {MutexDriverException} From the action, when the lock store fails.
+ * @example
+ * ```typescript
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Synchronized} from 'lakutata/com/mutex'
+ *
+ * class OrderController extends Controller {
+ *     //The payments of an order one at a time, the other orders in parallel
+ *     @ServiceAction({cmd: 'order.pay'})
+ *     @Synchronized('order:{id}')
+ *     public async pay(input: {id: number}): Promise<void> {
+ *     }
+ *
+ *     //Fails at once (HTTP 409) while another request rebuilds the index
+ *     @ServiceAction({cmd: 'search.reindex'})
+ *     @Synchronized('search:reindex', {wait: false})
+ *     public async reindex(): Promise<void> {
+ *     }
+ *
+ *     //A lock named by a function, from the component registered as "locks"
+ *     @ServiceAction({cmd: 'user.export'})
+ *     @Synchronized((input: {userId: string}): string => `export:${input.userId}`, {timeout: 5000, mutex: 'locks'})
+ *     public async export(input: {userId: string}): Promise<void> {
+ *     }
+ * }
+ * ```
+ */
+export declare function Synchronized(name: string | ((input: any, context: any) => string), options?: SynchronizedOptions): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/cjs/mutex/Synchronized.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockNameOf = lockNameOf;
+exports.Synchronized = Synchronized;
+/**
+ * Build a lock name from a template, replacing each `{field}` with that field of the input (`{a.b}` reads a nested
+ * field). {@link Synchronized} uses it for its template names; a template without `{}` is returned as it is.
+ * @param template The template, such as `'order:{id}'` or `'user:{user.id}:export'`.
+ * @param input The object whose fields fill the template (an action's validated input).
+ * @returns The lock name.
+ * @throws {TypeError} When a field of the template is missing, `null`, or an object (only strings, numbers and other
+ * primitives are accepted).
+ * @example
+ * ```typescript
+ * import {lockNameOf} from 'lakutata/com/mutex'
+ *
+ * console.log(lockNameOf('order:{id}', {id: 42})) //order:42
+ * console.log(lockNameOf('user:{user.id}:export', {user: {id: 'u7'}})) //user:u7:export
+ * ```
+ */
+function lockNameOf(template, input) {
+    return template.replace(/\{([^{}]+)}/g, (_, field) => {
+        const value = field.split('.').reduce((current, key) => current === null || current === undefined ? undefined : current[key], input);
+        if (value === undefined || value === null || (typeof value === 'object'))
+            throw new TypeError(`The lock "${template}" needs the field ${field} of the input of the action (a string or a number)`);
+        return String(value);
+    });
+}
+/**
+ * Run a controller action holding a lock, acquired once its input is validated and its access control passed, released
+ * after it (whether it returns or throws). The requests needing the same lock run one at a time in every instance
+ * sharing the lock store, whatever their transport (HTTP, CLI, service); the others run in parallel.
+ *
+ * The lock comes from the {@link Mutex} component registered as `mutex` (or `options.mutex`); a missing component
+ * fails the request. The wait for the lock stops when the request is aborted (its client gone), and a request not
+ * getting the lock in time fails with a {@link MutexTimeoutException} (HTTP 409). The action is not interrupted when
+ * its lock is lost: check the controller's `this.signal` for a long work.
+ * @param name The lock name: a template filled from the fields of the action's input (`'order:{id}'`, see
+ * {@link lockNameOf}; a missing field fails the request with a `TypeError`), or a function of the input and the
+ * request's context returning it.
+ * @param options The lock component, the wait and the lock's `ttl`.
+ * @returns The method decorator.
+ * @throws {TypeError} When the class is declared, if the name is neither a non-empty string nor a function, or if the
+ * decorated member is not a method.
+ * @throws {MutexTimeoutException} From the action, when the lock is not acquired in time (HTTP 409).
+ * @throws {MutexDriverException} From the action, when the lock store fails.
+ * @example
+ * ```typescript
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Synchronized} from 'lakutata/com/mutex'
+ *
+ * class OrderController extends Controller {
+ *     //The payments of an order one at a time, the other orders in parallel
+ *     @ServiceAction({cmd: 'order.pay'})
+ *     @Synchronized('order:{id}')
+ *     public async pay(input: {id: number}): Promise<void> {
+ *     }
+ *
+ *     //Fails at once (HTTP 409) while another request rebuilds the index
+ *     @ServiceAction({cmd: 'search.reindex'})
+ *     @Synchronized('search:reindex', {wait: false})
+ *     public async reindex(): Promise<void> {
+ *     }
+ *
+ *     //A lock named by a function, from the component registered as "locks"
+ *     @ServiceAction({cmd: 'user.export'})
+ *     @Synchronized((input: {userId: string}): string => `export:${input.userId}`, {timeout: 5000, mutex: 'locks'})
+ *     public async export(input: {userId: string}): Promise<void> {
+ *     }
+ * }
+ * ```
+ */
+function Synchronized(name, options = {}) {
+    if (typeof name !== 'function' && (typeof name !== 'string' || !name))
+        throw new TypeError('The lock of a synchronized action is a template or a function');
+    return (_target, propertyKey, descriptor) => {
+        const action = descriptor.value;
+        if (typeof action !== 'function')
+            throw new TypeError(`@Synchronized decorates a method (${String(propertyKey)})`);
+        descriptor.value = async function (...args) {
+            const input = args[0] ?? {};
+            const lockName = typeof name === 'function' ? name(input, this.context) : lockNameOf(name, input);
+            const mutex = await this.getObject(options.mutex ?? 'mutex');
+            return await mutex.synchronized(lockName, (_lock) => action.apply(this, args), {
+                timeout: options.wait === false ? 0 : options.timeout,
+                ttl: options.ttl,
+                signal: this.signal
+            });
+        };
+        return descriptor;
+    };
+}

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

@@ -0,0 +1,115 @@
+import { MutexDriver, type DriverLock } from './MutexDriver.js';
+/**
+ * The content of a lock file: its holder (its token, its process and its host), its expiration
+ */
+type LockFile = {
+    name: string;
+    token: string;
+    pid: number;
+    host: string;
+    expires: number;
+};
+/**
+ * The file driver (`{type: 'file'}`): each lock is a file of a directory, created exclusively, shared by the processes of
+ * one host using the same directory and prefix (several workers or applications of a machine). It needs no package.
+ * The processes must share the directory: the default one (`lakutata-mutex` in the operating system's temporary
+ * directory) can differ between users. A directory shared by several hosts (a network file system) works only as far
+ * as its exclusive creation and renames are atomic, and only the expiration then frees the lock of a crashed host.
+ *
+ * The locks expire after their `ttl` unless renewed; a lock whose process is gone on this host is taken over at once,
+ * without waiting for its expiration. The driver gives no fencing token (`fence` is `undefined`).
+ * @example
+ * ```typescript
+ * import {FileMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * //The workers of this machine run the migration one at a time
+ * const driver: FileMutexDriver = new FileMutexDriver('/var/lock/my-app', 'my-app:')
+ * const lock: DriverLock | undefined = await driver.acquire('migrate', 60000)
+ * if (lock) {
+ *     try {
+ *         console.log('migrating')
+ *     } finally {
+ *         await driver.release('migrate', lock)
+ *     }
+ * }
+ * ```
+ */
+export declare class FileMutexDriver extends MutexDriver {
+    #private;
+    protected readonly directory: string;
+    protected readonly prefix: string;
+    /**
+     * `true`: the locks expire after their `ttl` unless renewed.
+     */
+    readonly expiring: boolean;
+    /**
+     * Create a driver on a directory, created at the first acquisition when it does not exist.
+     * @param directory The directory of the lock files.
+     * @param prefix The prefix added to the lock names; `''` by default.
+     */
+    constructor(directory: string, prefix?: string);
+    /**
+     * The path of a lock's file: the SHA-256 digest of the prefixed name, with the extension `.lock`.
+     * @param name The lock name.
+     * @returns The file path.
+     */
+    protected file(name: string): string;
+    /**
+     * Read a lock file.
+     * @param file The file path.
+     * @returns Its content, or `undefined` when it does not exist or cannot be parsed (being written).
+     */
+    protected read(file: string): Promise<LockFile | undefined>;
+    /**
+     * Whether a lock file is no longer held: expired, or written by another process of this host which no longer runs.
+     * @param lock The content of the lock file.
+     * @returns Whether it may be taken over.
+     */
+    protected stale(lock: LockFile): boolean;
+    /**
+     * Whether a lock file which cannot be read was abandoned (its process ended while writing it) rather than being
+     * written: unchanged for more than 5 seconds.
+     * @param file The file path.
+     * @returns Whether it may be taken over.
+     */
+    protected abandoned(file: string): Promise<boolean>;
+    /**
+     * Remove a lock file when it is still the one read, by renaming it first so that only one process takes it. A file
+     * of another holder taken by mistake is put back when its place is still free.
+     * @param file The file path.
+     * @param token The token read in the file, or `undefined` for a file which could not be read.
+     * @returns Whether the file was removed.
+     */
+    protected take(file: string, token: string | undefined): Promise<boolean>;
+    /**
+     * Try to acquire a lock once: create its file exclusively, or take over a file expired, abandoned, or whose process
+     * of this host is gone.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds.
+     * @returns The lock (without fencing token), or `undefined` when another holder has it.
+     * @throws {Error} When the directory cannot be created or the file written (permissions, disk full).
+     */
+    acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * Release a lock by removing its file, when the file still holds this holder's token.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released.
+     */
+    release(name: string, lock: DriverLock): Promise<boolean>;
+    /**
+     * Renew a lock whose file still holds this holder's token, for `ttl` milliseconds from now: the file is taken away
+     * (renamed), checked, rewritten and given back without replacing a lock another process acquired meanwhile (the
+     * renewal fails then). A lock expired is not renewed (lost), even when no other process took it over 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.
+     */
+    extend(name: string, lock: DriverLock, ttl: number): Promise<boolean>;
+    /**
+     * Do nothing: the driver keeps no file open; the lock files stay until they are released or taken over.
+     */
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMutexDriver = void 0;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const MutexDriver_js_1 = require("./MutexDriver.js");
+const Names_js_1 = require("../lib/Names.js");
+/**
+ * Whether a process of this host runs
+ * @param pid
+ */
+function processRuns(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        //Running, but not ours to signal
+        return error.code === 'EPERM';
+    }
+}
+/**
+ * The file driver (`{type: 'file'}`): each lock is a file of a directory, created exclusively, shared by the processes of
+ * one host using the same directory and prefix (several workers or applications of a machine). It needs no package.
+ * The processes must share the directory: the default one (`lakutata-mutex` in the operating system's temporary
+ * directory) can differ between users. A directory shared by several hosts (a network file system) works only as far
+ * as its exclusive creation and renames are atomic, and only the expiration then frees the lock of a crashed host.
+ *
+ * The locks expire after their `ttl` unless renewed; a lock whose process is gone on this host is taken over at once,
+ * without waiting for its expiration. The driver gives no fencing token (`fence` is `undefined`).
+ * @example
+ * ```typescript
+ * import {FileMutexDriver, type DriverLock} from 'lakutata/com/mutex'
+ *
+ * //The workers of this machine run the migration one at a time
+ * const driver: FileMutexDriver = new FileMutexDriver('/var/lock/my-app', 'my-app:')
+ * const lock: DriverLock | undefined = await driver.acquire('migrate', 60000)
+ * if (lock) {
+ *     try {
+ *         console.log('migrating')
+ *     } finally {
+ *         await driver.release('migrate', lock)
+ *     }
+ * }
+ * ```
+ */
+class FileMutexDriver extends MutexDriver_js_1.MutexDriver {
+    #host;
+    /**
+     * Create a driver on a directory, created at the first acquisition when it does not exist.
+     * @param directory The directory of the lock files.
+     * @param prefix The prefix added to the lock names; `''` by default.
+     */
+    constructor(directory, prefix = '') {
+        super();
+        this.directory = directory;
+        this.prefix = prefix;
+        /**
+         * `true`: the locks expire after their `ttl` unless renewed.
+         */
+        this.expiring = true;
+        this.#host = (0, node_os_1.hostname)();
+    }
+    /**
+     * The path of a lock's file: the SHA-256 digest of the prefixed name, with the extension `.lock`.
+     * @param name The lock name.
+     * @returns The file path.
+     */
+    file(name) {
+        return node_path_1.default.join(this.directory, `${(0, Names_js_1.nameDigest)(this.prefix + name)}.lock`);
+    }
+    /**
+     * Read a lock file.
+     * @param file The file path.
+     * @returns Its content, or `undefined` when it does not exist or cannot be parsed (being written).
+     */
+    async read(file) {
+        try {
+            return JSON.parse(await (0, promises_1.readFile)(file, 'utf8'));
+        }
+        catch {
+            //Not there, or being written
+            return undefined;
+        }
+    }
+    /**
+     * Whether a lock file is no longer held: expired, or written by another process of this host which no longer runs.
+     * @param lock The content of the lock file.
+     * @returns Whether it may be taken over.
+     */
+    stale(lock) {
+        return lock.expires <= Date.now() || (lock.host === this.#host && lock.pid !== process.pid && !processRuns(lock.pid));
+    }
+    /**
+     * Whether a lock file which cannot be read was abandoned (its process ended while writing it) rather than being
+     * written: unchanged for more than 5 seconds.
+     * @param file The file path.
+     * @returns Whether it may be taken over.
+     */
+    async abandoned(file) {
+        try {
+            return Date.now() - (await (0, promises_1.stat)(file)).mtimeMs > 5000;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Remove a lock file when it is still the one read, by renaming it first so that only one process takes it. A file
+     * of another holder taken by mistake is put back when its place is still free.
+     * @param file The file path.
+     * @param token The token read in the file, or `undefined` for a file which could not be read.
+     * @returns Whether the file was removed.
+     */
+    async take(file, token) {
+        const taken = `${file}.${(0, Names_js_1.lockToken)()}`;
+        try {
+            await (0, promises_1.rename)(file, taken);
+        }
+        catch {
+            return false;
+        }
+        const content = await this.read(taken);
+        if (content?.token === token) {
+            await (0, promises_1.unlink)(taken).catch(() => undefined);
+            return true;
+        }
+        //Another lock was taken: given back when its place is free
+        await (0, promises_1.link)(taken, file).catch(() => undefined);
+        await (0, promises_1.unlink)(taken).catch(() => undefined);
+        return false;
+    }
+    /**
+     * Try to acquire a lock once: create its file exclusively, or take over a file expired, abandoned, or whose process
+     * of this host is gone.
+     * @param name The lock name.
+     * @param ttl How long the lock stays held without a renewal, in milliseconds.
+     * @returns The lock (without fencing token), or `undefined` when another holder has it.
+     * @throws {Error} When the directory cannot be created or the file written (permissions, disk full).
+     */
+    async acquire(name, ttl) {
+        await (0, promises_1.mkdir)(this.directory, { recursive: true });
+        const file = this.file(name);
+        const lock = { token: (0, Names_js_1.lockToken)() };
+        const content = JSON.stringify({ name: name, token: lock.token, pid: process.pid, host: this.#host, expires: Date.now() + ttl });
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                await (0, promises_1.writeFile)(file, content, { flag: 'wx' });
+                return lock;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            const current = await this.read(file);
+            if (current ? !this.stale(current) : !(await this.abandoned(file)))
+                return undefined;
+            if (!(await this.take(file, current?.token)))
+                return undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Release a lock by removing its file, when the file still holds this holder's token.
+     * @param name The lock name.
+     * @param lock The lock acquired.
+     * @returns Whether it was released.
+     */
+    async release(name, lock) {
+        const file = this.file(name);
+        if ((await this.read(file))?.token !== lock.token)
+            return false;
+        return await this.take(file, lock.token);
+    }
+    /**
+     * Renew a lock whose file still holds this holder's token, for `ttl` milliseconds from now: the file is taken away
+     * (renamed), checked, rewritten and given back without replacing a lock another process acquired meanwhile (the
+     * renewal fails then). A lock expired is not renewed (lost), even when no other process took it over 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 file = this.file(name);
+        const current = await this.read(file);
+        //Expired: lost, even when nobody took it yet
+        if (current?.token !== lock.token || current.expires <= Date.now())
+            return false;
+        //Taken away (renamed: only one taker has it) and checked, renewed, then given back without replacing a lock
+        //acquired meanwhile (linked: it fails when the file exists)
+        const taken = `${file}.${(0, Names_js_1.lockToken)()}`;
+        try {
+            await (0, promises_1.rename)(file, taken);
+        }
+        catch {
+            return false;
+        }
+        const content = await this.read(taken);
+        if (content?.token !== lock.token) {
+            //Another holder's lock, taken over meanwhile: given back
+            await (0, promises_1.link)(taken, file).catch(() => undefined);
+            await (0, promises_1.unlink)(taken).catch(() => undefined);
+            return false;
+        }
+        await (0, promises_1.writeFile)(taken, JSON.stringify({ ...content, expires: Date.now() + ttl }));
+        try {
+            await (0, promises_1.link)(taken, file);
+            return true;
+        }
+        catch {
+            //Acquired by another process while it was taken away: lost
+            return false;
+        }
+        finally {
+            await (0, promises_1.unlink)(taken).catch(() => undefined);
+        }
+    }
+    /**
+     * Do nothing: the driver keeps no file open; the lock files stay until they are released or taken over.
+     */
+    async close() {
+        //Nothing kept open
+    }
+}
+exports.FileMutexDriver = FileMutexDriver;

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

@@ -0,0 +1,60 @@
+import { MutexDriver, type DriverLock } from './MutexDriver.js';
+/**
+ * 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()
+ * ```
+ */
+export declare class MemoryMutexDriver extends MutexDriver {
+    #private;
+    protected readonly prefix: string;
+    /**
+     * `true`: the locks expire after their `ttl` unless renewed.
+     */
+    readonly expiring: boolean;
+    /**
+     * 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?: string);
+    /**
+     * 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.
+     */
+    acquire(name: string, ttl: number): Promise<DriverLock | undefined>;
+    /**
+     * 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).
+     */
+    release(name: string, lock: DriverLock): Promise<boolean>;
+    /**
+     * 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.
+     */
+    extend(name: string, lock: DriverLock, ttl: number): Promise<boolean>;
+    /**
+     * Do nothing: the locks stay in the process memory until they are released or expire.
+     */
+    close(): Promise<void>;
+}