velocious 1.0.430 → 1.0.431

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

@@ -1,13 +1,17 @@
 // @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
@@ -21,315 +25,356 @@ 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;
-        }
-        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");
+  /**
+   * 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
     }
-    /**
-     * 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();
+
+    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 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 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 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;
-//# 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\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"]}
+
+baseMethodsForward(VelociousDatabasePoolBase)
+
+export default VelociousDatabasePoolBase