velocious 1.0.430 → 1.0.431

package/build/src/database/drivers/sqlite/index.js

@@ -1,351 +1,394 @@
 // @ts-check
-import { createHash } from "node:crypto";
-import wait from "awaitery/build/wait.js";
-import fs from "fs/promises";
-import os from "node:os";
-import path from "node:path";
-import query from "./query.js";
-import sqlite3 from "sqlite3";
-import { open } from "sqlite";
-import Base from "./base.js";
-import fileExists from "../../../utils/file-exists.js";
+
+import {createHash} from "node:crypto"
+import wait from "awaitery/build/wait.js"
+import fs from "fs/promises"
+import os from "node:os"
+import path from "node:path"
+import query from "./query.js"
+import sqlite3 from "sqlite3"
+import {open} from "sqlite"
+
+import Base from "./base.js"
+import fileExists from "../../../utils/file-exists.js"
+
 export default class VelociousDatabaseDriversSqliteNode extends Base {
-    /**
-     * Connection.
-      @type {import("sqlite3").Database | undefined} */
-    connection = undefined;
-    /**
-     * Advisory lock directory.
-      @type {string | undefined} */
-    _advisoryLockDirectory = undefined;
-    async connect() {
-        const args = this.getArgs();
-        const databaseDir = `${this.getConfiguration().getDirectory()}/db`;
-        const databasePath = `${databaseDir}/${this.localStorageName()}.sqlite`;
-        if (!await fileExists(databaseDir)) {
-            await fs.mkdir(databaseDir, { recursive: true });
-        }
-        if (args.reset) {
-            await fs.unlink(databasePath);
-        }
-        this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`);
-        try {
-            // @ts-expect-error
-            this.connection = /** Narrows the runtime value to the documented type. @type {import("sqlite3").Database} */ (await open({
-                filename: databasePath,
-                driver: sqlite3.Database
-            }));
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new Error(`Couldn't open database ${databasePath} because of ${error.constructor.name}: ${error.message}`, { cause: error });
-            }
-            else {
-                throw new Error(`Couldn't open database ${databasePath} because of ${typeof error}: ${error}`, { cause: error });
-            }
-        }
-        await this.registerVersion();
+  /**
+   * Connection.
+    @type {import("sqlite3").Database | undefined} */
+  connection = undefined
+
+  /**
+   * Advisory lock directory.
+    @type {string | undefined} */
+  _advisoryLockDirectory = undefined
+
+  async connect() {
+    const args = this.getArgs()
+    const databaseDir = `${this.getConfiguration().getDirectory()}/db`
+    const databasePath = `${databaseDir}/${this.localStorageName()}.sqlite`
+
+    if (!await fileExists(databaseDir)) {
+      await fs.mkdir(databaseDir, {recursive: true})
     }
-    localStorageName() {
-        const args = this.getArgs();
-        if (!args.name)
-            throw new Error("No name given for SQLite Node");
-        return `VelociousDatabaseDriversSqlite---${args.name}`;
+
+    if (args.reset) {
+      await fs.unlink(databasePath)
     }
-    async close() {
-        await this.connection?.close();
-        this.connection = undefined;
+
+    this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`)
+
+    try {
+      // @ts-expect-error
+      this.connection = /** Narrows the runtime value to the documented type. @type {import("sqlite3").Database} */ (await open({
+        filename: databasePath,
+        driver: sqlite3.Database
+      }))
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Couldn't open database ${databasePath} because of ${error.constructor.name}: ${error.message}`, {cause: error})
+      } else {
+        throw new Error(`Couldn't open database ${databasePath} because of ${typeof error}: ${error}`, {cause: error})
+      }
     }
