velocious 1.0.431 → 1.0.433

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

@@ -1,17 +1,13 @@
 // @ts-check
-
-import Configuration from "../../configuration.js"
-import Logger from "../../logger.js"
-import baseMethodsForward from "./base-methods-forward.js"
-
-export const POOL_CONFIGURATION_KEY = Symbol("velociousPoolConfigurationKey")
-
+import Configuration from "../../configuration.js";
+import Logger from "../../logger.js";
+import baseMethodsForward from "./base-methods-forward.js";
+export const POOL_CONFIGURATION_KEY = Symbol("velociousPoolConfigurationKey");
 /**
  * ConnectionCheckoutOptions type.
  * @typedef {object} ConnectionCheckoutOptions
  * @property {string} [name] - Human-readable name for the checked-out connection.
  */
-
 /**
  * DatabasePoolDebugSnapshot type.
  * @typedef {object} DatabasePoolDebugSnapshot
@@ -25,356 +21,315 @@ export const POOL_CONFIGURATION_KEY = Symbol("velociousPoolConfigurationKey")
  * @property {number} pendingCheckoutCount - Number of queued checkout requests.
  * @property {string} poolClass - Pool class name.
  */
-
 /**
  * Shared.
   @type {{currentPool: VelociousDatabasePoolBase | null}} */
 const shared = {
-  currentPool: null
-}
-
+    currentPool: null
+};
 /**
  * Runs stable stringify.
  * @param {?} value - Value to stringify.
  * @returns {string} - Stable JSON string.
  */
 function stableStringify(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`
-  }
-
-  if (value && typeof value === "object") {
-    const entries = Object
-      .keys(/**
-             * Narrows the runtime value to the documented type.
-              @type {Record<string, ?>} */ (value))
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${stableStringify(/**
-                                                               * Narrows the runtime value to the documented type.
-                                                                @type {Record<string, ?>} */ (value)[key])}`)
-
-    return `{${entries.join(",")}}`
-  }
-
-  return JSON.stringify(value)
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object
+            .keys(/**
+               * Narrows the runtime value to the documented type.
+                @type {Record<string, ?>} */ (value))
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(/**
+                                                                 * Narrows the runtime value to the documented type.
+                                                                  @type {Record<string, ?>} */ (value)[key])}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value);
 }
