velocious 1.0.510 → 1.0.512

package/build/database/record-changes.js

@@ -0,0 +1,135 @@
+// @ts-check
+
+import EventEmitter from "../utils/event-emitter.js"
+
+/**
+ * RecordModelClass type.
+ * @typedef {typeof import("./record/index.js").default} RecordModelClass */
+
+/**
+ * RecordChangeOperation type.
+ * @typedef {"create" | "update" | "destroy"} RecordChangeOperation */
+
+/**
+ * RecordChangeEvent type.
+ * @typedef {object} RecordChangeEvent
+ * @property {RecordModelClass} modelClass - Model class whose row changed.
+ * @property {RecordChangeOperation} operation - The committed operation.
+ * @property {InstanceType<RecordModelClass>} record - The committed record instance.
+ */
+
+/**
+ * RecordChangeListener type.
+ * @typedef {(event: RecordChangeEvent) => void} RecordChangeListener */
+
+/**
+ * Framework-level bus for committed local model changes. Records emit here once
+ * per commit (see `VelociousDatabaseRecord.save`/`destroy`), so local writes,
+ * pull applies, and realtime applies converge on one uniform signal that live
+ * queries subscribe to. Emission is keyed by model name; a `batch(...)` window
+ * coalesces a burst of commits into a single event per model class.
+ */
+class RecordChanges {
+  /**
+   * Underlying event bus keyed by model name.
+   * @type {import("eventemitter3").EventEmitter} */
+  _emitter = new EventEmitter()
+
+  /**
+   * Number of open batch windows; while positive, emits buffer instead of dispatching.
+   * @type {number} */
+  _batchDepth = 0
+
+  /**
+   * Latest buffered event per model name, dispatched once when the outermost batch ends.
+   * @type {Map<string, RecordChangeEvent>} */
+  _bufferedEvents = new Map()
+
+  /**
+   * Subscribes a listener to committed changes of a model class.
+   * @param {RecordModelClass} modelClass - Model class to observe.
+   * @param {RecordChangeListener} listener - Listener called with each change event.
+   * @returns {() => void} Unsubscribe callback.
+   */
+  subscribe(modelClass, listener) {
+    const eventName = modelClass.getModelName()
+
+    this._emitter.on(eventName, listener)
+
+    return () => {
+      this._emitter.off(eventName, listener)
+    }
+  }
+
+  /**
+   * Whether any listener is currently observing the given model class. Callers on
+   * the write path use this to skip emitting entirely when nothing is watching,
+   * keeping server-side saves free of live-query overhead.
+   * @param {RecordModelClass} modelClass - Model class to check.
+   * @returns {boolean} Whether listeners exist for the model class.
+   */
+  hasListeners(modelClass) {
+    return this._emitter.listenerCount(modelClass.getModelName()) > 0
+  }
+
+  /**
+   * Emits a committed change. While a batch window is open the event is buffered
+   * and deduplicated by model class, so a batch of N commits dispatches a single
+   * event per model class when the outermost batch ends.
+   * @param {RecordChangeEvent} event - Change event to dispatch.
+   * @returns {void}
+   */
+  emit(event) {
+    if (this._batchDepth > 0) {
+      this._bufferedEvents.set(event.modelClass.getModelName(), event)
+
+      return
+    }
+
+    this._emitter.emit(event.modelClass.getModelName(), event)
+  }
+
+  /**
+   * Runs a callback with change dispatch coalesced: every change committed while
+   * the callback runs buffers, and the outermost batch flushes a single event per
+   * changed model class after it resolves. Nested batches share one flush. Sync
+   * appliers wrap their per-row apply loop in this so a large pull or realtime
+   * push triggers one re-run per live query instead of one per applied row.
+   * @template T
+   * @param {() => Promise<T> | T} callback - Work whose committed changes should coalesce.
+   * @returns {Promise<T>} The callback result.
+   */
+  async batch(callback) {
+    this._batchDepth++
+
+    try {
+      return await callback()
+    } finally {
+      this._batchDepth--
+
+      if (this._batchDepth === 0) this._flushBufferedEvents()
+    }
+  }
+
+  /**
+   * Dispatches and clears the buffered per-model events collected during a batch.
+   * @returns {void}
+   */
+  _flushBufferedEvents() {
+    const bufferedEvents = this._bufferedEvents
+
+    this._bufferedEvents = new Map()
+
+    for (const event of bufferedEvents.values()) {
+      this._emitter.emit(event.modelClass.getModelName(), event)
+    }
+  }
+}
+
+/**
+ * Shared singleton so record commits and live queries meet on one bus.
+ * @type {RecordChanges} */
+const recordChanges = new RecordChanges()
+
+export default recordChanges
+export {RecordChanges}

