velocious 1.0.577 → 1.0.579

package/build/src/database/pool/base-methods-forward.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-methods-forward.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base-methods-forward.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qDAHW,cAAc,WAAW,EAAE,OAAO,GAChC,IAAI,CAuChB"}
+{"version":3,"file":"base-methods-forward.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base-methods-forward.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,QAAQ,EAHxC,cAAc,WAAW,EAAE,OAGa,GAFtC,IAAI,CAuChB"}

package/build/src/database/pool/base-methods-forward.js

@@ -27,11 +27,11 @@ export default function baseMethodsForward(PoolBase) {
         "update",
         "updateSql"
     ];
-    const prototype = /** @type {Record<string, (...args: Array<?>) => ?>} */ ( /** @type {?} */(PoolBase.prototype));
+    const prototype = /** @type {Record<string, (...args: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>>} */ ( /** @type {ReturnType<typeof JSON.parse>} */(PoolBase.prototype));
     for (const forwardMethod of forwardMethods) {
         prototype[forwardMethod] = function (...args) {
             const connection = this.getCurrentConnection();
-            const connectionRecord = /** @type {Record<string, (...args: Array<?>) => ?>} */ ( /** @type {?} */(connection));
+            const connectionRecord = /** @type {Record<string, (...args: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>>} */ ( /** @type {ReturnType<typeof JSON.parse>} */(connection));
             const connectionMethod = connectionRecord[forwardMethod];
             if (!connectionMethod)
                 throw new Error(`${forwardMethod} isn't defined on driver`);
@@ -39,4 +39,4 @@ export default function baseMethodsForward(PoolBase) {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/database/pool/base.d.ts

@@ -1,57 +1,24 @@
-/**
- * Opaque ownership handle for an in-process test shared connection registration.
- * @typedef {{owner: symbol}} TestSharedConnectionRegistration
- */
-/**
- * ConnectionCheckoutOptions type.
- * @typedef {object} ConnectionCheckoutOptions
- * @property {string} [name] - Human-readable name for the checked-out connection.
- */
-/**
- * DatabasePoolPendingCheckoutDebugSnapshot type.
- * @typedef {object} DatabasePoolPendingCheckoutDebugSnapshot
- * @property {string | undefined} checkoutName - Human-readable checkout name.
- * @property {number} enqueuedAt - Timestamp when the checkout started waiting.
- * @property {number} index - Pending checkout queue index.
- * @property {number | null} remainingTimeoutMs - Milliseconds before the checkout times out, or null when disabled.
- * @property {string} reuseKey - Database configuration reuse key needed by the checkout.
- * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.
- * @property {number | null} timeoutMillis - Timeout configured for the checkout, or null when disabled.
- * @property {number} waitingForMs - Milliseconds already spent waiting.
- */
-/**
- * DatabasePoolDebugSnapshot type.
- * @typedef {object} DatabasePoolDebugSnapshot
- * @property {Record<string, ?>} configuration - Sanitized resolved database configuration.
- * @property {Array<Record<string, ?>>} connections - Live connection snapshots.
- * @property {number} connectionsBeingSpawned - Number of in-progress connection spawns.
- * @property {number} idleCount - Number of idle connections.
- * @property {string} identifier - Database identifier.
- * @property {number} inUseCount - Number of checked-out connections.
- * @property {Array<DatabasePoolPendingCheckoutDebugSnapshot>} [pendingCheckouts] - Waiting checkout snapshots.
- * @property {number} pendingCheckoutCount - Number of queued checkout requests.
- * @property {string} poolClass - Pool class name.
- */
-export const POOL_CONFIGURATION_KEY: unique symbol;
-export default VelociousDatabasePoolBase;
-/**
- * Opaque ownership handle for an in-process test shared connection registration.
- */
+import Configuration from "../../configuration.js";
+import Logger from "../../logger.js";
 export type TestSharedConnectionRegistration = {
     owner: symbol;
 };
-/**
- * ConnectionCheckoutOptions type.
- */
 export type ConnectionCheckoutOptions = {
     /**
      * - Human-readable name for the checked-out connection.
      */
-    name?: string | undefined;
+    name?: string;
+};
+export type CapturedConnectionOptions = {
+    /**
+     * - Resolved physical database configuration captured by the caller.
+     */
+    databaseConfiguration: import("../../configuration-types.js").DatabaseConfigurationType;
+    /**
+     * - Human-readable name for the checked-out connection.
+     */
+    name?: string;
 };
-/**
- * DatabasePoolPendingCheckoutDebugSnapshot type.
- */
 export type DatabasePoolPendingCheckoutDebugSnapshot = {
     /**
      * - Human-readable checkout name.
@@ -86,18 +53,15 @@ export type DatabasePoolPendingCheckoutDebugSnapshot = {
      */
     waitingForMs: number;
 };
-/**
- * DatabasePoolDebugSnapshot type.
- */
 export type DatabasePoolDebugSnapshot = {
     /**
      * - Sanitized resolved database configuration.
      */
-    configuration: Record<string, unknown>;
+    configuration: Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * - Live connection snapshots.
      */
-    connections: Array<Record<string, unknown>>;
+    connections: Array<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * - Number of in-progress connection spawns.
      */
@@ -117,7 +81,7 @@ export type DatabasePoolDebugSnapshot = {
     /**
      * - Waiting checkout snapshots.
      */
-    pendingCheckouts?: DatabasePoolPendingCheckoutDebugSnapshot[] | undefined;
+    pendingCheckouts?: Array<DatabasePoolPendingCheckoutDebugSnapshot>;
     /**
      * - Number of queued checkout requests.
      */
@@ -127,7 +91,56 @@ export type DatabasePoolDebugSnapshot = {
      */
     poolClass: string;
 };
+/**
+ * Opaque ownership handle for an in-process test shared connection registration.
+ * @typedef {{owner: symbol}} TestSharedConnectionRegistration
+ */
+/**
+ * ConnectionCheckoutOptions type.
+ * @typedef {object} ConnectionCheckoutOptions
+ * @property {string} [name] - Human-readable name for the checked-out connection.
+ */
+/**
+ * CapturedConnectionOptions type.
+ * @typedef {object} CapturedConnectionOptions
+ * @property {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved physical database configuration captured by the caller.
+ * @property {string} [name] - Human-readable name for the checked-out connection.
+ */
+/**
+ * DatabasePoolPendingCheckoutDebugSnapshot type.
+ * @typedef {object} DatabasePoolPendingCheckoutDebugSnapshot
+ * @property {string | undefined} checkoutName - Human-readable checkout name.
+ * @property {number} enqueuedAt - Timestamp when the checkout started waiting.
+ * @property {number} index - Pending checkout queue index.
+ * @property {number | null} remainingTimeoutMs - Milliseconds before the checkout times out, or null when disabled.
+ * @property {string} reuseKey - Database configuration reuse key needed by the checkout.
+ * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.
+ * @property {number | null} timeoutMillis - Timeout configured for the checkout, or null when disabled.
+ * @property {number} waitingForMs - Milliseconds already spent waiting.
+ */
+/**
+ * DatabasePoolDebugSnapshot type.
+ * @typedef {object} DatabasePoolDebugSnapshot
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} configuration - Sanitized resolved database configuration.
+ * @property {Array<Record<string, ReturnType<typeof JSON.parse>>>} connections - Live connection snapshots.
+ * @property {number} connectionsBeingSpawned - Number of in-progress connection spawns.
+ * @property {number} idleCount - Number of idle connections.
+ * @property {string} identifier - Database identifier.
+ * @property {number} inUseCount - Number of checked-out connections.
+ * @property {Array<DatabasePoolPendingCheckoutDebugSnapshot>} [pendingCheckouts] - Waiting checkout snapshots.
+ * @property {number} pendingCheckoutCount - Number of queued checkout requests.
+ * @property {string} poolClass - Pool class name.
+ */
+export declare const POOL_CONFIGURATION_KEY: unique symbol;
 declare class VelociousDatabasePoolBase {
+    configuration: Configuration;
+    identifier: string;
+    logger: Logger;
+    driverClass: typeof import("../drivers/base.js").default | undefined;
+    /**
+     * Without current connection context.
+     * @type {undefined | ((callback: () => ReturnType<typeof JSON.parse>) => ReturnType<typeof JSON.parse>)} */
+    _withoutCurrentConnectionContext: undefined | ((callback: () => ReturnType<typeof JSON.parse>) => ReturnType<typeof JSON.parse>);
     /**
      * Runs current.
      * @returns {VelociousDatabasePoolBase} - The current.
@@ -149,13 +162,6 @@ declare class VelociousDatabasePoolBase {
         configuration: Configuration;
         identifier: string;
     });
-    /**
-     * Without current connection context.
-     * @type {undefined | ((callback: () => ?) => ?)} */
-    _withoutCurrentConnectionContext: undefined | ((callback: () => unknown) => unknown);
-    configuration: Configuration;
-    identifier: string;
-    logger: Logger;
     /**
      * Runs checkin.
      * @abstract
@@ -230,9 +236,10 @@ declare class VelociousDatabasePoolBase {
     getConfiguration(): import("../../configuration-types.js").DatabaseConfigurationType;
     /**
      * Runs get configuration reuse key.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} [databaseConfiguration] - Resolved configuration to identify.
      * @returns {string} - Reuse key for the currently resolved database configuration.
      */
-    getConfigurationReuseKey(): string;
+    getConfigurationReuseKey(databaseConfiguration?: import("../../configuration-types.js").DatabaseConfigurationType): string;
     /**
      * Runs connection matches current configuration.
      * @param {import("../drivers/base.js").default} connection - Connection.
@@ -273,12 +280,18 @@ declare class VelociousDatabasePoolBase {
      * @param {typeof import("../drivers/base.js").default} driverClass - Driver class.
      */
     setDriverClass(driverClass: typeof import("../drivers/base.js").default): void;
-    driverClass: typeof import("../drivers/base.js").default | undefined;
     /**
      * Runs spawn connection.
      * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection.
      */
     spawnConnection(): Promise<import("../drivers/base.js").default>;
+    /**
+     * Spawns a connection for an already-resolved physical database configuration.
+     * The reuse identity is derived only from that captured configuration.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Captured resolved configuration.
+     * @returns {Promise<import("../drivers/base.js").default>} - Connected and identity-stamped driver.
+     */
+    spawnConnectionForConfiguration(databaseConfiguration: import("../../configuration-types.js").DatabaseConfigurationType): Promise<import("../drivers/base.js").default>;
     /**
      * Runs spawn connection with configuration.
      * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Configuration object.
@@ -295,11 +308,11 @@ declare class VelociousDatabasePoolBase {
      * Runs with connection.
      * @template T
      * @abstract
-     * @param {ConnectionCheckoutOptions | function(import("../drivers/base.js").default) : Promise<T>} _optionsOrCallback - Checkout options or callback function.
-     * @param {function(import("../drivers/base.js").default) : Promise<T>} [_callback] - Callback function.
+     * @param {ConnectionCheckoutOptions | ((arg: import("../drivers/base.js").default) => Promise<T>)} _optionsOrCallback - Checkout options or callback function.
+     * @param {(arg: import("../drivers/base.js").default) => Promise<T>} [_callback] - Callback function.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
-    withConnection<T>(_optionsOrCallback: ConnectionCheckoutOptions | ((arg0: import("../drivers/base.js").default) => Promise<T>), _callback?: (arg0: import("../drivers/base.js").default) => Promise<T>): Promise<T>;
+    withConnection<T>(_optionsOrCallback: ConnectionCheckoutOptions | ((arg: import("../drivers/base.js").default) => Promise<T>), _callback?: (arg: import("../drivers/base.js").default) => Promise<T>): Promise<T>;
     /**
      * Runs an operation on a freshly checked-out connection.
      * @template T
@@ -308,6 +321,16 @@ declare class VelociousDatabasePoolBase {
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     withOperationConnection<T>(options: ConnectionCheckoutOptions, callback: (connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>): Promise<T>;
+    /**
+     * Runs work through a pool-owned checkout for an immutable, already-resolved
+     * physical configuration. Concrete pools must preserve their capacity,
+     * timeout, queue, debug, and closeAll ownership on this path.
+     * @template T
+     * @param {CapturedConnectionOptions} options - Captured checkout options.
+     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Operation callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    withCapturedOperationConnection<T>(options: CapturedConnectionOptions, callback: (connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>): Promise<T>;
     /**
      * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.
      * Default implementation just checks out a connection.
@@ -321,22 +344,21 @@ declare class VelociousDatabasePoolBase {
     getDebugSnapshot(): DatabasePoolDebugSnapshot;
     /**
      * Runs debug configuration snapshot.
-     * @returns {Record<string, ?>} - Sanitized resolved database configuration.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Sanitized resolved database configuration.
      */
-    debugConfigurationSnapshot(): Record<string, unknown>;
+    debugConfigurationSnapshot(): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Runs debug connection snapshot.
      * @param {import("../drivers/base.js").default} connection - Database connection.
-     * @param {Record<string, ?>} details - Extra diagnostic fields.
-     * @returns {Record<string, ?>} - Connection diagnostic snapshot.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} details - Extra diagnostic fields.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Connection diagnostic snapshot.
      */
-    debugConnectionSnapshot(connection: import("../drivers/base.js").default, details?: Record<string, unknown>): Record<string, unknown>;
+    debugConnectionSnapshot(connection: import("../drivers/base.js").default, details?: Record<string, ReturnType<typeof JSON.parse>>): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Closes all connections for this pool.
      * @returns {Promise<void>} - Resolves when complete.
      */
     closeAll(): Promise<void>;
 }
-import Configuration from "../../configuration.js";
-import Logger from "../../logger.js";
+export default VelociousDatabasePoolBase;
 //# sourceMappingURL=base.d.ts.map

package/build/src/database/pool/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base.js"],"names":[],"mappings":"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"}

package/build/src/database/pool/base.js

@@ -11,6 +11,12 @@ import baseMethodsForward from "./base-methods-forward.js";
  * @typedef {object} ConnectionCheckoutOptions
  * @property {string} [name] - Human-readable name for the checked-out connection.
  */
+/**
+ * CapturedConnectionOptions type.
+ * @typedef {object} CapturedConnectionOptions
+ * @property {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Resolved physical database configuration captured by the caller.
+ * @property {string} [name] - Human-readable name for the checked-out connection.
+ */
 /**
  * DatabasePoolPendingCheckoutDebugSnapshot type.
  * @typedef {object} DatabasePoolPendingCheckoutDebugSnapshot
@@ -26,8 +32,8 @@ import baseMethodsForward from "./base-methods-forward.js";
 /**
  * DatabasePoolDebugSnapshot type.
  * @typedef {object} DatabasePoolDebugSnapshot
- * @property {Record<string, ?>} configuration - Sanitized resolved database configuration.
- * @property {Array<Record<string, ?>>} connections - Live connection snapshots.
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} configuration - Sanitized resolved database configuration.
+ * @property {Array<Record<string, ReturnType<typeof JSON.parse>>>} connections - Live connection snapshots.
  * @property {number} connectionsBeingSpawned - Number of in-progress connection spawns.
  * @property {number} idleCount - Number of idle connections.
  * @property {string} identifier - Database identifier.
@@ -45,7 +51,7 @@ const shared = {
 };
 /**
  * Runs stable stringify.
- * @param {?} value - Value to stringify.
+ * @param {ReturnType<typeof JSON.parse>} value - Value to stringify.
  * @returns {string} - Stable JSON string.
  */
 function stableStringify(value) {
@@ -54,9 +60,9 @@ function stableStringify(value) {
     }
     if (value && typeof value === "object") {
         const entries = Object
-            .keys(/** @type {Record<string, ?>} */ (value))
+            .keys(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (value))
             .sort()
-            .map((key) => `${JSON.stringify(key)}:${stableStringify(/** @type {Record<string, ?>} */ (value)[key])}`);
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (value)[key])}`);
         return `{${entries.join(",")}}`;
     }
     return JSON.stringify(value);
@@ -64,7 +70,7 @@ function stableStringify(value) {
 class VelociousDatabasePoolBase {
     /**
      * Without current connection context.
-     * @type {undefined | ((callback: () => ?) => ?)} */
+     * @type {undefined | ((callback: () => ReturnType<typeof JSON.parse>) => ReturnType<typeof JSON.parse>)} */
     _withoutCurrentConnectionContext = undefined;
     /**
      * Runs current.
@@ -192,10 +198,10 @@ class VelociousDatabasePoolBase {
     }
     /**
      * Runs get configuration reuse key.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} [databaseConfiguration] - Resolved configuration to identify.
      * @returns {string} - Reuse key for the currently resolved database configuration.
      */
-    getConfigurationReuseKey() {
-        const databaseConfiguration = this.getConfiguration();
+    getConfigurationReuseKey(databaseConfiguration = this.getConfiguration()) {
         return stableStringify({
             database: databaseConfiguration.database,
             host: databaseConfiguration.host,
@@ -274,12 +280,22 @@ class VelociousDatabasePoolBase {
     async spawnConnection() {
         const databaseConfig = this.getConfiguration();
         this.logger.debug("spawnConnection", { identifier: this.identifier, databaseConfig });
-        const connection = await this.spawnConnectionWithConfiguration(databaseConfig);
+        return await this.spawnConnectionForConfiguration(databaseConfig);
+    }
+    /**
+     * Spawns a connection for an already-resolved physical database configuration.
+     * The reuse identity is derived only from that captured configuration.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfiguration - Captured resolved configuration.
+     * @returns {Promise<import("../drivers/base.js").default>} - Connected and identity-stamped driver.
+     */
+    async spawnConnectionForConfiguration(databaseConfiguration) {
+        const reuseKey = this.getConfigurationReuseKey(databaseConfiguration);
+        const connection = await this.spawnConnectionWithConfiguration(databaseConfiguration);
         const connectionWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
-        connectionWithPoolKey[POOL_CONFIGURATION_KEY] = this.getConfigurationReuseKey();
+        connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey;
         connection.setSchemaCacheInvalidator(() => {
             this.clearSchemaCache();
-            this.configuration.clearSchemaCachesForReuseKey(this.getConfigurationReuseKey());
+            this.configuration.clearSchemaCachesForReuseKey(reuseKey);
         });
         return connection;
     }
@@ -319,8 +335,8 @@ class VelociousDatabasePoolBase {
      * Runs with connection.
      * @template T
      * @abstract
-     * @param {ConnectionCheckoutOptions | function(import("../drivers/base.js").default) : Promise<T>} _optionsOrCallback - Checkout options or callback function.
-     * @param {function(import("../drivers/base.js").default) : Promise<T>} [_callback] - Callback function.
+     * @param {ConnectionCheckoutOptions | ((arg: import("../drivers/base.js").default) => Promise<T>)} _optionsOrCallback - Checkout options or callback function.
+     * @param {(arg: import("../drivers/base.js").default) => Promise<T>} [_callback] - Callback function.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     withConnection(_optionsOrCallback, _callback) {
@@ -337,6 +353,20 @@ class VelociousDatabasePoolBase {
         const owner = Symbol("database-operation-owner");
         return await this.withConnection(options, async (connection) => await callback(connection, owner));
     }
+    /**
+     * Runs work through a pool-owned checkout for an immutable, already-resolved
+     * physical configuration. Concrete pools must preserve their capacity,
+     * timeout, queue, debug, and closeAll ownership on this path.
+     * @template T
+     * @param {CapturedConnectionOptions} options - Captured checkout options.
+     * @param {(connection: import("../drivers/base.js").default, owner: symbol) => Promise<T>} callback - Operation callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async withCapturedOperationConnection(options, callback) {
+        void options;
+        void callback;
+        throw new Error("'withCapturedOperationConnection' not implemented");
+    }
     /**
      * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.
      * Default implementation just checks out a connection.
@@ -363,7 +393,7 @@ class VelociousDatabasePoolBase {
     }
     /**
      * Runs debug configuration snapshot.
-     * @returns {Record<string, ?>} - Sanitized resolved database configuration.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Sanitized resolved database configuration.
      */
     debugConfigurationSnapshot() {
         const databaseConfig = this.getConfiguration();
@@ -385,8 +415,8 @@ class VelociousDatabasePoolBase {
     /**
      * Runs debug connection snapshot.
      * @param {import("../drivers/base.js").default} connection - Database connection.
-     * @param {Record<string, ?>} details - Extra diagnostic fields.
-     * @returns {Record<string, ?>} - Connection diagnostic snapshot.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} details - Extra diagnostic fields.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Connection diagnostic snapshot.
      */
     debugConnectionSnapshot(connection, details = {}) {
         const connectionWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
@@ -404,4 +434,4 @@ class VelociousDatabasePoolBase {
 }
 baseMethodsForward(VelociousDatabasePoolBase);
 export default VelociousDatabasePoolBase;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/database/pool/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration from \"../../configuration.js\"\nimport Logger from \"../../logger.js\"\nimport baseMethodsForward from \"./base-methods-forward.js\"\n\n/**\n * Opaque ownership handle for an in-process test shared connection registration.\n * @typedef {{owner: symbol}} TestSharedConnectionRegistration\n */\n\n/**\n * ConnectionCheckoutOptions type.\n * @typedef {object} ConnectionCheckoutOptions\n * @property {string} [name] - Human-readable name for the checked-out connection.\n */\n/**\n * DatabasePoolPendingCheckoutDebugSnapshot type.\n * @typedef {object} DatabasePoolPendingCheckoutDebugSnapshot\n * @property {string | undefined} checkoutName - Human-readable checkout name.\n * @property {number} enqueuedAt - Timestamp when the checkout started waiting.\n * @property {number} index - Pending checkout queue index.\n * @property {number | null} remainingTimeoutMs - Milliseconds before the checkout times out, or null when disabled.\n * @property {string} reuseKey - Database configuration reuse key needed by the checkout.\n * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.\n * @property {number | null} timeoutMillis - Timeout configured for the checkout, or null when disabled.\n * @property {number} waitingForMs - Milliseconds already spent waiting.\n */\n/**\n * DatabasePoolDebugSnapshot type.\n * @typedef {object} DatabasePoolDebugSnapshot\n * @property {Record<string, ?>} configuration - Sanitized resolved database configuration.\n * @property {Array<Record<string, ?>>} connections - Live connection snapshots.\n * @property {number} connectionsBeingSpawned - Number of in-progress connection spawns.\n * @property {number} idleCount - Number of idle connections.\n * @property {string} identifier - Database identifier.\n * @property {number} inUseCount - Number of checked-out connections.\n * @property {Array<DatabasePoolPendingCheckoutDebugSnapshot>} [pendingCheckouts] - Waiting checkout snapshots.\n * @property {number} pendingCheckoutCount - Number of queued checkout requests.\n * @property {string} poolClass - Pool class name.\n */\nexport const POOL_CONFIGURATION_KEY = Symbol(\"velociousPoolConfigurationKey\")\n\n/**\n * Shared.\n * @type {{currentPool: VelociousDatabasePoolBase | null}} */\nconst shared = {\n  currentPool: null\n}\n\n/**\n * Runs stable stringify.\n * @param {?} value - Value to stringify.\n * @returns {string} - Stable JSON string.\n */\nfunction stableStringify(value) {\n  if (Array.isArray(value)) {\n    return `[${value.map((entry) => stableStringify(entry)).join(\",\")}]`\n  }\n\n  if (value && typeof value === \"object\") {\n    const entries = Object\n      .keys(/** @type {Record<string, ?>} */ (value))\n      .sort()\n      .map((key) => `${JSON.stringify(key)}:${stableStringify(/** @type {Record<string, ?>} */ (value)[key])}`)\n\n    return `{${entries.join(\",\")}}`\n  }\n\n  return JSON.stringify(value)\n}\n\nclass VelociousDatabasePoolBase {\n  /**\n   * Without current connection context.\n   * @type {undefined | ((callback: () => ?) => ?)} */\n  _withoutCurrentConnectionContext = undefined\n\n  /**\n   * Runs current.\n   * @returns {VelociousDatabasePoolBase} - The current.\n   */\n  static current() {\n    if (!shared.currentPool) throw new Error(\"A database pool hasn't been set\")\n\n    return shared.currentPool\n  }\n\n  /**\n   * Clears any global connections for the given configuration.\n   * @param {import(\"../../configuration.js\").default} configuration - Configuration owning the pool.\n   * @returns {void} - No return value.\n   */\n  static clearGlobalConnections(configuration) { void configuration }\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {Configuration} args.configuration - Configuration instance.\n   * @param {string} args.identifier - Identifier.\n   */\n  constructor({configuration, identifier}) {\n    this.configuration = configuration || Configuration.current()\n\n    if (!this.configuration) throw new Error(\"No configuration given\")\n    if (!identifier) throw new Error(\"No identifier was given\")\n\n    this.identifier = identifier\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * Runs checkin.\n   * @abstract\n   * @param {import(\"../drivers/base.js\").default} _connection - Connection.\n   */\n  checkin(_connection) {\n    throw new Error(\"'checkin' not implemented\")\n  }\n\n  /**\n   * Runs checkout.\n   * @abstract\n   * @param {ConnectionCheckoutOptions} [_options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the checkout.\n   */\n  checkout(_options) {\n    throw new Error(\"'checkout' not implemented\")\n  }\n\n  /**\n   * Runs get current connection.\n   * @abstract\n   * @returns {import(\"../drivers/base.js\").default} - The current connection.\n   */\n  getCurrentConnection() {\n    throw new Error(\"'getCurrentConnection' not implemented\")\n  }\n\n  /**\n   * Returns the connection pinned to the current context, if any.\n   * Default implementation defers to `getCurrentConnection`.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The current context connection.\n   */\n  getCurrentContextConnection() {\n    return this.getCurrentConnection()\n  }\n\n  /**\n   * Pins a connection to be returned to callers that run without a connection-context\n   * pin (used by the test runner to share one connection with in-process HTTP handlers).\n   * Base pools that do not track async context ignore it; async-context pools override.\n   * @param {import(\"../drivers/base.js\").default} _connection - Shared connection.\n   * @returns {TestSharedConnectionRegistration | undefined} - Opaque registration handle when supported.\n   */\n  setTestSharedConnection(_connection) {\n    return undefined\n  }\n\n  /**\n   * Sets a provider that resolves the connection eligible for in-process test request sharing.\n   * Base pools that do not track async context ignore it; async-context pools override.\n   * @param {() => import(\"../drivers/base.js\").default | undefined} _provider - Shared connection provider.\n   * @returns {TestSharedConnectionRegistration | undefined} - Opaque registration handle when supported.\n   */\n  setTestSharedConnectionProvider(_provider) {\n    return undefined\n  }\n\n  /**\n   * Clears the shared connection or provider set for in-process test requests. No-op by default.\n   * When a registration is provided, clears only if it is still the active registration.\n   * @param {TestSharedConnectionRegistration} [_registration] - Opaque handle returned when the shared value was set.\n   * @returns {void}\n   */\n  clearTestSharedConnection(_registration) {}\n\n  /**\n   * Runs a callback inside the test shared connection's context. Base pools that do not\n   * track async context just run the callback as-is; async-context pools override.\n   * @template T\n   * @param {() => T} callback - Callback to run.\n   * @returns {T} - Callback result.\n   */\n  runWithTestSharedConnection(callback) {\n    return callback()\n  }\n\n  /**\n   * Returns whether the current connection is pinned to an execution context.\n   * @returns {boolean} - Whether the current connection can be reused by nested code.\n   */\n  hasCurrentConnectionContext() {\n    return true\n  }\n\n  /**\n   * Runs without current connection context.\n   * @template T\n   * @param {() => T} callback - Callback to run without ? current connection context.\n   * @returns {T} - Callback result.\n   */\n  withoutCurrentConnectionContext(callback) {\n    if (this._withoutCurrentConnectionContext) return /** @type {T} */ (this._withoutCurrentConnectionContext(callback))\n\n    return callback()\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../../configuration-types.js\").DatabaseConfigurationType} - Resolved database configuration for the pool identifier.\n   */\n  getConfiguration() {\n    return this.configuration.resolveDatabaseConfiguration(this.identifier)\n  }\n\n  /**\n   * Runs get configuration reuse key.\n   * @returns {string} - Reuse key for the currently resolved database configuration.\n   */\n  getConfigurationReuseKey() {\n    const databaseConfiguration = this.getConfiguration()\n\n    return stableStringify({\n      database: databaseConfiguration.database,\n      host: databaseConfiguration.host,\n      name: databaseConfiguration.name,\n      port: databaseConfiguration.port,\n      schema: databaseConfiguration.schema,\n      schemaCache: databaseConfiguration.schemaCache,\n      sqlConfig: databaseConfiguration.sqlConfig,\n      type: databaseConfiguration.type,\n      useDatabase: databaseConfiguration.useDatabase,\n      username: databaseConfiguration.username\n    })\n  }\n\n  /**\n   * Runs connection matches current configuration.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {boolean} - Whether connection matches current resolved configuration.\n   */\n  connectionMatchesCurrentConfiguration(connection) {\n    return this.getConnectionConfigurationReuseKey(connection) === this.getConfigurationReuseKey()\n  }\n\n  /**\n   * Returns the resolved database configuration key stamped on a connection at checkout.\n   * @param {import(\"../drivers/base.js\").default} connection - Checked-out connection.\n   * @returns {string} - Connection configuration reuse key.\n   */\n  getConnectionConfigurationReuseKey(connection) {\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n    const reuseKey = connectionWithPoolKey[POOL_CONFIGURATION_KEY]\n\n    if (!reuseKey) throw new Error(\"Database connection is missing its configuration reuse key\")\n\n    return reuseKey\n  }\n\n  /**\n   * Clears schema metadata cached by this pool's current connection.\n   * Pools that keep multiple connections alive should override this to clear every live connection.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    this._clearConnectionSchemaCache(this.getCurrentConnection())\n  }\n\n  /**\n   * Runs clear connection schema cache.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection whose local schema cache should be cleared.\n   * @returns {void} - No return value.\n   */\n  _clearConnectionSchemaCache(connection) {\n    connection._clearLocalSchemaCache()\n  }\n\n  /**\n   * Runs primary key type.\n   * @abstract\n   * @returns {string} - The primary key type.\n   */\n  primaryKeyType() {\n    throw new Error(\"'primaryKeyType' not implemented\")\n  }\n\n  /**\n   * Runs set current.\n   * @returns {void} - No return value.\n   */\n  setCurrent() {\n    shared.currentPool = this\n  }\n\n  /**\n   * Runs set driver class.\n   * @param {typeof import(\"../drivers/base.js\").default} driverClass - Driver class.\n   */\n  setDriverClass(driverClass) {\n    this.driverClass = driverClass\n  }\n\n  /**\n   * Runs spawn connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the spawn connection.\n   */\n  async spawnConnection() {\n    const databaseConfig = this.getConfiguration()\n\n    this.logger.debug(\"spawnConnection\", {identifier: this.identifier, databaseConfig})\n\n    const connection = await this.spawnConnectionWithConfiguration(databaseConfig)\n\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n    connectionWithPoolKey[POOL_CONFIGURATION_KEY] = this.getConfigurationReuseKey()\n    connection.setSchemaCacheInvalidator(() => {\n      this.clearSchemaCache()\n      this.configuration.clearSchemaCachesForReuseKey(this.getConfigurationReuseKey())\n    })\n\n    return connection\n  }\n\n  /**\n   * Runs spawn connection with configuration.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} config - Configuration object.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the spawn connection with configuration.\n   */\n  async spawnConnectionWithConfiguration(config) {\n    const DriverClass = config.driver || this.driverClass\n\n    if (!DriverClass) throw new Error(\"No driver class set in database pool or in given config\")\n\n    const connection = new DriverClass(config, this.configuration)\n\n    try {\n      await connection.connect()\n    } catch (error) {\n      await this.closeConnectionAfterFailedConnect(connection)\n      throw error\n    }\n\n    return connection\n  }\n\n  /**\n   * Runs close connection after failed connect.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to close.\n   * @returns {Promise<void>} - Resolves when cleanup has been attempted.\n   */\n  async closeConnectionAfterFailedConnect(connection) {\n    try {\n      await connection.close()\n    } catch (error) {\n      this.logger.warn(\"Failed to close database connection after connect failed\", {error})\n    }\n  }\n\n  /**\n   * Runs with connection.\n   * @template T\n   * @abstract\n   * @param {ConnectionCheckoutOptions | function(import(\"../drivers/base.js\").default) : Promise<T>} _optionsOrCallback - Checkout options or callback function.\n   * @param {function(import(\"../drivers/base.js\").default) : Promise<T>} [_callback] - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  withConnection(_optionsOrCallback, _callback) {\n    throw new Error(\"'withConnection' not implemented\")\n  }\n\n  /**\n   * Runs an operation on a freshly checked-out connection.\n   * @template T\n   * @param {ConnectionCheckoutOptions} options - Checkout options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Operation callback.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withOperationConnection(options, callback) {\n    const owner = Symbol(\"database-operation-owner\")\n\n    return await this.withConnection(options, async (connection) => await callback(connection, owner))\n  }\n\n  /**\n   * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.\n   * Default implementation just checks out a connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the global connection.\n   */\n  async ensureGlobalConnection() {\n    return await this.checkout()\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.\n   */\n  getDebugSnapshot() {\n    return {\n      configuration: this.debugConfigurationSnapshot(),\n      connections: [],\n      connectionsBeingSpawned: 0,\n      identifier: this.identifier,\n      idleCount: 0,\n      inUseCount: 0,\n      pendingCheckoutCount: 0,\n      poolClass: this.constructor.name\n    }\n  }\n\n  /**\n   * Runs debug configuration snapshot.\n   * @returns {Record<string, ?>} - Sanitized resolved database configuration.\n   */\n  debugConfigurationSnapshot() {\n    const databaseConfig = this.getConfiguration()\n    const poolConfig = databaseConfig.pool\n\n    return {\n      database: databaseConfig.database,\n      driver: databaseConfig.driver?.name,\n      host: databaseConfig.host,\n      migrations: databaseConfig.migrations,\n      name: databaseConfig.name,\n      pool: poolConfig ? {idleTimeoutMillis: poolConfig.idleTimeoutMillis, max: poolConfig.max} : undefined,\n      port: databaseConfig.port,\n      schema: databaseConfig.schema,\n      type: databaseConfig.type,\n      useDatabase: databaseConfig.useDatabase,\n      username: databaseConfig.username\n    }\n  }\n\n  /**\n   * Runs debug connection snapshot.\n   * @param {import(\"../drivers/base.js\").default} connection - Database connection.\n   * @param {Record<string, ?>} details - Extra diagnostic fields.\n   * @returns {Record<string, ?>} - Connection diagnostic snapshot.\n   */\n  debugConnectionSnapshot(connection, details = {}) {\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n    return {\n      ...connection.getDebugSnapshot(),\n      ...details,\n      reuseKey: connectionWithPoolKey[POOL_CONFIGURATION_KEY]\n    }\n  }\n\n  /**\n   * Closes all connections for this pool.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeAll() {}\n}\n\nbaseMethodsForward(VelociousDatabasePoolBase)\n\nexport default VelociousDatabasePoolBase\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/database/pool/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration from \"../../configuration.js\"\nimport Logger from \"../../logger.js\"\nimport baseMethodsForward from \"./base-methods-forward.js\"\n\n/**\n * Opaque ownership handle for an in-process test shared connection registration.\n * @typedef {{owner: symbol}} TestSharedConnectionRegistration\n */\n\n/**\n * ConnectionCheckoutOptions type.\n * @typedef {object} ConnectionCheckoutOptions\n * @property {string} [name] - Human-readable name for the checked-out connection.\n */\n/**\n * CapturedConnectionOptions type.\n * @typedef {object} CapturedConnectionOptions\n * @property {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Resolved physical database configuration captured by the caller.\n * @property {string} [name] - Human-readable name for the checked-out connection.\n */\n/**\n * DatabasePoolPendingCheckoutDebugSnapshot type.\n * @typedef {object} DatabasePoolPendingCheckoutDebugSnapshot\n * @property {string | undefined} checkoutName - Human-readable checkout name.\n * @property {number} enqueuedAt - Timestamp when the checkout started waiting.\n * @property {number} index - Pending checkout queue index.\n * @property {number | null} remainingTimeoutMs - Milliseconds before the checkout times out, or null when disabled.\n * @property {string} reuseKey - Database configuration reuse key needed by the checkout.\n * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.\n * @property {number | null} timeoutMillis - Timeout configured for the checkout, or null when disabled.\n * @property {number} waitingForMs - Milliseconds already spent waiting.\n */\n/**\n * DatabasePoolDebugSnapshot type.\n * @typedef {object} DatabasePoolDebugSnapshot\n * @property {Record<string, ReturnType<typeof JSON.parse>>} configuration - Sanitized resolved database configuration.\n * @property {Array<Record<string, ReturnType<typeof JSON.parse>>>} connections - Live connection snapshots.\n * @property {number} connectionsBeingSpawned - Number of in-progress connection spawns.\n * @property {number} idleCount - Number of idle connections.\n * @property {string} identifier - Database identifier.\n * @property {number} inUseCount - Number of checked-out connections.\n * @property {Array<DatabasePoolPendingCheckoutDebugSnapshot>} [pendingCheckouts] - Waiting checkout snapshots.\n * @property {number} pendingCheckoutCount - Number of queued checkout requests.\n * @property {string} poolClass - Pool class name.\n */\nexport const POOL_CONFIGURATION_KEY = Symbol(\"velociousPoolConfigurationKey\")\n\n/**\n * Shared.\n * @type {{currentPool: VelociousDatabasePoolBase | null}} */\nconst shared = {\n  currentPool: null\n}\n\n/**\n * Runs stable stringify.\n * @param {ReturnType<typeof JSON.parse>} value - Value to stringify.\n * @returns {string} - Stable JSON string.\n */\nfunction stableStringify(value) {\n  if (Array.isArray(value)) {\n    return `[${value.map((entry) => stableStringify(entry)).join(\",\")}]`\n  }\n\n  if (value && typeof value === \"object\") {\n    const entries = Object\n      .keys(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (value))\n      .sort()\n      .map((key) => `${JSON.stringify(key)}:${stableStringify(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (value)[key])}`)\n\n    return `{${entries.join(\",\")}}`\n  }\n\n  return JSON.stringify(value)\n}\n\nclass VelociousDatabasePoolBase {\n  /**\n   * Without current connection context.\n   * @type {undefined | ((callback: () => ReturnType<typeof JSON.parse>) => ReturnType<typeof JSON.parse>)} */\n  _withoutCurrentConnectionContext = undefined\n\n  /**\n   * Runs current.\n   * @returns {VelociousDatabasePoolBase} - The current.\n   */\n  static current() {\n    if (!shared.currentPool) throw new Error(\"A database pool hasn't been set\")\n\n    return shared.currentPool\n  }\n\n  /**\n   * Clears any global connections for the given configuration.\n   * @param {import(\"../../configuration.js\").default} configuration - Configuration owning the pool.\n   * @returns {void} - No return value.\n   */\n  static clearGlobalConnections(configuration) { void configuration }\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {Configuration} args.configuration - Configuration instance.\n   * @param {string} args.identifier - Identifier.\n   */\n  constructor({configuration, identifier}) {\n    this.configuration = configuration || Configuration.current()\n\n    if (!this.configuration) throw new Error(\"No configuration given\")\n    if (!identifier) throw new Error(\"No identifier was given\")\n\n    this.identifier = identifier\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * Runs checkin.\n   * @abstract\n   * @param {import(\"../drivers/base.js\").default} _connection - Connection.\n   */\n  checkin(_connection) {\n    throw new Error(\"'checkin' not implemented\")\n  }\n\n  /**\n   * Runs checkout.\n   * @abstract\n   * @param {ConnectionCheckoutOptions} [_options] - Checkout options.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the checkout.\n   */\n  checkout(_options) {\n    throw new Error(\"'checkout' not implemented\")\n  }\n\n  /**\n   * Runs get current connection.\n   * @abstract\n   * @returns {import(\"../drivers/base.js\").default} - The current connection.\n   */\n  getCurrentConnection() {\n    throw new Error(\"'getCurrentConnection' not implemented\")\n  }\n\n  /**\n   * Returns the connection pinned to the current context, if any.\n   * Default implementation defers to `getCurrentConnection`.\n   * @returns {import(\"../drivers/base.js\").default | undefined} - The current context connection.\n   */\n  getCurrentContextConnection() {\n    return this.getCurrentConnection()\n  }\n\n  /**\n   * Pins a connection to be returned to callers that run without a connection-context\n   * pin (used by the test runner to share one connection with in-process HTTP handlers).\n   * Base pools that do not track async context ignore it; async-context pools override.\n   * @param {import(\"../drivers/base.js\").default} _connection - Shared connection.\n   * @returns {TestSharedConnectionRegistration | undefined} - Opaque registration handle when supported.\n   */\n  setTestSharedConnection(_connection) {\n    return undefined\n  }\n\n  /**\n   * Sets a provider that resolves the connection eligible for in-process test request sharing.\n   * Base pools that do not track async context ignore it; async-context pools override.\n   * @param {() => import(\"../drivers/base.js\").default | undefined} _provider - Shared connection provider.\n   * @returns {TestSharedConnectionRegistration | undefined} - Opaque registration handle when supported.\n   */\n  setTestSharedConnectionProvider(_provider) {\n    return undefined\n  }\n\n  /**\n   * Clears the shared connection or provider set for in-process test requests. No-op by default.\n   * When a registration is provided, clears only if it is still the active registration.\n   * @param {TestSharedConnectionRegistration} [_registration] - Opaque handle returned when the shared value was set.\n   * @returns {void}\n   */\n  clearTestSharedConnection(_registration) {}\n\n  /**\n   * Runs a callback inside the test shared connection's context. Base pools that do not\n   * track async context just run the callback as-is; async-context pools override.\n   * @template T\n   * @param {() => T} callback - Callback to run.\n   * @returns {T} - Callback result.\n   */\n  runWithTestSharedConnection(callback) {\n    return callback()\n  }\n\n  /**\n   * Returns whether the current connection is pinned to an execution context.\n   * @returns {boolean} - Whether the current connection can be reused by nested code.\n   */\n  hasCurrentConnectionContext() {\n    return true\n  }\n\n  /**\n   * Runs without current connection context.\n   * @template T\n   * @param {() => T} callback - Callback to run without ? current connection context.\n   * @returns {T} - Callback result.\n   */\n  withoutCurrentConnectionContext(callback) {\n    if (this._withoutCurrentConnectionContext) return /** @type {T} */ (this._withoutCurrentConnectionContext(callback))\n\n    return callback()\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../../configuration-types.js\").DatabaseConfigurationType} - Resolved database configuration for the pool identifier.\n   */\n  getConfiguration() {\n    return this.configuration.resolveDatabaseConfiguration(this.identifier)\n  }\n\n  /**\n   * Runs get configuration reuse key.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} [databaseConfiguration] - Resolved configuration to identify.\n   * @returns {string} - Reuse key for the currently resolved database configuration.\n   */\n  getConfigurationReuseKey(databaseConfiguration = this.getConfiguration()) {\n    return stableStringify({\n      database: databaseConfiguration.database,\n      host: databaseConfiguration.host,\n      name: databaseConfiguration.name,\n      port: databaseConfiguration.port,\n      schema: databaseConfiguration.schema,\n      schemaCache: databaseConfiguration.schemaCache,\n      sqlConfig: databaseConfiguration.sqlConfig,\n      type: databaseConfiguration.type,\n      useDatabase: databaseConfiguration.useDatabase,\n      username: databaseConfiguration.username\n    })\n  }\n\n  /**\n   * Runs connection matches current configuration.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection.\n   * @returns {boolean} - Whether connection matches current resolved configuration.\n   */\n  connectionMatchesCurrentConfiguration(connection) {\n    return this.getConnectionConfigurationReuseKey(connection) === this.getConfigurationReuseKey()\n  }\n\n  /**\n   * Returns the resolved database configuration key stamped on a connection at checkout.\n   * @param {import(\"../drivers/base.js\").default} connection - Checked-out connection.\n   * @returns {string} - Connection configuration reuse key.\n   */\n  getConnectionConfigurationReuseKey(connection) {\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n    const reuseKey = connectionWithPoolKey[POOL_CONFIGURATION_KEY]\n\n    if (!reuseKey) throw new Error(\"Database connection is missing its configuration reuse key\")\n\n    return reuseKey\n  }\n\n  /**\n   * Clears schema metadata cached by this pool's current connection.\n   * Pools that keep multiple connections alive should override this to clear every live connection.\n   * @returns {void} - No return value.\n   */\n  clearSchemaCache() {\n    this._clearConnectionSchemaCache(this.getCurrentConnection())\n  }\n\n  /**\n   * Runs clear connection schema cache.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection whose local schema cache should be cleared.\n   * @returns {void} - No return value.\n   */\n  _clearConnectionSchemaCache(connection) {\n    connection._clearLocalSchemaCache()\n  }\n\n  /**\n   * Runs primary key type.\n   * @abstract\n   * @returns {string} - The primary key type.\n   */\n  primaryKeyType() {\n    throw new Error(\"'primaryKeyType' not implemented\")\n  }\n\n  /**\n   * Runs set current.\n   * @returns {void} - No return value.\n   */\n  setCurrent() {\n    shared.currentPool = this\n  }\n\n  /**\n   * Runs set driver class.\n   * @param {typeof import(\"../drivers/base.js\").default} driverClass - Driver class.\n   */\n  setDriverClass(driverClass) {\n    this.driverClass = driverClass\n  }\n\n  /**\n   * Runs spawn connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the spawn connection.\n   */\n  async spawnConnection() {\n    const databaseConfig = this.getConfiguration()\n\n    this.logger.debug(\"spawnConnection\", {identifier: this.identifier, databaseConfig})\n\n    return await this.spawnConnectionForConfiguration(databaseConfig)\n  }\n\n  /**\n   * Spawns a connection for an already-resolved physical database configuration.\n   * The reuse identity is derived only from that captured configuration.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} databaseConfiguration - Captured resolved configuration.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Connected and identity-stamped driver.\n   */\n  async spawnConnectionForConfiguration(databaseConfiguration) {\n    const reuseKey = this.getConfigurationReuseKey(databaseConfiguration)\n    const connection = await this.spawnConnectionWithConfiguration(databaseConfiguration)\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n    connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey\n    connection.setSchemaCacheInvalidator(() => {\n      this.clearSchemaCache()\n      this.configuration.clearSchemaCachesForReuseKey(reuseKey)\n    })\n\n    return connection\n  }\n\n  /**\n   * Runs spawn connection with configuration.\n   * @param {import(\"../../configuration-types.js\").DatabaseConfigurationType} config - Configuration object.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the spawn connection with configuration.\n   */\n  async spawnConnectionWithConfiguration(config) {\n    const DriverClass = config.driver || this.driverClass\n\n    if (!DriverClass) throw new Error(\"No driver class set in database pool or in given config\")\n\n    const connection = new DriverClass(config, this.configuration)\n\n    try {\n      await connection.connect()\n    } catch (error) {\n      await this.closeConnectionAfterFailedConnect(connection)\n      throw error\n    }\n\n    return connection\n  }\n\n  /**\n   * Runs close connection after failed connect.\n   * @param {import(\"../drivers/base.js\").default} connection - Connection to close.\n   * @returns {Promise<void>} - Resolves when cleanup has been attempted.\n   */\n  async closeConnectionAfterFailedConnect(connection) {\n    try {\n      await connection.close()\n    } catch (error) {\n      this.logger.warn(\"Failed to close database connection after connect failed\", {error})\n    }\n  }\n\n  /**\n   * Runs with connection.\n   * @template T\n   * @abstract\n   * @param {ConnectionCheckoutOptions | ((arg: import(\"../drivers/base.js\").default) => Promise<T>)} _optionsOrCallback - Checkout options or callback function.\n   * @param {(arg: import(\"../drivers/base.js\").default) => Promise<T>} [_callback] - Callback function.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  withConnection(_optionsOrCallback, _callback) {\n    throw new Error(\"'withConnection' not implemented\")\n  }\n\n  /**\n   * Runs an operation on a freshly checked-out connection.\n   * @template T\n   * @param {ConnectionCheckoutOptions} options - Checkout options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Operation callback.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withOperationConnection(options, callback) {\n    const owner = Symbol(\"database-operation-owner\")\n\n    return await this.withConnection(options, async (connection) => await callback(connection, owner))\n  }\n\n  /**\n   * Runs work through a pool-owned checkout for an immutable, already-resolved\n   * physical configuration. Concrete pools must preserve their capacity,\n   * timeout, queue, debug, and closeAll ownership on this path.\n   * @template T\n   * @param {CapturedConnectionOptions} options - Captured checkout options.\n   * @param {(connection: import(\"../drivers/base.js\").default, owner: symbol) => Promise<T>} callback - Operation callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async withCapturedOperationConnection(options, callback) {\n    void options\n    void callback\n    throw new Error(\"'withCapturedOperationConnection' not implemented\")\n  }\n\n  /**\n   * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.\n   * Default implementation just checks out a connection.\n   * @returns {Promise<import(\"../drivers/base.js\").default>} - Resolves with the global connection.\n   */\n  async ensureGlobalConnection() {\n    return await this.checkout()\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.\n   */\n  getDebugSnapshot() {\n    return {\n      configuration: this.debugConfigurationSnapshot(),\n      connections: [],\n      connectionsBeingSpawned: 0,\n      identifier: this.identifier,\n      idleCount: 0,\n      inUseCount: 0,\n      pendingCheckoutCount: 0,\n      poolClass: this.constructor.name\n    }\n  }\n\n  /**\n   * Runs debug configuration snapshot.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Sanitized resolved database configuration.\n   */\n  debugConfigurationSnapshot() {\n    const databaseConfig = this.getConfiguration()\n    const poolConfig = databaseConfig.pool\n\n    return {\n      database: databaseConfig.database,\n      driver: databaseConfig.driver?.name,\n      host: databaseConfig.host,\n      migrations: databaseConfig.migrations,\n      name: databaseConfig.name,\n      pool: poolConfig ? {idleTimeoutMillis: poolConfig.idleTimeoutMillis, max: poolConfig.max} : undefined,\n      port: databaseConfig.port,\n      schema: databaseConfig.schema,\n      type: databaseConfig.type,\n      useDatabase: databaseConfig.useDatabase,\n      username: databaseConfig.username\n    }\n  }\n\n  /**\n   * Runs debug connection snapshot.\n   * @param {import(\"../drivers/base.js\").default} connection - Database connection.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} details - Extra diagnostic fields.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Connection diagnostic snapshot.\n   */\n  debugConnectionSnapshot(connection, details = {}) {\n    const connectionWithPoolKey = /** @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n    return {\n      ...connection.getDebugSnapshot(),\n      ...details,\n      reuseKey: connectionWithPoolKey[POOL_CONFIGURATION_KEY]\n    }\n  }\n\n  /**\n   * Closes all connections for this pool.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async closeAll() {}\n}\n\nbaseMethodsForward(VelociousDatabasePoolBase)\n\nexport default VelociousDatabasePoolBase\n"]}