-
 class VelociousDatabasePoolBase {
-  /**
-   * Without current connection context.
-    @type {undefined | ((callback: () => ?) => ?)} */
-  _withoutCurrentConnectionContext = undefined
-
-  /**
-   * Runs current.
-   * @returns {VelociousDatabasePoolBase} - The current.
-   */
-  static current() {
-    if (!shared.currentPool) throw new Error("A database pool hasn't been set")
-
-    return shared.currentPool
-  }
-
-  /**
-   * Clears any global connections for the given configuration.
-   * @returns {void} - No return value.
-   */
-  static clearGlobalConnections() {}
-
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {Configuration} args.configuration - Configuration instance.
-   * @param {string} args.identifier - Identifier.
-   */
-  constructor({configuration, identifier}) {
-    this.configuration = configuration || Configuration.current()
-
-    if (!this.configuration) throw new Error("No configuration given")
-    if (!identifier) throw new Error("No identifier was given")
-
-    this.identifier = identifier
-    this.logger = new Logger(this)
-  }
-
-  /**
-   * Runs checkin.
-   * @abstract
-   * @param {import("../drivers/base.js").default} _connection - Connection.
-   */
-  checkin(_connection) {
-    throw new Error("'checkin' not implemented")
-  }
-
-  /**
-   * Runs checkout.
-   * @abstract
-   * @param {ConnectionCheckoutOptions} [_options] - Checkout options.
-   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
-   */
-  checkout(_options) {
-    throw new Error("'checkout' not implemented")
-  }
-
-  /**
-   * Runs get current connection.
-   * @abstract
-   * @returns {import("../drivers/base.js").default} - The current connection.
-   */
-  getCurrentConnection() {
-    throw new Error("'getCurrentConnection' not implemented")
-  }
-
-  /**
-   * Returns the connection pinned to the current context, if any.
-   * Default implementation defers to `getCurrentConnection`.
-   * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
-   */
-  getCurrentContextConnection() {
-    return this.getCurrentConnection()
-  }
-
-  /**
-   * Runs without current connection context.
-   * @template T
-   * @param {() => T} callback - Callback to run without ? current connection context.
-   * @returns {T} - Callback result.
-   */
-  withoutCurrentConnectionContext(callback) {
-    if (this._withoutCurrentConnectionContext) return /** Narrows the runtime value to the documented type. @type {T} */ (this._withoutCurrentConnectionContext(callback))
-
-    return callback()
-  }
-
-  /**
-   * Runs get configuration.
-   * @returns {import("../../configuration-types.js").DatabaseConfigurationType} - Resolved database configuration for the pool identifier.
-   */
-  getConfiguration() {
-    return this.configuration.resolveDatabaseConfiguration(this.identifier)
-  }
-
-  /**
-   * Runs get configuration reuse key.
-   * @returns {string} - Reuse key for the currently resolved database configuration.
-   */
-  getConfigurationReuseKey() {
-    const databaseConfiguration = this.getConfiguration()
-
-    return stableStringify({
-      database: databaseConfiguration.database,
-      host: databaseConfiguration.host,
-      name: databaseConfiguration.name,
-      port: databaseConfiguration.port,
-      schema: databaseConfiguration.schema,
-      schemaCache: databaseConfiguration.schemaCache,
-      sqlConfig: databaseConfiguration.sqlConfig,
-      type: databaseConfiguration.type,
-      useDatabase: databaseConfiguration.useDatabase,
-      username: databaseConfiguration.username
-    })
-  }
-
-  /**
-   * Runs connection matches current configuration.
-   * @param {import("../drivers/base.js").default} connection - Connection.
-   * @returns {boolean} - Whether connection matches current resolved configuration.
-   */
-  connectionMatchesCurrentConfiguration(connection) {
-    const connectionWithPoolKey = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
-
-    return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === this.getConfigurationReuseKey()
-  }
-
-  /**
-   * Clears schema metadata cached by this pool's current connection.
-   * Pools that keep multiple connections alive should override this to clear every live connection.
-   * @returns {void} - No return value.
-   */
-  clearSchemaCache() {
-    this._clearConnectionSchemaCache(this.getCurrentConnection())
-  }
-
-  /**
-   * Runs clear connection schema cache.
-   * @param {import("../drivers/base.js").default} connection - Connection whose local schema cache should be cleared.
-   * @returns {void} - No return value.
-   */
-  _clearConnectionSchemaCache(connection) {
-    connection._clearLocalSchemaCache()
-  }
-
-  /**
-   * Runs primary key type.
-   * @abstract
-   * @returns {string} - The primary key type.
-   */
-  primaryKeyType() {
-    throw new Error("'primaryKeyType' not implemented")
-  }
-
-  /**
-   * Runs set current.
-   * @returns {void} - No return value.
-   */
-  setCurrent() {
-    shared.currentPool = this
-  }
-
-  /**
-   * Runs set driver class.
-   * @param {typeof import("../drivers/base.js").default} driverClass - Driver class.
-   */
-  setDriverClass(driverClass) {
-    this.driverClass = driverClass
-  }
-
-  /**
-   * Runs spawn connection.
-   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection.
-   */
-  async spawnConnection() {
-    const databaseConfig = this.getConfiguration()
-
-    this.logger.debug("spawnConnection", {identifier: this.identifier, databaseConfig})
-
-    const connection = await this.spawnConnectionWithConfiguration(databaseConfig)
-
-    const connectionWithPoolKey = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
-    connectionWithPoolKey[POOL_CONFIGURATION_KEY] = this.getConfigurationReuseKey()
-    connection.setSchemaCacheInvalidator(() => {
-      this.clearSchemaCache()
-      this.configuration.clearSchemaCachesForReuseKey(this.getConfigurationReuseKey())
-    })
-
-    return connection
-  }
-
-  /**
-   * Runs spawn connection with configuration.
-   * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Configuration object.
-   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection with configuration.
-   */
-  async spawnConnectionWithConfiguration(config) {
-    const DriverClass = config.driver || this.driverClass
-
-    if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
-
-    const connection = new DriverClass(config, this.configuration)
-
-    try {
-      await connection.connect()
-    } catch (error) {
-      await this.closeConnectionAfterFailedConnect(connection)
-      throw error
+    /**
+     * Without current connection context.
+      @type {undefined | ((callback: () => ?) => ?)} */
+    _withoutCurrentConnectionContext = undefined;
+    /**
+     * Runs current.
+     * @returns {VelociousDatabasePoolBase} - The current.
+     */
+    static current() {
+        if (!shared.currentPool)
+            throw new Error("A database pool hasn't been set");
+        return shared.currentPool;
+    }
+    /**
+     * Clears any global connections for the given configuration.
+     * @returns {void} - No return value.
+     */
+    static clearGlobalConnections() { }
+    /**
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {Configuration} args.configuration - Configuration instance.
+     * @param {string} args.identifier - Identifier.
+     */
+    constructor({ configuration, identifier }) {
+        this.configuration = configuration || Configuration.current();
+        if (!this.configuration)
+            throw new Error("No configuration given");
+        if (!identifier)
+            throw new Error("No identifier was given");
+        this.identifier = identifier;
+        this.logger = new Logger(this);
+    }
+    /**
+     * Runs checkin.
+     * @abstract
+     * @param {import("../drivers/base.js").default} _connection - Connection.
+     */
+    checkin(_connection) {
+        throw new Error("'checkin' not implemented");
+    }
+    /**
+     * Runs checkout.
+     * @abstract
+     * @param {ConnectionCheckoutOptions} [_options] - Checkout options.
+     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
+     */
+    checkout(_options) {
+        throw new Error("'checkout' not implemented");
+    }
+    /**
+     * Runs get current connection.
+     * @abstract
+     * @returns {import("../drivers/base.js").default} - The current connection.
+     */
+    getCurrentConnection() {
+        throw new Error("'getCurrentConnection' not implemented");
+    }
+    /**
+     * Returns the connection pinned to the current context, if any.
+     * Default implementation defers to `getCurrentConnection`.
+     * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
+     */
+    getCurrentContextConnection() {
+        return this.getCurrentConnection();
+    }
+    /**
+     * Runs without current connection context.
+     * @template T
+     * @param {() => T} callback - Callback to run without ? current connection context.
+     * @returns {T} - Callback result.
+     */
+    withoutCurrentConnectionContext(callback) {
+        if (this._withoutCurrentConnectionContext)
+            return /** Narrows the runtime value to the documented type. @type {T} */ (this._withoutCurrentConnectionContext(callback));
+        return callback();
+    }
+    /**
+     * Runs get configuration.
+     * @returns {import("../../configuration-types.js").DatabaseConfigurationType} - Resolved database configuration for the pool identifier.
+     */
+    getConfiguration() {
+        return this.configuration.resolveDatabaseConfiguration(this.identifier);
+    }
+    /**
+     * Runs get configuration reuse key.
+     * @returns {string} - Reuse key for the currently resolved database configuration.
+     */
+    getConfigurationReuseKey() {
+        const databaseConfiguration = this.getConfiguration();
+        return stableStringify({
+            database: databaseConfiguration.database,
+            host: databaseConfiguration.host,
+            name: databaseConfiguration.name,
+            port: databaseConfiguration.port,
+            schema: databaseConfiguration.schema,
+            schemaCache: databaseConfiguration.schemaCache,
+            sqlConfig: databaseConfiguration.sqlConfig,
+            type: databaseConfiguration.type,
+            useDatabase: databaseConfiguration.useDatabase,
+            username: databaseConfiguration.username
+        });
+    }
+    /**
+     * Runs connection matches current configuration.
+     * @param {import("../drivers/base.js").default} connection - Connection.
+     * @returns {boolean} - Whether connection matches current resolved configuration.
+     */
+    connectionMatchesCurrentConfiguration(connection) {
+        const connectionWithPoolKey = /**
+                                       * Narrows the runtime value to the documented type.
+                                        @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
+        return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === this.getConfigurationReuseKey();
+    }
+    /**
+     * Clears schema metadata cached by this pool's current connection.
+     * Pools that keep multiple connections alive should override this to clear every live connection.
+     * @returns {void} - No return value.
+     */
+    clearSchemaCache() {
+        this._clearConnectionSchemaCache(this.getCurrentConnection());
+    }
+    /**
+     * Runs clear connection schema cache.
+     * @param {import("../drivers/base.js").default} connection - Connection whose local schema cache should be cleared.
+     * @returns {void} - No return value.
+     */
+    _clearConnectionSchemaCache(connection) {
+        connection._clearLocalSchemaCache();
+    }
+    /**
+     * Runs primary key type.
+     * @abstract
+     * @returns {string} - The primary key type.
+     */
+    primaryKeyType() {
+        throw new Error("'primaryKeyType' not implemented");
+    }
+    /**
+     * Runs set current.
+     * @returns {void} - No return value.
+     */
+    setCurrent() {
+        shared.currentPool = this;
+    }
+    /**
+     * Runs set driver class.
+     * @param {typeof import("../drivers/base.js").default} driverClass - Driver class.
+     */
+    setDriverClass(driverClass) {
+        this.driverClass = driverClass;
+    }
+    /**
+     * Runs spawn connection.
+     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection.
+     */
+    async spawnConnection() {
+        const databaseConfig = this.getConfiguration();
+        this.logger.debug("spawnConnection", { identifier: this.identifier, databaseConfig });
+        const connection = await this.spawnConnectionWithConfiguration(databaseConfig);
+        const connectionWithPoolKey = /**
+                                       * Narrows the runtime value to the documented type.
+                                        @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
+        connectionWithPoolKey[POOL_CONFIGURATION_KEY] = this.getConfigurationReuseKey();
+        connection.setSchemaCacheInvalidator(() => {
+            this.clearSchemaCache();
+            this.configuration.clearSchemaCachesForReuseKey(this.getConfigurationReuseKey());
+        });
+        return connection;
+    }
+    /**
+     * Runs spawn connection with configuration.
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Configuration object.
+     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the spawn connection with configuration.
+     */
+    async spawnConnectionWithConfiguration(config) {
+        const DriverClass = config.driver || this.driverClass;
+        if (!DriverClass)
+            throw new Error("No driver class set in database pool or in given config");
+        const connection = new DriverClass(config, this.configuration);
+        try {
+            await connection.connect();
+        }
+        catch (error) {
+            await this.closeConnectionAfterFailedConnect(connection);
+            throw error;
+        }
+        return connection;
+    }
+    /**
+     * Runs close connection after failed connect.
+     * @param {import("../drivers/base.js").default} connection - Connection to close.
+     * @returns {Promise<void>} - Resolves when cleanup has been attempted.
+     */
+    async closeConnectionAfterFailedConnect(connection) {
+        try {
+            await connection.close();
+        }
+        catch (error) {
+            this.logger.warn("Failed to close database connection after connect failed", { error });
+        }
+    }
+    /**
+     * 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.
+     * @returns {Promise<T>} - Resolves with the callback result.
+     */
+    withConnection(_optionsOrCallback, _callback) {
+        throw new Error("'withConnection' not implemented");
     }
-
-    return connection
-  }
-
-  /**
-   * Runs close connection after failed connect.
-   * @param {import("../drivers/base.js").default} connection - Connection to close.
-   * @returns {Promise<void>} - Resolves when cleanup has been attempted.
-   */
-  async closeConnectionAfterFailedConnect(connection) {
-    try {
-      await connection.close()
-    } catch (error) {
-      this.logger.warn("Failed to close database connection after connect failed", {error})
+    /**
+     * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.
+     * Default implementation just checks out a connection.
+     * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the global connection.
+     */
+    async ensureGlobalConnection() {
+        return await this.checkout();
     }
-  }
-
-  /**
-   * 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.
-   * @returns {Promise<T>} - Resolves with the callback result.
-   */
-  withConnection(_optionsOrCallback, _callback) {
-    throw new Error("'withConnection' not implemented")
-  }
-
-  /**
-   * Ensures a reusable connection exists for contexts where AsyncLocalStorage isn't set.
-   * Default implementation just checks out a connection.
-   * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the global connection.
-   */
-  async ensureGlobalConnection() {
-    return await this.checkout()
-  }
-
-  /**
-   * Runs get debug snapshot.
-   * @returns {DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.
-   */
-  getDebugSnapshot() {
-    return {
-      configuration: this.debugConfigurationSnapshot(),
-      connections: [],
-      connectionsBeingSpawned: 0,
-      identifier: this.identifier,
-      idleCount: 0,
-      inUseCount: 0,
-      pendingCheckoutCount: 0,
-      poolClass: this.constructor.name
+    /**
+     * Runs get debug snapshot.
+     * @returns {DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.
+     */
+    getDebugSnapshot() {
+        return {
+            configuration: this.debugConfigurationSnapshot(),
+            connections: [],
+            connectionsBeingSpawned: 0,
+            identifier: this.identifier,
+            idleCount: 0,
+            inUseCount: 0,
+            pendingCheckoutCount: 0,
+            poolClass: this.constructor.name
+        };
     }
-  }
-
-  /**
-   * Runs debug configuration snapshot.
-   * @returns {Record<string, ?>} - Sanitized resolved database configuration.
-   */
-  debugConfigurationSnapshot() {
-    const databaseConfig = this.getConfiguration()
-    const poolConfig = databaseConfig.pool
-
-    return {
-      database: databaseConfig.database,
-      driver: databaseConfig.driver?.name,
-      host: databaseConfig.host,
-      migrations: databaseConfig.migrations,
-      name: databaseConfig.name,
-      pool: poolConfig ? {idleTimeoutMillis: poolConfig.idleTimeoutMillis, max: poolConfig.max} : undefined,
-      port: databaseConfig.port,
-      schema: databaseConfig.schema,
-      type: databaseConfig.type,
-      useDatabase: databaseConfig.useDatabase,
-      username: databaseConfig.username
+    /**
+     * Runs debug configuration snapshot.
+     * @returns {Record<string, ?>} - Sanitized resolved database configuration.
+     */
+    debugConfigurationSnapshot() {
+        const databaseConfig = this.getConfiguration();
+        const poolConfig = databaseConfig.pool;
+        return {
+            database: databaseConfig.database,
+            driver: databaseConfig.driver?.name,
+            host: databaseConfig.host,
+            migrations: databaseConfig.migrations,
+            name: databaseConfig.name,
+            pool: poolConfig ? { idleTimeoutMillis: poolConfig.idleTimeoutMillis, max: poolConfig.max } : undefined,
+            port: databaseConfig.port,
+            schema: databaseConfig.schema,
+            type: databaseConfig.type,
+            useDatabase: databaseConfig.useDatabase,
+            username: databaseConfig.username
+        };
     }
-  }
-
-  /**
-   * 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.
-   */
-  debugConnectionSnapshot(connection, details = {}) {
-    const connectionWithPoolKey = /**
-                                   * Narrows the runtime value to the documented type.
-                                    @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
-
-    return {
-      ...connection.getDebugSnapshot(),
-      ...details,
-      reuseKey: connectionWithPoolKey[POOL_CONFIGURATION_KEY]
+    /**
+     * 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.
+     */
+    debugConnectionSnapshot(connection, details = {}) {
+        const connectionWithPoolKey = /**
+                                       * Narrows the runtime value to the documented type.
+                                        @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection);
+        return {
+            ...connection.getDebugSnapshot(),
+            ...details,
+            reuseKey: connectionWithPoolKey[POOL_CONFIGURATION_KEY]
+        };
     }
-  }
-
-  /**
-   * Closes all connections for this pool.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async closeAll() {}
+    /**
+     * Closes all connections for this pool.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async closeAll() { }
 }
-
-baseMethodsForward(VelociousDatabasePoolBase)
-
-export default 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":"AAAA,YAAY;AAEZ,OAAO,aAAa,MAAM,wBAAwB,CAAA;AAClD,OAAO,MAAM,MAAM,iBAAiB,CAAA;AACpC,OAAO,kBAAkB,MAAM,2BAA2B,CAAA;AAE1D,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAA;AAE7E;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;4DAE4D;AAC5D,MAAM,MAAM,GAAG;IACb,WAAW,EAAE,IAAI;CAClB,CAAA;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,KAAK;IAC5B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;IACtE,CAAC;IAED,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,MAAM;aACnB,IAAI,CAAC;;4CAE8B,CAAC,CAAC,KAAK,CAAC,CAAC;aAC5C,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC;;8FAE8B,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAA;QAEzG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;IACjC,CAAC;IAED,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;AAC9B,CAAC;AAED,MAAM,yBAAyB;IAC7B;;uDAEmD;IACnD,gCAAgC,GAAG,SAAS,CAAA;IAE5C;;;OAGG;IACH,MAAM,CAAC,OAAO;QACZ,IAAI,CAAC,MAAM,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;QAE3E,OAAO,MAAM,CAAC,WAAW,CAAA;IAC3B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,sBAAsB,KAAI,CAAC;IAElC;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,UAAU,EAAC;QACrC,IAAI,CAAC,aAAa,GAAG,aAAa,IAAI,aAAa,CAAC,OAAO,EAAE,CAAA;QAE7D,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;QAClE,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;QAE3D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,WAAW;QACjB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC9C,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ;QACf,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAA;IAC/C,CAAC;IAED;;;;OAIG;IACH,oBAAoB;QAClB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;IAC3D,CAAC;IAED;;;;OAIG;IACH,2BAA2B;QACzB,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAA;IACpC,CAAC;IAED;;;;;OAKG;IACH,+BAA+B,CAAC,QAAQ;QACtC,IAAI,IAAI,CAAC,gCAAgC;YAAE,OAAO,kEAAkE,CAAC,CAAC,IAAI,CAAC,gCAAgC,CAAC,QAAQ,CAAC,CAAC,CAAA;QAEtK,OAAO,QAAQ,EAAE,CAAA;IACnB,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;IACzE,CAAC;IAED;;;OAGG;IACH,wBAAwB;QACtB,MAAM,qBAAqB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAErD,OAAO,eAAe,CAAC;YACrB,QAAQ,EAAE,qBAAqB,CAAC,QAAQ;YACxC,IAAI,EAAE,qBAAqB,CAAC,IAAI;YAChC,IAAI,EAAE,qBAAqB,CAAC,IAAI;YAChC,IAAI,EAAE,qBAAqB,CAAC,IAAI;YAChC,MAAM,EAAE,qBAAqB,CAAC,MAAM;YACpC,WAAW,EAAE,qBAAqB,CAAC,WAAW;YAC9C,SAAS,EAAE,qBAAqB,CAAC,SAAS;YAC1C,IAAI,EAAE,qBAAqB,CAAC,IAAI;YAChC,WAAW,EAAE,qBAAqB,CAAC,WAAW;YAC9C,QAAQ,EAAE,qBAAqB,CAAC,QAAQ;SACzC,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,qCAAqC,CAAC,UAAU;QAC9C,MAAM,qBAAqB,GAAG;;6HAEuF,CAAC,CAAC,UAAU,CAAC,CAAA;QAElI,OAAO,qBAAqB,CAAC,sBAAsB,CAAC,KAAK,IAAI,CAAC,wBAAwB,EAAE,CAAA;IAC1F,CAAC;IAED;;;;OAIG;IACH,gBAAgB;QACd,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAA;IAC/D,CAAC;IAED;;;;OAIG;IACH,2BAA2B,CAAC,UAAU;QACpC,UAAU,CAAC,sBAAsB,EAAE,CAAA;IACrC,CAAC;IAED;;;;OAIG;IACH,cAAc;QACZ,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;IACrD,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,MAAM,CAAC,WAAW,GAAG,IAAI,CAAA;IAC3B,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,WAAW;QACxB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;IAChC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe;QACnB,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAE9C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE,EAAC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,cAAc,EAAC,CAAC,CAAA;QAEnF,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,gCAAgC,CAAC,cAAc,CAAC,CAAA;QAE9E,MAAM,qBAAqB,GAAG;;6HAEuF,CAAC,CAAC,UAAU,CAAC,CAAA;QAClI,qBAAqB,CAAC,sBAAsB,CAAC,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAA;QAC/E,UAAU,CAAC,yBAAyB,CAAC,GAAG,EAAE;YACxC,IAAI,CAAC,gBAAgB,EAAE,CAAA;YACvB,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,CAAA;QAClF,CAAC,CAAC,CAAA;QAEF,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,gCAAgC,CAAC,MAAM;QAC3C,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,CAAA;QAErD,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;QAE5F,MAAM,UAAU,GAAG,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QAE9D,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAA;QAC5B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,iCAAiC,CAAC,UAAU,CAAC,CAAA;YACxD,MAAM,KAAK,CAAA;QACb,CAAC;QAED,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iCAAiC,CAAC,UAAU;QAChD,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,KAAK,EAAE,CAAA;QAC1B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0DAA0D,EAAE,EAAC,KAAK,EAAC,CAAC,CAAA;QACvF,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,kBAAkB,EAAE,SAAS;QAC1C,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;IACrD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,sBAAsB;QAC1B,OAAO,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;IAC9B,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACd,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,0BAA0B,EAAE;YAChD,WAAW,EAAE,EAAE;YACf,uBAAuB,EAAE,CAAC;YAC1B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,CAAC;YACZ,UAAU,EAAE,CAAC;YACb,oBAAoB,EAAE,CAAC;YACvB,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;SACjC,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,0BAA0B;QACxB,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAC9C,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CAAA;QAEtC,OAAO;YACL,QAAQ,EAAE,cAAc,CAAC,QAAQ;YACjC,MAAM,EAAE,cAAc,CAAC,MAAM,EAAE,IAAI;YACnC,IAAI,EAAE,cAAc,CAAC,IAAI;YACzB,UAAU,EAAE,cAAc,CAAC,UAAU;YACrC,IAAI,EAAE,cAAc,CAAC,IAAI;YACzB,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAC,iBAAiB,EAAE,UAAU,CAAC,iBAAiB,EAAE,GAAG,EAAE,UAAU,CAAC,GAAG,EAAC,CAAC,CAAC,CAAC,SAAS;YACrG,IAAI,EAAE,cAAc,CAAC,IAAI;YACzB,MAAM,EAAE,cAAc,CAAC,MAAM;YAC7B,IAAI,EAAE,cAAc,CAAC,IAAI;YACzB,WAAW,EAAE,cAAc,CAAC,WAAW;YACvC,QAAQ,EAAE,cAAc,CAAC,QAAQ;SAClC,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,uBAAuB,CAAC,UAAU,EAAE,OAAO,GAAG,EAAE;QAC9C,MAAM,qBAAqB,GAAG;;6HAEuF,CAAC,CAAC,UAAU,CAAC,CAAA;QAElI,OAAO;YACL,GAAG,UAAU,CAAC,gBAAgB,EAAE;YAChC,GAAG,OAAO;YACV,QAAQ,EAAE,qBAAqB,CAAC,sBAAsB,CAAC;SACxD,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,QAAQ,KAAI,CAAC;CACpB;AAED,kBAAkB,CAAC,yBAAyB,CAAC,CAAA;AAE7C,eAAe,yBAAyB,CAAA","sourcesContent":["// @ts-check\n\nimport Configuration from \"../../configuration.js\"\nimport Logger from \"../../logger.js\"\nimport baseMethodsForward from \"./base-methods-forward.js\"\n\nexport const POOL_CONFIGURATION_KEY = Symbol(\"velociousPoolConfigurationKey\")\n\n/**\n * ConnectionCheckoutOptions type.\n * @typedef {object} ConnectionCheckoutOptions\n * @property {string} [name] - Human-readable name for the checked-out connection.\n */\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<Record<string, ?>>} [pendingCheckouts] - Waiting checkout snapshots.\n * @property {number} pendingCheckoutCount - Number of queued checkout requests.\n * @property {string} poolClass - Pool class name.\n */\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(/**\n             * Narrows the runtime value to the documented type.\n              @type {Record<string, ?>} */ (value))\n      .sort()\n      .map((key) => `${JSON.stringify(key)}:${stableStringify(/**\n                                                               * Narrows the runtime value to the documented type.\n                                                                @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   * @returns {void} - No return value.\n   */\n  static clearGlobalConnections() {}\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   * 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 /** Narrows the runtime value to the documented type. @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    const connectionWithPoolKey = /**\n                                   * Narrows the runtime value to the documented type.\n                                    @type {import(\"../drivers/base.js\").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)\n\n    return connectionWithPoolKey[POOL_CONFIGURATION_KEY] === this.getConfigurationReuseKey()\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 = /**\n                                   * Narrows the runtime value to the documented type.\n                                    @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   * 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 = /**\n                                   * Narrows the runtime value to the documented type.\n                                    @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"]}