package/build/database/use-live-query.js

@@ -0,0 +1,118 @@
+// @ts-check
+
+import {useCallback, useEffect, useMemo, useRef, useSyncExternalStore} from "react"
+
+import LiveQuery from "./live-query.js"
+
+/**
+ * RecordModelClass type.
+ * @typedef {typeof import("./record/index.js").default} RecordModelClass */
+
+/**
+ * LiveQuerySource type.
+ * @template T
+ * @typedef {import("./live-query.js").LiveQuerySource<T>} LiveQuerySource */
+
+/**
+ * LiveQueryState type.
+ * @template T
+ * @typedef {import("./live-query.js").LiveQueryState<T>} LiveQueryState */
+
+/**
+ * UseLiveQueryOptions type.
+ * @typedef {object} UseLiveQueryOptions
+ * @property {boolean} [active] - Whether the query is active. Default true; pass false to pause and return the empty state.
+ * @property {number} [debounce] - Trailing debounce in ms for re-runs. Defaults to microtask coalescing.
+ * @property {RecordModelClass[]} [models] - Model classes to observe. Defaults to the query's model class; pass this to also react to joined models.
+ */
+
+/**
+ * Stable empty state returned while there is no active query, so a paused hook
+ * keeps a referentially stable snapshot for `useSyncExternalStore`.
+ * @type {LiveQueryState<?>} */
+const EMPTY_STATE = {error: null, loading: false, results: []}
+
+/**
+ * Assigns and stores a stable identity key for query sources without a `toSql`.
+ * @type {WeakMap<object, string>} */
+const queryIdentityKeys = new WeakMap()
+
+/**
+ * Monotonic counter backing the queryIdentityKeys registry.
+ * @type {number} */
+let nextQueryIdentity = 0
+
+/**
+ * Builds a dependency key identifying a query's semantics so the underlying
+ * controller is rebuilt when they change. Model-class queries expose `toSql`, so
+ * distinct conditions yield distinct keys; other sources fall back to a stable
+ * per-object identity (such sources must be memoized by the caller).
+ * @param {LiveQuerySource<?> & {toSql?: () => ?}} query - Query source.
+ * @param {RecordModelClass[] | undefined} models - Explicit model classes to observe.
+ * @returns {string} Dependency key.
+ */
+function liveQueryDependencyKey(query, models) {
+  const modelNames = (models ?? [query.getModelClass()]).map((modelClass) => modelClass.getModelName()).join(",")
+
+  if (typeof query.toSql === "function") return `${modelNames}::${String(query.toSql())}`
+
+  let identityKey = queryIdentityKeys.get(query)
+
+  if (identityKey === undefined) {
+    identityKey = `#${++nextQueryIdentity}`
+    queryIdentityKeys.set(query, identityKey)
+  }
+
+  return `${modelNames}::${identityKey}`
+}
+
+/**
+ * React hook declaring what a screen shows and keeping it current from committed
+ * local model changes. Runs `query.toArray()` once, subscribes to the query's
+ * model class(es) on the record-change bus, and re-runs (coalesced, stale-safe)
+ * whenever a watched model commits — so local writes, pull applies, and realtime
+ * applies all refresh the results without any manual refresh plumbing.
+ * @template T
+ * @param {(LiveQuerySource<T> & {toSql?: () => ?}) | null | undefined} query - Query source, e.g. `Model.where({...})`.
+ * @param {UseLiveQueryOptions} [options] - Hook options.
+ * @returns {LiveQueryState<T>} Current results, loading, and last error.
+ */
+export default function useLiveQuery(query, options = {}) {
+  const {active = true, debounce, models} = options
+  const enabled = active && Boolean(query)
+  const dependencyKey = enabled && query ? liveQueryDependencyKey(query, models) : "disabled"
+
+  const queryRef = useRef(query)
+  const modelsRef = useRef(models)
+
+  queryRef.current = query
+  modelsRef.current = models
+
+  const liveQuery = useMemo(() => {
+    if (!enabled || !queryRef.current) return null
+
+    return new LiveQuery({debounce, models: modelsRef.current, query: queryRef.current})
+  }, [dependencyKey, debounce, enabled])
+
+  useEffect(() => {
+    if (!liveQuery) return undefined
+
+    liveQuery.start()
+
+    return () => liveQuery.close()
+  }, [liveQuery])
+
+  const subscribe = useCallback((/** @type {() => void} */ listener) => {
+    if (!liveQuery) return () => {}
+
+    return liveQuery.subscribe(listener)
+  }, [liveQuery])
+
+  const getSnapshot = useCallback(() => {
+    if (!liveQuery) return /** @type {LiveQueryState<T>} */ (EMPTY_STATE)
+
+    return liveQuery.getState()
+  }, [liveQuery])
+
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
+}