-    /**
-     * Runs query actual.
-     * @param {string} sql - SQL string.
-     * @returns {Promise<Record<string, ?>[]>} - Resolves with the query actual.
-     */
-    async _queryActual(sql) {
-        if (!this.connection)
-            throw new Error("No connection");
-        return await query(this.connection, sql);
+
+    await this.registerVersion()
+  }
+
+  localStorageName() {
+    const args = this.getArgs()
+
+    if (!args.name) throw new Error("No name given for SQLite Node")
+
+    return `VelociousDatabaseDriversSqlite---${args.name}`
+  }
+
+  async close() {
+    await this.connection?.close()
+    this.connection = undefined
+  }
+
+  /**
+   * Runs query actual.
+   * @param {string} sql - SQL string.
+   * @returns {Promise<Record<string, ?>[]>} - Resolves with the query actual.
+   */
+  async _queryActual(sql) {
+    if (!this.connection) throw new Error("No connection")
+
+    return await query(this.connection, sql)
+  }
+
+  /**
+   * Layers a filesystem lock directory on top of the in-process waiter
+   * queue so SQLite deployments with multiple Node processes writing to
+   * the same database file see consistent advisory-lock mutual exclusion
+   * across processes, not just within a single process.
+   *
+   * The in-process queue from the shared SQLite base class is still used
+   * for the fast intra-process path (no polling, waiters wake each other
+   * through the `Set<string>` + waiter queue); the filesystem lock is
+   * only checked once the in-process queue has granted the caller, so
+   * typical single-process traffic pays at most two `fs.mkdir` calls
+   * (create and remove) per critical section.
+   * @param {string} name - Lock name.
+   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
+   * @returns {Promise<boolean>}
+   */
+  async acquireAdvisoryLock(name, {timeoutMs} = {}) {
+    const deadline = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null
+    const remainingForInProcess = deadline !== null ? Math.max(0, deadline - Date.now()) : null
+    const inProcessAcquired = await super.acquireAdvisoryLock(name, {timeoutMs: remainingForInProcess})
+
+    if (!inProcessAcquired) return false
+
+    try {
+      const remainingForFile = deadline !== null ? Math.max(0, deadline - Date.now()) : null
+      const fileAcquired = await this._acquireAdvisoryLockFile(name, {timeoutMs: remainingForFile})
+
+      if (!fileAcquired) {
+        await super.releaseAdvisoryLock(name)
+        return false
+      }
+    } catch (error) {
+      await super.releaseAdvisoryLock(name)
+      throw error
     }
-    /**
-     * Layers a filesystem lock directory on top of the in-process waiter
-     * queue so SQLite deployments with multiple Node processes writing to
-     * the same database file see consistent advisory-lock mutual exclusion
-     * across processes, not just within a single process.
-     *
-     * The in-process queue from the shared SQLite base class is still used
-     * for the fast intra-process path (no polling, waiters wake each other
-     * through the `Set<string>` + waiter queue); the filesystem lock is
-     * only checked once the in-process queue has granted the caller, so
-     * typical single-process traffic pays at most two `fs.mkdir` calls
-     * (create and remove) per critical section.
-     * @param {string} name - Lock name.
-     * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
-     * @returns {Promise<boolean>}
-     */
-    async acquireAdvisoryLock(name, { timeoutMs } = {}) {
-        const deadline = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null;
-        const remainingForInProcess = deadline !== null ? Math.max(0, deadline - Date.now()) : null;
-        const inProcessAcquired = await super.acquireAdvisoryLock(name, { timeoutMs: remainingForInProcess });
-        if (!inProcessAcquired)
-            return false;
-        try {
-            const remainingForFile = deadline !== null ? Math.max(0, deadline - Date.now()) : null;
-            const fileAcquired = await this._acquireAdvisoryLockFile(name, { timeoutMs: remainingForFile });
-            if (!fileAcquired) {
-                await super.releaseAdvisoryLock(name);
-                return false;
-            }
-        }
-        catch (error) {
-            await super.releaseAdvisoryLock(name);
-            throw error;
-        }
-        return true;
+
+    return true
+  }
+
+  /**
+   * Runs try acquire advisory lock.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>}
+   */
+  async tryAcquireAdvisoryLock(name) {
+    const inProcessAcquired = await super.tryAcquireAdvisoryLock(name)
+
+    if (!inProcessAcquired) return false
+
+    try {
+      const fileAcquired = await this._tryAcquireAdvisoryLockFile(name)
+
+      if (!fileAcquired) {
+        await super.releaseAdvisoryLock(name)
+        return false
+      }
+    } catch (error) {
+      await super.releaseAdvisoryLock(name)
+      throw error
     }
-    /**
-     * Runs try acquire advisory lock.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>}
-     */
-    async tryAcquireAdvisoryLock(name) {
-        const inProcessAcquired = await super.tryAcquireAdvisoryLock(name);
-        if (!inProcessAcquired)
-            return false;
-        try {
-            const fileAcquired = await this._tryAcquireAdvisoryLockFile(name);
-            if (!fileAcquired) {
-                await super.releaseAdvisoryLock(name);
-                return false;
-            }
-        }
-        catch (error) {
-            await super.releaseAdvisoryLock(name);
-            throw error;
-        }
-        return true;
-    }
-    /**
-     * Releases the lock only if **this** driver instance acquired it, both
-     * in the shared in-process owner table and in the on-disk lock
-     * directory. A caller that tries to release a lock it never acquired
-     * (or that was already released by another driver) gets `false` back
-     * and the filesystem state is left alone so we never delete somebody
-     * else's lock directory.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>}
-     */
-    async releaseAdvisoryLock(name) {
-        const inProcessReleased = await super.releaseAdvisoryLock(name);
-        if (inProcessReleased) {
-            await this._releaseAdvisoryLockFile(name);
-        }
-        return inProcessReleased;
+
+    return true
+  }
+
+  /**
+   * Releases the lock only if **this** driver instance acquired it, both
+   * in the shared in-process owner table and in the on-disk lock
+   * directory. A caller that tries to release a lock it never acquired
+   * (or that was already released by another driver) gets `false` back
+   * and the filesystem state is left alone so we never delete somebody
+   * else's lock directory.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>}
+   */
+  async releaseAdvisoryLock(name) {
+    const inProcessReleased = await super.releaseAdvisoryLock(name)
+
+    if (inProcessReleased) {
+      await this._releaseAdvisoryLockFile(name)
     }
-    /**
-     * Runs is advisory lock held.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>}
-     */
-    async isAdvisoryLockHeld(name) {
-        if (await super.isAdvisoryLockHeld(name))
-            return true;
-        return await this._isAdvisoryLockFileHeld(name);
+
+    return inProcessReleased
+  }
+
+  /**
+   * Runs is advisory lock held.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>}
+   */
+  async isAdvisoryLockHeld(name) {
+    if (await super.isAdvisoryLockHeld(name)) return true
+
+    return await this._isAdvisoryLockFileHeld(name)
+  }
+
+  /**
+   * Runs resolve advisory lock directory.
+    @returns {string} */
+  _resolveAdvisoryLockDirectory() {
+    if (!this._advisoryLockDirectory) {
+      // Fall back to deriving the directory for callers that invoked
+      // advisory lock methods before `connect()` wired the field in.
+      const databaseDir = `${this.getConfiguration().getDirectory()}/db`
+
+      this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`)
     }
-    /**
-     * Runs resolve advisory lock directory.
-      @returns {string} */
-    _resolveAdvisoryLockDirectory() {
-        if (!this._advisoryLockDirectory) {
-            // Fall back to deriving the directory for callers that invoked
-            // advisory lock methods before `connect()` wired the field in.
-            const databaseDir = `${this.getConfiguration().getDirectory()}/db`;
-            this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`);
+
+    return this._advisoryLockDirectory
+  }
+
+  /**
+   * Runs advisory lock path.
+   * @param {string} name - Lock name.
+   * @returns {string}
+   */
+  _advisoryLockPath(name) {
+    const hash = createHash("sha256").update(name).digest("hex").slice(0, 16)
+    const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 64)
+
+    return path.join(this._resolveAdvisoryLockDirectory(), `${safeName}-${hash}.lock`)
+  }
+
+  /**
+   * Runs ensure advisory lock directory.
+    @returns {Promise<void>} */
+  async _ensureAdvisoryLockDirectory() {
+    await fs.mkdir(this._resolveAdvisoryLockDirectory(), {recursive: true})
+  }
+
+  /**
+   * Runs write advisory lock metadata.
+   * @param {string} lockDirPath - Absolute path of the lock directory.
+   * @returns {Promise<void>}
+   */
+  async _writeAdvisoryLockMetadata(lockDirPath) {
+    const ownerPath = path.join(lockDirPath, "owner.json")
+    const payload = JSON.stringify({
+      pid: process.pid,
+      hostname: os.hostname(),
+      acquiredAt: new Date().toISOString()
+    })
+
+    await fs.writeFile(ownerPath, payload)
+  }
+
+  /**
+   * Runs acquire advisory lock file.
+   * @param {string} name - Lock name.
+   * @param {{timeoutMs?: number | null}} args - Timeout args.
+   * @returns {Promise<boolean>}
+   */
+  async _acquireAdvisoryLockFile(name, {timeoutMs}) {
+    await this._ensureAdvisoryLockDirectory()
+
+    const lockPath = this._advisoryLockPath(name)
+    const deadline = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null
+    const pollIntervalMs = 50
+
+    // Intentionally looping without a fixed iteration cap — either the
+    // mkdir succeeds, the deadline elapses, or an unexpected error is
+    // re-thrown.
+    while (true) {
+      try {
+        await fs.mkdir(lockPath)
+        await this._writeAdvisoryLockMetadata(lockPath)
+
+        return true
+      } catch (error) {
+        if (/**
+             * Narrows the runtime value to the documented type.
+              @type {NodeJS.ErrnoException} */ (error)?.code !== "EEXIST") throw error
+
+        if (await this._isAdvisoryLockStale(lockPath)) {
+          await fs.rm(lockPath, {recursive: true, force: true})
+          continue
         }
-        return this._advisoryLockDirectory;
-    }
-    /**
-     * Runs advisory lock path.
-     * @param {string} name - Lock name.
-     * @returns {string}
-     */
-    _advisoryLockPath(name) {
-        const hash = createHash("sha256").update(name).digest("hex").slice(0, 16);
-        const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 64);
-        return path.join(this._resolveAdvisoryLockDirectory(), `${safeName}-${hash}.lock`);
-    }
-    /**
-     * Runs ensure advisory lock directory.
-      @returns {Promise<void>} */
-    async _ensureAdvisoryLockDirectory() {
-        await fs.mkdir(this._resolveAdvisoryLockDirectory(), { recursive: true });
-    }
-    /**
-     * Runs write advisory lock metadata.
-     * @param {string} lockDirPath - Absolute path of the lock directory.
-     * @returns {Promise<void>}
-     */
-    async _writeAdvisoryLockMetadata(lockDirPath) {
-        const ownerPath = path.join(lockDirPath, "owner.json");
-        const payload = JSON.stringify({
-            pid: process.pid,
-            hostname: os.hostname(),
-            acquiredAt: new Date().toISOString()
-        });
-        await fs.writeFile(ownerPath, payload);
-    }
-    /**
-     * Runs acquire advisory lock file.
-     * @param {string} name - Lock name.
-     * @param {{timeoutMs?: number | null}} args - Timeout args.
-     * @returns {Promise<boolean>}
-     */
-    async _acquireAdvisoryLockFile(name, { timeoutMs }) {
-        await this._ensureAdvisoryLockDirectory();
-        const lockPath = this._advisoryLockPath(name);
-        const deadline = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null;
-        const pollIntervalMs = 50;
-        // Intentionally looping without a fixed iteration cap — either the
-        // mkdir succeeds, the deadline elapses, or an unexpected error is
-        // re-thrown.
-        while (true) {
-            try {
-                await fs.mkdir(lockPath);
-                await this._writeAdvisoryLockMetadata(lockPath);
-                return true;
-            }
-            catch (error) {
-                if ( /**
-                     * Narrows the runtime value to the documented type.
-                      @type {NodeJS.ErrnoException} */(error)?.code !== "EEXIST")
-                    throw error;
-                if (await this._isAdvisoryLockStale(lockPath)) {
-                    await fs.rm(lockPath, { recursive: true, force: true });
-                    continue;
-                }
-                if (deadline !== null) {
-                    const remaining = deadline - Date.now();
-                    if (remaining <= 0)
-                        return false;
-                    await wait(Math.min(pollIntervalMs, remaining));
-                }
-                else {
-                    await wait(pollIntervalMs);
-                }
-            }
+
+        if (deadline !== null) {
+          const remaining = deadline - Date.now()
+
+          if (remaining <= 0) return false
+
+          await wait(Math.min(pollIntervalMs, remaining))
+        } else {
+          await wait(pollIntervalMs)
         }
+      }
     }
-    /**
-     * Runs try acquire advisory lock file.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>}
-     */
-    async _tryAcquireAdvisoryLockFile(name) {
-        await this._ensureAdvisoryLockDirectory();
-        const lockPath = this._advisoryLockPath(name);
+  }
+
+  /**
+   * Runs try acquire advisory lock file.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>}
+   */
+  async _tryAcquireAdvisoryLockFile(name) {
+    await this._ensureAdvisoryLockDirectory()
+
+    const lockPath = this._advisoryLockPath(name)
+
+    try {
+      await fs.mkdir(lockPath)
+      await this._writeAdvisoryLockMetadata(lockPath)
+
+      return true
+    } catch (error) {
+      if (/**
+           * Narrows the runtime value to the documented type.
+            @type {NodeJS.ErrnoException} */ (error)?.code !== "EEXIST") throw error
+
+      if (await this._isAdvisoryLockStale(lockPath)) {
+        await fs.rm(lockPath, {recursive: true, force: true})
+
         try {
-            await fs.mkdir(lockPath);
-            await this._writeAdvisoryLockMetadata(lockPath);
-            return true;
-        }
-        catch (error) {
-            if ( /**
-                 * Narrows the runtime value to the documented type.
-                  @type {NodeJS.ErrnoException} */(error)?.code !== "EEXIST")
-                throw error;
-            if (await this._isAdvisoryLockStale(lockPath)) {
-                await fs.rm(lockPath, { recursive: true, force: true });
-                try {
-                    await fs.mkdir(lockPath);
-                    await this._writeAdvisoryLockMetadata(lockPath);
-                    return true;
-                }
-                catch (retryError) {
-                    if ( /**
-                         * Narrows the runtime value to the documented type.
-                          @type {NodeJS.ErrnoException} */(retryError)?.code === "EEXIST")
-                        return false;
-                    throw retryError;
-                }
-            }
-            return false;
+          await fs.mkdir(lockPath)
+          await this._writeAdvisoryLockMetadata(lockPath)
+
+          return true
+        } catch (retryError) {
+          if (/**
+               * Narrows the runtime value to the documented type.
+                @type {NodeJS.ErrnoException} */ (retryError)?.code === "EEXIST") return false
+
+          throw retryError
         }
+      }
+
+      return false
     }
-    /**
-     * Runs release advisory lock file.
-     * @param {string} name - Lock name.
-     * @returns {Promise<void>}
-     */
-    async _releaseAdvisoryLockFile(name) {
-        const lockPath = this._advisoryLockPath(name);
-        try {
-            await fs.rm(lockPath, { recursive: true, force: true });
-        }
-        catch {
-            // Best-effort release; in-process state is still authoritative and
-            // stale-lock cleanup on the next acquire will remove the directory
-            // if it really is still lingering.
-        }
+  }
+
+  /**
+   * Runs release advisory lock file.
+   * @param {string} name - Lock name.
+   * @returns {Promise<void>}
+   */
+  async _releaseAdvisoryLockFile(name) {
+    const lockPath = this._advisoryLockPath(name)
+
+    try {
+      await fs.rm(lockPath, {recursive: true, force: true})
+    } catch {
+      // Best-effort release; in-process state is still authoritative and
+      // stale-lock cleanup on the next acquire will remove the directory
+      // if it really is still lingering.
+    }
+  }
+
+  /**
+   * Runs is advisory lock file held.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>}
+   */
+  async _isAdvisoryLockFileHeld(name) {
+    const lockPath = this._advisoryLockPath(name)
+
+    try {
+      await fs.stat(lockPath)
+    } catch {
+      return false
     }
+
+    return !await this._isAdvisoryLockStale(lockPath)
+  }
+
+  /**
+   * A lock directory is considered stale when its owner metadata names a
+   * PID on this host that is no longer running. Cross-host ownership (a
+   * different `hostname`) is treated as live because we cannot reliably
+   * probe a PID on another machine; operators in that situation should
+   * remove stale lock directories by hand if they linger.
+   * @param {string} lockPath - Absolute path of the lock directory.
+   * @returns {Promise<boolean>}
+   */
+  async _isAdvisoryLockStale(lockPath) {
     /**
-     * Runs is advisory lock file held.
-     * @param {string} name - Lock name.
-     * @returns {Promise<boolean>}
-     */
-    async _isAdvisoryLockFileHeld(name) {
-        const lockPath = this._advisoryLockPath(name);
-        try {
-            await fs.stat(lockPath);
-        }
-        catch {
-            return false;
-        }
-        return !await this._isAdvisoryLockStale(lockPath);
+     * Defines rawOwner.
+      @type {string} */
+    let rawOwner
+
+    try {
+      rawOwner = await fs.readFile(path.join(lockPath, "owner.json"), "utf8")
+    } catch {
+      // Missing or unreadable metadata — treat as stale so we can reclaim.
+      return true
     }
+
     /**
-     * A lock directory is considered stale when its owner metadata names a
-     * PID on this host that is no longer running. Cross-host ownership (a
-     * different `hostname`) is treated as live because we cannot reliably
-     * probe a PID on another machine; operators in that situation should
-     * remove stale lock directories by hand if they linger.
-     * @param {string} lockPath - Absolute path of the lock directory.
-     * @returns {Promise<boolean>}
-     */
-    async _isAdvisoryLockStale(lockPath) {
-        /**
-         * Defines rawOwner.
-          @type {string} */
-        let rawOwner;
-        try {
-            rawOwner = await fs.readFile(path.join(lockPath, "owner.json"), "utf8");
-        }
-        catch {
-            // Missing or unreadable metadata — treat as stale so we can reclaim.
-            return true;
-        }
-        /**
-         * Defines owner.
-          @type {{pid?: number, hostname?: string}} */
-        let owner;
-        try {
-            owner = JSON.parse(rawOwner);
-        }
-        catch {
-            return true;
-        }
-        if (!owner || typeof owner.pid !== "number")
-            return true;
-        if (owner.hostname && owner.hostname !== os.hostname())
-            return false;
-        try {
-            // `kill(pid, 0)` is a no-op signal that fails with ESRCH if the
-            // process is not running; permission errors still indicate the
-            // process exists so we treat those as "not stale".
-            process.kill(owner.pid, 0);
-            return false;
-        }
-        catch (error) {
-            return /** Narrows the runtime value to the documented type. @type {NodeJS.ErrnoException} */ (error)?.code === "ESRCH";
-        }
+     * Defines owner.
+      @type {{pid?: number, hostname?: string}} */
+    let owner
+
+    try {
+      owner = JSON.parse(rawOwner)
+    } catch {
+      return true
+    }
+
+    if (!owner || typeof owner.pid !== "number") return true
+    if (owner.hostname && owner.hostname !== os.hostname()) return false
+
+    try {
+      // `kill(pid, 0)` is a no-op signal that fails with ESRCH if the
+      // process is not running; permission errors still indicate the
+      // process exists so we treat those as "not stale".
+      process.kill(owner.pid, 0)
+
+      return false
+    } catch (error) {
+      return /** Narrows the runtime value to the documented type. @type {NodeJS.ErrnoException} */ (error)?.code === "ESRCH"
     }
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport wait from \"awaitery/build/wait.js\"\nimport fs from \"fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport query from \"./query.js\"\nimport sqlite3 from \"sqlite3\"\nimport {open} from \"sqlite\"\n\nimport Base from \"./base.js\"\nimport fileExists from \"../../../utils/file-exists.js\"\n\nexport default class VelociousDatabaseDriversSqliteNode extends Base {\n  /**\n   * Connection.\n    @type {import(\"sqlite3\").Database | undefined} */\n  connection = undefined\n\n  /**\n   * Advisory lock directory.\n    @type {string | undefined} */\n  _advisoryLockDirectory = undefined\n\n  async connect() {\n    const args = this.getArgs()\n    const databaseDir = `${this.getConfiguration().getDirectory()}/db`\n    const databasePath = `${databaseDir}/${this.localStorageName()}.sqlite`\n\n    if (!await fileExists(databaseDir)) {\n      await fs.mkdir(databaseDir, {recursive: true})\n    }\n\n    if (args.reset) {\n      await fs.unlink(databasePath)\n    }\n\n    this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`)\n\n    try {\n      // @ts-expect-error\n      this.connection = /** Narrows the runtime value to the documented type. @type {import(\"sqlite3\").Database} */ (await open({\n        filename: databasePath,\n        driver: sqlite3.Database\n      }))\n    } catch (error) {\n      if (error instanceof Error) {\n        throw new Error(`Couldn't open database ${databasePath} because of ${error.constructor.name}: ${error.message}`, {cause: error})\n      } else {\n        throw new Error(`Couldn't open database ${databasePath} because of ${typeof error}: ${error}`, {cause: error})\n      }\n    }\n\n    await this.registerVersion()\n  }\n\n  localStorageName() {\n    const args = this.getArgs()\n\n    if (!args.name) throw new Error(\"No name given for SQLite Node\")\n\n    return `VelociousDatabaseDriversSqlite---${args.name}`\n  }\n\n  async close() {\n    await this.connection?.close()\n    this.connection = undefined\n  }\n\n  /**\n   * Runs query actual.\n   * @param {string} sql - SQL string.\n   * @returns {Promise<Record<string, ?>[]>} - Resolves with the query actual.\n   */\n  async _queryActual(sql) {\n    if (!this.connection) throw new Error(\"No connection\")\n\n    return await query(this.connection, sql)\n  }\n\n  /**\n   * Layers a filesystem lock directory on top of the in-process waiter\n   * queue so SQLite deployments with multiple Node processes writing to\n   * the same database file see consistent advisory-lock mutual exclusion\n   * across processes, not just within a single process.\n   *\n   * The in-process queue from the shared SQLite base class is still used\n   * for the fast intra-process path (no polling, waiters wake each other\n   * through the `Set<string>` + waiter queue); the filesystem lock is\n   * only checked once the in-process queue has granted the caller, so\n   * typical single-process traffic pays at most two `fs.mkdir` calls\n   * (create and remove) per critical section.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.\n   * @returns {Promise<boolean>}\n   */\n  async acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const deadline = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Date.now() + timeoutMs : null\n    const remainingForInProcess = deadline !== null ? Math.max(0, deadline - Date.now()) : null\n    const inProcessAcquired = await super.acquireAdvisoryLock(name, {timeoutMs: remainingForInProcess})\n\n    if (!inProcessAcquired) return false\n\n    try {\n      const remainingForFile = deadline !== null ? Math.max(0, deadline - Date.now()) : null\n      const fileAcquired = await this._acquireAdvisoryLockFile(name, {timeoutMs: remainingForFile})\n\n      if (!fileAcquired) {\n        await super.releaseAdvisoryLock(name)\n        return false\n      }\n    } catch (error) {\n      await super.releaseAdvisoryLock(name)\n      throw error\n    }\n\n    return true\n  }\n\n  /**\n   * Runs try acquire advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>}\n   */\n  async tryAcquireAdvisoryLock(name) {\n    const inProcessAcquired = await super.tryAcquireAdvisoryLock(name)\n\n    if (!inProcessAcquired) return false\n\n    try {\n      const fileAcquired = await this._tryAcquireAdvisoryLockFile(name)\n\n      if (!fileAcquired) {\n        await super.releaseAdvisoryLock(name)\n        return false\n      }\n    } catch (error) {\n      await super.releaseAdvisoryLock(name)\n      throw error\n    }\n\n    return true\n  }\n\n  /**\n   * Releases the lock only if **this** driver instance acquired it, both\n   * in the shared in-process owner table and in the on-disk lock\n   * directory. A caller that tries to release a lock it never acquired\n   * (or that was already released by another driver) gets `false` back\n   * and the filesystem state is left alone so we never delete somebody\n   * else's lock directory.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>}\n   */\n  async releaseAdvisoryLock(name) {\n    const inProcessReleased = await super.releaseAdvisoryLock(name)\n\n    if (inProcessReleased) {\n      await this._releaseAdvisoryLockFile(name)\n    }\n\n    return inProcessReleased\n  }\n\n  /**\n   * Runs is advisory lock held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>}\n   */\n  async isAdvisoryLockHeld(name) {\n    if (await super.isAdvisoryLockHeld(name)) return true\n\n    return await this._isAdvisoryLockFileHeld(name)\n  }\n\n  /**\n   * Runs resolve advisory lock directory.\n    @returns {string} */\n  _resolveAdvisoryLockDirectory() {\n    if (!this._advisoryLockDirectory) {\n      // Fall back to deriving the directory for callers that invoked\n      // advisory lock methods before `connect()` wired the field in.\n      const databaseDir = `${this.getConfiguration().getDirectory()}/db`\n\n      this._advisoryLockDirectory = path.join(databaseDir, `${this.localStorageName()}.velocious-advisory-locks`)\n    }\n\n    return this._advisoryLockDirectory\n  }\n\n  /**\n   * Runs advisory lock path.\n   * @param {string} name - Lock name.\n   * @returns {string}\n   */\n  _advisoryLockPath(name) {\n    const hash = createHash(\"sha256\").update(name).digest(\"hex\").slice(0, 16)\n    const safeName = name.replace(/[^a-zA-Z0-9._-]/g, \"_\").slice(0, 64)\n\n    return path.join(this._resolveAdvisoryLockDirectory(), `${safeName}-${hash}.lock`)\n  }\n\n  /**\n   * Runs ensure advisory lock directory.\n    @returns {Promise<void>} */\n  async _ensureAdvisoryLockDirectory() {\n    await fs.mkdir(this._resolveAdvisoryLockDirectory(), {recursive: true})\n  }\n\n  /**\n   * Runs write advisory lock metadata.\n   * @param {string} lockDirPath - Absolute path of the lock directory.\n   * @returns {Promise<void>}\n   */\n  async _writeAdvisoryLockMetadata(lockDirPath) {\n    const ownerPath = path.join(lockDirPath, \"owner.json\")\n    const payload = JSON.stringify({\n      pid: process.pid,\n      hostname: os.hostname(),\n      acquiredAt: new Date().toISOString()\n    })\n\n    await fs.writeFile(ownerPath, payload)\n  }\n\n  /**\n   * Runs acquire advisory lock file.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} args - Timeout args.\n   * @returns {Promise<boolean>}\n   */\n  async _acquireAdvisoryLockFile(name, {timeoutMs}) {\n    await this._ensureAdvisoryLockDirectory()\n\n    const lockPath = this._advisoryLockPath(name)\n    const deadline = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Date.now() + timeoutMs : null\n    const pollIntervalMs = 50\n\n    // Intentionally looping without a fixed iteration cap — either the\n    // mkdir succeeds, the deadline elapses, or an unexpected error is\n    // re-thrown.\n    while (true) {\n      try {\n        await fs.mkdir(lockPath)\n        await this._writeAdvisoryLockMetadata(lockPath)\n\n        return true\n      } catch (error) {\n        if (/**\n             * Narrows the runtime value to the documented type.\n              @type {NodeJS.ErrnoException} */ (error)?.code !== \"EEXIST\") throw error\n\n        if (await this._isAdvisoryLockStale(lockPath)) {\n          await fs.rm(lockPath, {recursive: true, force: true})\n          continue\n        }\n\n        if (deadline !== null) {\n          const remaining = deadline - Date.now()\n\n          if (remaining <= 0) return false\n\n          await wait(Math.min(pollIntervalMs, remaining))\n        } else {\n          await wait(pollIntervalMs)\n        }\n      }\n    }\n  }\n\n  /**\n   * Runs try acquire advisory lock file.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>}\n   */\n  async _tryAcquireAdvisoryLockFile(name) {\n    await this._ensureAdvisoryLockDirectory()\n\n    const lockPath = this._advisoryLockPath(name)\n\n    try {\n      await fs.mkdir(lockPath)\n      await this._writeAdvisoryLockMetadata(lockPath)\n\n      return true\n    } catch (error) {\n      if (/**\n           * Narrows the runtime value to the documented type.\n            @type {NodeJS.ErrnoException} */ (error)?.code !== \"EEXIST\") throw error\n\n      if (await this._isAdvisoryLockStale(lockPath)) {\n        await fs.rm(lockPath, {recursive: true, force: true})\n\n        try {\n          await fs.mkdir(lockPath)\n          await this._writeAdvisoryLockMetadata(lockPath)\n\n          return true\n        } catch (retryError) {\n          if (/**\n               * Narrows the runtime value to the documented type.\n                @type {NodeJS.ErrnoException} */ (retryError)?.code === \"EEXIST\") return false\n\n          throw retryError\n        }\n      }\n\n      return false\n    }\n  }\n\n  /**\n   * Runs release advisory lock file.\n   * @param {string} name - Lock name.\n   * @returns {Promise<void>}\n   */\n  async _releaseAdvisoryLockFile(name) {\n    const lockPath = this._advisoryLockPath(name)\n\n    try {\n      await fs.rm(lockPath, {recursive: true, force: true})\n    } catch {\n      // Best-effort release; in-process state is still authoritative and\n      // stale-lock cleanup on the next acquire will remove the directory\n      // if it really is still lingering.\n    }\n  }\n\n  /**\n   * Runs is advisory lock file held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>}\n   */\n  async _isAdvisoryLockFileHeld(name) {\n    const lockPath = this._advisoryLockPath(name)\n\n    try {\n      await fs.stat(lockPath)\n    } catch {\n      return false\n    }\n\n    return !await this._isAdvisoryLockStale(lockPath)\n  }\n\n  /**\n   * A lock directory is considered stale when its owner metadata names a\n   * PID on this host that is no longer running. Cross-host ownership (a\n   * different `hostname`) is treated as live because we cannot reliably\n   * probe a PID on another machine; operators in that situation should\n   * remove stale lock directories by hand if they linger.\n   * @param {string} lockPath - Absolute path of the lock directory.\n   * @returns {Promise<boolean>}\n   */\n  async _isAdvisoryLockStale(lockPath) {\n    /**\n     * Defines rawOwner.\n      @type {string} */\n    let rawOwner\n\n    try {\n      rawOwner = await fs.readFile(path.join(lockPath, \"owner.json\"), \"utf8\")\n    } catch {\n      // Missing or unreadable metadata — treat as stale so we can reclaim.\n      return true\n    }\n\n    /**\n     * Defines owner.\n      @type {{pid?: number, hostname?: string}} */\n    let owner\n\n    try {\n      owner = JSON.parse(rawOwner)\n    } catch {\n      return true\n    }\n\n    if (!owner || typeof owner.pid !== \"number\") return true\n    if (owner.hostname && owner.hostname !== os.hostname()) return false\n\n    try {\n      // `kill(pid, 0)` is a no-op signal that fails with ESRCH if the\n      // process is not running; permission errors still indicate the\n      // process exists so we treat those as \"not stale\".\n      process.kill(owner.pid, 0)\n\n      return false\n    } catch (error) {\n      return /** Narrows the runtime value to the documented type. @type {NodeJS.ErrnoException} */ (error)?.code === \"ESRCH\"\n    }\n  }\n}\n"]}