package/build/src/configuration-types.d.ts

@@ -775,7 +775,7 @@ export type DatabaseConfigurationType = {
     /**
      * - Database type identifier.
      */
-    type?: "sqlite" | "pgsql" | "mysql" | "mssql" | undefined;
+    type?: "sqlite" | "mysql" | "pgsql" | "mssql" | undefined;
     /**
      * - Database to switch to after connecting.
      */

package/build/src/configuration.d.ts

@@ -383,7 +383,7 @@ export default class VelociousConfiguration {
      * @returns {typeof import("./database/pool/base.js").default} - The database pool type.
      */
     getDatabasePoolType(identifier?: string): typeof import("./database/pool/base.js").default;
-    getDatabaseType(identifier?: string): "sqlite" | "pgsql" | "mysql" | "mssql";
+    getDatabaseType(identifier?: string): "sqlite" | "mysql" | "pgsql" | "mssql";
     /**
      * Runs get directory.
      * @returns {string} - The directory.

package/build/src/database/advisory-lock-runner.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Runs advisory locks on the caller connection by default, using a dedicated
+ * lock connection only when a positive hold timeout needs separate ownership.
+ */
+export default class AdvisoryLockRunner {
+    /**
+     * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
+     * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
+     * use a dedicated advisory-lock connection so the lock can still be released.
+     * @template T
+     * @param {string} name - Lock name (for the error message).
+     * @param {() => Promise<T>} callback - Callback holding the lock.
+     * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    static runWithAdvisoryLockHoldTimeout<T>(name: string, callback: () => Promise<T>, holdTimeoutMs?: number | null): Promise<T>;
+    /**
+     * Creates an advisory-lock runner for one model database identifier.
+     * @param {{configuration: import("../configuration.js").default, connectionProvider: () => import("./drivers/base.js").default, databaseIdentifier: string}} args - Runner dependencies.
+     */
+    constructor({ configuration, connectionProvider, databaseIdentifier }: {
+        configuration: import("../configuration.js").default;
+        connectionProvider: () => import("./drivers/base.js").default;
+        databaseIdentifier: string;
+    });
+    configuration: import("../configuration.js").default;
+    connectionProvider: () => import("./drivers/base.js").default;
+    databaseIdentifier: string;
+    /**
+     * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withAdvisoryLock<T>(name: string, callback: () => Promise<T>, args?: {
+        timeoutMs?: number | null;
+        holdTimeoutMs?: number | null;
+    }): Promise<T>;
+    /**
+     * Runs a callback only if the advisory lock can be acquired immediately.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withAdvisoryLockOrFail<T>(name: string, callback: () => Promise<T>, args?: {
+        holdTimeoutMs?: number | null;
+    }): Promise<T>;
+    /**
+     * Runs the lock holder callback and releases the lock from its owning connection.
+     * @template T
+     * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    runLockedCallback<T>({ callback, connection, holdTimeoutMs, name }: {
+        callback: () => Promise<T>;
+        connection: import("./drivers/base.js").default;
+        holdTimeoutMs?: number | null;
+        name: string;
+    }): Promise<T>;
+    /**
+     * Runs lock work on the caller connection unless a positive hold timeout needs
+     * its own lock connection.
+     * @template T
+     * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withLockConnection<T>(holdTimeoutMs: number | null | undefined, callback: (connection: import("./drivers/base.js").default) => Promise<T>): Promise<T>;
+    /**
+     * Spawns a hold-timeout lock connection and closes it after lock work completes when
+     * the spawned driver owns the underlying physical connection.
+     * @template T
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withDedicatedConnection<T>(callback: (connection: import("./drivers/base.js").default) => Promise<T>): Promise<T>;
+}
+/**
+ * Thrown when `withAdvisoryLockOrFail` finds the lock already held.
+ */
+export class AdvisoryLockBusyError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that was already held.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+/**
+ * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.
+ */
+export class AdvisoryLockHoldTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name whose hold timed out.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+/**
+ * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
+ */
+export class AdvisoryLockTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that timed out.
+     */
+    constructor(message: string, { name }: {
+        name: string;
+    });
+    lockName: string;
+}
+//# sourceMappingURL=advisory-lock-runner.d.ts.map

package/build/src/database/advisory-lock-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"AAoDA;;;GAGG;AACH;IAoGE;;;;;;;;;OASG;IACH,sCANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,kBAChB,MAAM,GAAG,IAAI,GACX,OAAO,CAAC,CAAC,CAAC,CAwBtB;IAnID;;;OAGG;IACH,uEAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAC,EAM3J;IAHC,qDAAkC;IAClC,0BAJ0F,OAAO,mBAAmB,EAAE,OAAO,CAIjF;IAC5C,2BAA4C;IAG9C;;;;;;;OAOG;IACH,iBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GACxD,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;;;OAOG;IACH,uBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;OAKG;IACH,kBAJa,CAAC,iDACH;QAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACxH,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;;OAOG;IACH,mBALa,CAAC,iBACH,MAAM,GAAG,IAAI,GAAG,SAAS,YACzB,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;OAMG;IACH,wBAJa,CAAC,YACH,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAYtB;CAmCF;AAzKD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AAED;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AA9CD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB"}

package/build/src/database/advisory-lock-runner.js

@@ -0,0 +1,176 @@
+// @ts-check
+import timeout from "awaitery/build/timeout.js";
+/**
+ * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
+ */
+class AdvisoryLockTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that timed out.
+     */
+    constructor(message, { name }) {
+        super(message);
+        this.name = "AdvisoryLockTimeoutError";
+        this.lockName = name;
+    }
+}
+/**
+ * Thrown when `withAdvisoryLockOrFail` finds the lock already held.
+ */
+class AdvisoryLockBusyError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name that was already held.
+     */
+    constructor(message, { name }) {
+        super(message);
+        this.name = "AdvisoryLockBusyError";
+        this.lockName = name;
+    }
+}
+/**
+ * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.
+ */
+class AdvisoryLockHoldTimeoutError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{name: string}} args - The advisory lock name whose hold timed out.
+     */
+    constructor(message, { name }) {
+        super(message);
+        this.name = "AdvisoryLockHoldTimeoutError";
+        this.lockName = name;
+    }
+}
+/**
+ * Runs advisory locks on the caller connection by default, using a dedicated
+ * lock connection only when a positive hold timeout needs separate ownership.
+ */
+export default class AdvisoryLockRunner {
+    /**
+     * Creates an advisory-lock runner for one model database identifier.
+     * @param {{configuration: import("../configuration.js").default, connectionProvider: () => import("./drivers/base.js").default, databaseIdentifier: string}} args - Runner dependencies.
+     */
+    constructor({ configuration, connectionProvider, databaseIdentifier }) {
+        this.configuration = configuration;
+        this.connectionProvider = connectionProvider;
+        this.databaseIdentifier = databaseIdentifier;
+    }
+    /**
+     * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    async withAdvisoryLock(name, callback, args = {}) {
+        return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+            const acquired = await connection.acquireAdvisoryLock(name, args);
+            if (!acquired) {
+                throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, { name });
+            }
+            return await this.runLockedCallback({ callback, connection, holdTimeoutMs: args.holdTimeoutMs, name });
+        });
+    }
+    /**
+     * Runs a callback only if the advisory lock can be acquired immediately.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    async withAdvisoryLockOrFail(name, callback, args = {}) {
+        return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {
+            const acquired = await connection.tryAcquireAdvisoryLock(name);
+            if (!acquired) {
+                throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, { name });
+            }
+            return await this.runLockedCallback({ callback, connection, holdTimeoutMs: args.holdTimeoutMs, name });
+        });
+    }
+    /**
+     * Runs the lock holder callback and releases the lock from its owning connection.
+     * @template T
+     * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    async runLockedCallback({ callback, connection, holdTimeoutMs, name }) {
+        try {
+            return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs);
+        }
+        finally {
+            await connection.releaseAdvisoryLock(name);
+        }
+    }
+    /**
+     * Runs lock work on the caller connection unless a positive hold timeout needs
+     * its own lock connection.
+     * @template T
+     * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    async withLockConnection(holdTimeoutMs, callback) {
+        if (holdTimeoutMs && holdTimeoutMs > 0) {
+            return await this.withDedicatedConnection(callback);
+        }
+        return await callback(this.connectionProvider());
+    }
+    /**
+     * Spawns a hold-timeout lock connection and closes it after lock work completes when
+     * the spawned driver owns the underlying physical connection.
+     * @template T
+     * @param {(connection: import("./drivers/base.js").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    async withDedicatedConnection(callback) {
+        const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection();
+        try {
+            return await callback(connection);
+        }
+        finally {
+            if (!connection.getArgs().getConnection) {
+                await connection.close();
+            }
+        }
+    }
+    /**
+     * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
+     * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
+     * use a dedicated advisory-lock connection so the lock can still be released.
+     * @template T
+     * @param {string} name - Lock name (for the error message).
+     * @param {() => Promise<T>} callback - Callback holding the lock.
+     * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {
+        if (!holdTimeoutMs || holdTimeoutMs <= 0) {
+            return await callback();
+        }
+        let callbackSettled = false;
+        try {
+            return await timeout({ timeout: holdTimeoutMs }, async () => {
+                try {
+                    return await callback();
+                }
+                finally {
+                    callbackSettled = true;
+                }
+            });
+        }
+        catch (error) {
+            if (!callbackSettled) {
+                throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, { name });
+            }
+            throw error;
+        }
+    }
+}
+export { AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-runner.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout from \"awaitery/build/timeout.js\"\n\n/**\n * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.\n */\nclass AdvisoryLockTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when `withAdvisoryLockOrFail` finds the lock already held.\n */\nclass AdvisoryLockBusyError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that was already held.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockBusyError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.\n */\nclass AdvisoryLockHoldTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name whose hold timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockHoldTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Runs advisory locks on the caller connection by default, using a dedicated\n * lock connection only when a positive hold timeout needs separate ownership.\n */\nexport default class AdvisoryLockRunner {\n  /**\n   * Creates an advisory-lock runner for one model database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, connectionProvider: () => import(\"./drivers/base.js\").default, databaseIdentifier: string}} args - Runner dependencies.\n   */\n  constructor({configuration, connectionProvider, databaseIdentifier}) {\n    this.configuration = configuration\n    this.connectionProvider = connectionProvider\n    this.databaseIdentifier = databaseIdentifier\n  }\n\n  /**\n   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLock(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.acquireAdvisoryLock(name, args)\n\n      if (!acquired) {\n        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback only if the advisory lock can be acquired immediately.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLockOrFail(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) {\n        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs the lock holder callback and releases the lock from its owning connection.\n   * @template T\n   * @param {{callback: () => Promise<T>, connection: import(\"./drivers/base.js\").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {\n    try {\n      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)\n    } finally {\n      await connection.releaseAdvisoryLock(name)\n    }\n  }\n\n  /**\n   * Runs lock work on the caller connection unless a positive hold timeout needs\n   * its own lock connection.\n   * @template T\n   * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withLockConnection(holdTimeoutMs, callback) {\n    if (holdTimeoutMs && holdTimeoutMs > 0) {\n      return await this.withDedicatedConnection(callback)\n    }\n\n    return await callback(this.connectionProvider())\n  }\n\n  /**\n   * Spawns a hold-timeout lock connection and closes it after lock work completes when\n   * the spawned driver owns the underlying physical connection.\n   * @template T\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withDedicatedConnection(callback) {\n    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()\n\n    try {\n      return await callback(connection)\n    } finally {\n      if (!connection.getArgs().getConnection) {\n        await connection.close()\n      }\n    }\n  }\n\n  /**\n   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has\n   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers\n   * use a dedicated advisory-lock connection so the lock can still be released.\n   * @template T\n   * @param {string} name - Lock name (for the error message).\n   * @param {() => Promise<T>} callback - Callback holding the lock.\n   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {\n    if (!holdTimeoutMs || holdTimeoutMs <= 0) {\n      return await callback()\n    }\n\n    let callbackSettled = false\n\n    try {\n      return await timeout({timeout: holdTimeoutMs}, async () => {\n        try {\n          return await callback()\n        } finally {\n          callbackSettled = true\n        }\n      })\n    } catch (error) {\n      if (!callbackSettled) {\n        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})\n      }\n\n      throw error\n    }\n  }\n}\n\nexport {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}\n"]}

package/build/src/database/drivers/mysql/index.d.ts

@@ -1,9 +1,10 @@
 export default class VelociousDatabaseDriversMysql extends Base {
+    /** @type {import("mysql").Pool | undefined} */
+    pool: import("mysql").Pool | undefined;
     /** @type {string | null} */
     _desiredSessionTimeZone: string | null;
     /** @type {string | null} */
     _currentSessionTimeZone: string | null;
-    pool: mysql.Pool | undefined;
     /**
      * On pool error.
      * @param {Error} error - Error from the connection attempt.
@@ -68,6 +69,5 @@ export default class VelociousDatabaseDriversMysql extends Base {
     _options: Options | undefined;
 }
 import Base from "../base.js";
-import mysql from "mysql";
 import Options from "./options.js";
 //# sourceMappingURL=index.d.ts.map

package/build/src/database/drivers/mysql/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/index.js"],"names":[],"mappings":"AAgCA;IACE,4BAA4B;IAC5B,yBADW,MAAM,GAAG,IAAI,CACU;IAElC,4BAA4B;IAC5B,yBADW,MAAM,GAAG,IAAI,CACM;IAQ5B,6BAAqF;IAIvF;;;OAGG;IACH,cAAe,OAFJ,KAES,UAEnB;IAyCD;;;OAGG;IACH,6BAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;;OAGG;IACH,oCAFW,MAAM,GAAG,IAAI,QAIvB;IAED;;;OAGG;IACH,6BAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;OAEG;IACH,oCAEC;IAED;;;OAGG;IACH,yBAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;OAGG;IACH,eAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAmB7B;IAcD;;;;;;OAMG;IACH,gCALW,MAAM,SAEd;QAAuB,WAAW;KAClC,GAAU,MAAM,EAAE,CAOpB;IAoDD;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IA4GD;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAQlB;IAoEqB,8BAA2C;CAuGlE;iBAriBgB,YAAY;kBAUX,OAAO;oBADL,cAAc"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/index.js"],"names":[],"mappings":"AAgCA;IACE,+CAA+C;IAC/C,MADW,OAAO,OAAO,EAAE,IAAI,GAAG,SAAS,CAC3B;IAEhB,4BAA4B;IAC5B,yBADW,MAAM,GAAG,IAAI,CACU;IAElC,4BAA4B;IAC5B,yBADW,MAAM,GAAG,IAAI,CACM;IAY9B;;;OAGG;IACH,cAAe,OAFJ,KAES,UAEnB;IAyCD;;;OAGG;IACH,6BAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;;OAGG;IACH,oCAFW,MAAM,GAAG,IAAI,QAIvB;IAED;;;OAGG;IACH,6BAFa,MAAM,GAAG,IAAI,CAIzB;IAED;;OAEG;IACH,oCAEC;IAED;;;OAGG;IACH,yBAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;OAGG;IACH,eAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAmB7B;IAcD;;;;;;OAMG;IACH,gCALW,MAAM,SAEd;QAAuB,WAAW;KAClC,GAAU,MAAM,EAAE,CAOpB;IAoDD;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IA4GD;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAQlB;IAoEqB,8BAA2C;CAuGlE;iBAxiBgB,YAAY;oBAST,cAAc"}