@juit/pgproxy-pool 1.0.0

package/dist/pool.cjs

@@ -0,0 +1,486 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// pool.ts
+var pool_exports = {};
+__export(pool_exports, {
+  ConnectionPool: () => ConnectionPool
+});
+module.exports = __toCommonJS(pool_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_connection = require("./connection.cjs");
+var import_events = require("./events.cjs");
+function parseEnvNumber(variable, defaultValue) {
+  const string = process.env[variable];
+  if (string == null)
+    return defaultValue;
+  const value = parseFloat(string);
+  if (isNaN(value))
+    throw new Error(`Invalid value "${string}" for environment variable "${variable}"`);
+  return value;
+}
+function parseEnvBoolean(variable, defaultValue) {
+  const string = process.env[variable];
+  if (string == null)
+    return defaultValue;
+  const value = string.toLowerCase();
+  if (value === "false")
+    return false;
+  if (value === "true")
+    return true;
+  throw new Error(`Invalid value "${string}" for environment variable "${variable}"`);
+}
+var ConnectionRequest = class {
+  _resolve;
+  _reject;
+  _promise;
+  _timeout;
+  _pending = true;
+  /**
+   * Create a new {@link ConnectionRequest} with a timeout, after which the
+   * request will be automatically rejected.
+   */
+  constructor(timeout) {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+    this._timeout = setTimeout(() => {
+      this.reject(new Error(`Timeout of ${timeout} ms reached acquiring connection`));
+    }, timeout).unref();
+  }
+  /** Return the {@link Promise} to the {@link Connection} */
+  get promise() {
+    return this._promise;
+  }
+  /** Determine whether this request is still pending or not */
+  get pending() {
+    return this._pending;
+  }
+  /** Resolve this instance's {@link Promise} with a {@link Connection} */
+  resolve(connection) {
+    clearTimeout(this._timeout);
+    if (this._pending)
+      this._resolve(connection);
+    this._pending = false;
+  }
+  /** Reject this instance's {@link Promise} with an {@link Error} */
+  reject(error) {
+    clearTimeout(this._timeout);
+    if (this._pending)
+      this._reject(error);
+    this._pending = false;
+  }
+};
+var ConnectionPool = class extends import_events.Emitter {
+  /** Borrowed connections mapped to their borrow timeout */
+  _borrowed = /* @__PURE__ */ new Map();
+  /** Array of all _available_ connections (that is, not borrowed out) */
+  _available = [];
+  /** Array of all pending {@link ConnectionRequest}s */
+  _pending = [];
+  /** All connections mapped to their evictor callback handler */
+  _connections = /* @__PURE__ */ new Map();
+  /** A {@link WeakMap} of connections already evicted by this pool */
+  _evicted = /* @__PURE__ */ new WeakSet();
+  /** The minimum number of connections to keep in the pool */
+  _minimumPoolSize;
+  /** The maximum number of connections to keep in the pool */
+  _maximumPoolSize;
+  /** The maximum number of idle connections that can be sitting in the pool */
+  _maximumIdleConnections;
+  /** The number of *milliseconds* after which an `acquire()` call will fail */
+  _acquireTimeoutMs;
+  /** The maximum number of *milliseconds* a connection can be borrowed for */
+  _borrowTimeoutMs;
+  /** The number of *milliseconds* to wait after the creation of a connection failed */
+  _retryIntervalMs;
+  /** Whether to validate connections on borrow or not */
+  _validateOnBorrow;
+  /** The {@link ConnectionOptions} converted into a string for `LibPQ` */
+  _connectionOptions;
+  /** Indicator on whether this {@link ConnectionPool} was started or not */
+  _started = false;
+  /** Indicator on whether this {@link ConnectionPool} is starting or not */
+  _starting = false;
+  constructor(logger, options = {}) {
+    super(logger);
+    const {
+      minimumPoolSize = parseEnvNumber("PGPOOLMINSIZE", 0),
+      maximumPoolSize = parseEnvNumber("PGPOOLMAXSIZE", minimumPoolSize + 20),
+      maximumIdleConnections = parseEnvNumber("PGPOOLIDLECONN", (maximumPoolSize + minimumPoolSize) / 2),
+      acquireTimeout = parseEnvNumber("PGPOOLACQUIRETIMEOUT", 30),
+      borrowTimeout = parseEnvNumber("PGPOOLBORROWTIMEOUT", 120),
+      retryInterval = parseEnvNumber("PGPOOLRETRYINTERVAL", 5),
+      validateOnBorrow = parseEnvBoolean("PGPOOLVALIDATEONBORROW", true),
+      ...connectionOptions
+    } = options;
+    this._minimumPoolSize = Math.round(minimumPoolSize);
+    this._maximumPoolSize = Math.round(maximumPoolSize);
+    this._maximumIdleConnections = Math.ceil(maximumIdleConnections);
+    this._acquireTimeoutMs = Math.round(acquireTimeout * 1e3);
+    this._borrowTimeoutMs = Math.round(borrowTimeout * 1e3);
+    this._retryIntervalMs = Math.round(retryInterval * 1e3);
+    this._validateOnBorrow = validateOnBorrow;
+    (0, import_node_assert.default)(this._minimumPoolSize >= 0, `Invalid minimum pool size: ${this._minimumPoolSize}`);
+    (0, import_node_assert.default)(this._maximumPoolSize >= 1, `Invalid maximum pool size: ${this._maximumPoolSize}`);
+    (0, import_node_assert.default)(this._maximumIdleConnections >= 0, `Invalid maximum idle connections: ${this._maximumIdleConnections}`);
+    (0, import_node_assert.default)(this._acquireTimeoutMs > 0, `Invalid acquire timeout: ${this._acquireTimeoutMs} ms`);
+    (0, import_node_assert.default)(this._borrowTimeoutMs > 0, `Invalid borrow timeout: ${this._borrowTimeoutMs} ms`);
+    (0, import_node_assert.default)(this._retryIntervalMs > 0, `Invalid retry interval: ${this._retryIntervalMs} ms`);
+    (0, import_node_assert.default)(
+      this._minimumPoolSize <= this._maximumPoolSize,
+      `The minimum pool size ${this._minimumPoolSize} must less or equal to the maximum pool size ${this._maximumPoolSize}`
+    );
+    (0, import_node_assert.default)(
+      this._minimumPoolSize <= this._maximumIdleConnections,
+      `The minimum pool size ${this._minimumPoolSize} must less or equal to the maximum number of idle connections ${this._maximumIdleConnections}`
+    );
+    (0, import_node_assert.default)(
+      this._maximumIdleConnections <= this._maximumPoolSize,
+      `The maximum number of idle connections ${this._maximumIdleConnections} must less or equal to the maximum pool size ${this._maximumPoolSize}`
+    );
+    this._connectionOptions = (0, import_connection.convertOptions)(connectionOptions);
+    this._logger = logger;
+  }
+  /** Statistical informations about a {@link ConnectionPool} */
+  get stats() {
+    const available = this._available.length;
+    const borrowed = this._borrowed.size;
+    const total = this._connections.size;
+    const connecting = total - (available + borrowed);
+    return { available, borrowed, connecting, total };
+  }
+  /** Returns a flag indicating whether this pool is running or not */
+  get running() {
+    return this._started || this._starting;
+  }
+  /** Returns the running configuration of this instance */
+  get configuration() {
+    return {
+      minimumPoolSize: this._minimumPoolSize,
+      maximumPoolSize: this._maximumPoolSize,
+      maximumIdleConnections: this._maximumIdleConnections,
+      acquireTimeout: this._acquireTimeoutMs / 1e3,
+      borrowTimeout: this._borrowTimeoutMs / 1e3,
+      retryInterval: this._retryIntervalMs / 1e3,
+      validateOnBorrow: this._validateOnBorrow
+    };
+  }
+  /* ===== CONNECTION MANAGEMENT ============================================ */
+  /* These methods are protected, as they can be overridden to provide more
+   * specialized versions of connections */
+  /** Create a connection */
+  _create(logger, params) {
+    return new import_connection.Connection(logger, params);
+  }
+  /** Validate a connection by issuing a super-simple statement */
+  async _validate(connection) {
+    if (!connection.connected)
+      return false;
+    if (!this._validateOnBorrow)
+      return true;
+    const start = process.hrtime.bigint();
+    try {
+      this._logger.debug(`Validating connection "${connection.id}"`);
+      const result = await connection.query("SELECT now()");
+      return result.rowCount === 1;
+    } catch (error) {
+      this._logger.error(`Error validating connection "${connection.id}":`, error);
+      return false;
+    } finally {
+      const time = process.hrtime.bigint() - start;
+      const ms = Math.floor(Number(time) / 1e4) / 100;
+      this._logger.debug(`Connection "${connection.id}" validated in ${ms} ms`);
+    }
+  }
+  /** Recycle a connection rolling back any running transaction */
+  async _recycle(connection) {
+    if (!connection.connected)
+      return false;
+    try {
+      const result = await connection.query("SELECT pg_current_xact_id_if_assigned() IS NOT NULL");
+      if (result.rows[0]?.[0] === "t") {
+        this._logger.warn(`Rolling back transaction recycling connection "${connection.id}"`);
+        await connection.query("ROLLBACK");
+      }
+      return true;
+    } catch (error) {
+      this._logger.error(`Error recycling connection "${connection.id}":`, error);
+      return false;
+    }
+  }
+  /* ===== CONNECTION / POOL INTERACTION ==================================== */
+  /** Adopt a connection tying it to our events */
+  _adopt(connection) {
+    const destroyer = () => {
+      connection.off("destroyed", evictor);
+      this._evict(connection);
+    };
+    this.once("stopped", destroyer);
+    const evictor = (forced) => {
+      this.off("stopped", destroyer);
+      if (forced)
+        return;
+      this._evict(connection);
+      this._runCreateLoop();
+    };
+    connection.once("destroyed", evictor);
+    this._connections.set(connection, evictor);
+    return connection;
+  }
+  /** Destroy a connection, it will be wiped from this pool */
+  _evict(connection, aborted = false) {
+    const evictor = this._connections.get(connection);
+    if (!evictor) {
+      this._logger.warn(`Attempting to evict non adopted connection ${connection.id}`);
+      return;
+    }
+    this._connections.delete(connection);
+    connection.off("destroyed", evictor);
+    evictor(true);
+    try {
+      this._logger.debug(`Destroying connection "${connection.id}"`);
+      clearTimeout(this._borrowed.get(connection));
+      this._borrowed.delete(connection);
+      const index = this._available.indexOf(connection);
+      if (index >= 0)
+        this._available.splice(index);
+      connection.destroy();
+      this._emit(aborted ? "connection_aborted" : "connection_destroyed", connection);
+    } catch (error) {
+      this._logger.error(`Error destroying connection "${connection.id}"`);
+    } finally {
+      this._evicted.add(connection);
+    }
+  }
+  /* ===== RUN LOOPS ======================================================== */
+  /**
+   * Run the create connection loop.
+   *
+   * This loop simply creates connections, connects them, sets up the various
+   * event handler (on disconnect) and simply adds them to the available array.
+   */
+  _runCreateLoop() {
+    if (!this._started)
+      return;
+    Promise.resolve().then(async () => {
+      while (this._started) {
+        const connections = this._connections.size;
+        const available = this._available.length;
+        const pending = this._pending.length;
+        if (available && connections >= this._minimumPoolSize || // enough available for minimum pool size
+        !pending && available >= this._maximumIdleConnections || // enough maximum idle connections
+        connections >= this._maximumPoolSize) {
+          break;
+        }
+        let connection;
+        try {
+          connection = this._create(this._logger, this._connectionOptions);
+          this._adopt(connection);
+        } catch (error) {
+          const retry = `retrying in ${this._retryIntervalMs} ms`;
+          this._logger.error(`Error creating pooled connection, ${retry}:`, error);
+          await new Promise((resolve) => setTimeout(resolve, this._retryIntervalMs));
+          continue;
+        }
+        try {
+          await connection.connect();
+        } catch (error) {
+          const retry = `retrying in ${this._retryIntervalMs} ms`;
+          this._logger.error(`Error connecting "${connection.id}", ${retry}:`, error);
+          this._evict(connection, true);
+          await new Promise((resolve) => setTimeout(resolve, this._retryIntervalMs));
+          continue;
+        }
+        if (this._started)
+          this._available.push(connection);
+        else
+          this._evict(connection, true);
+        this._runBorrowLoop();
+        this._emit("connection_created", connection);
+      }
+    }).catch(
+      /* coverage ignore next */
+      (error) => {
+        const retry = `retrying in ${this._retryIntervalMs} ms`;
+        this._logger.error(`Error in create loop, ${retry}:`, error);
+        setTimeout(() => this._runCreateLoop(), this._retryIntervalMs);
+      }
+    );
+  }
+  /**
+   * Run the borrow connection loop.
+   *
+   * This loop looks at all the pending connection requests, and fullfills them
+   * with a connection from the available array. If no connections are available
+   * then it simply triggers the create loop.
+   */
+  _runBorrowLoop() {
+    if (!this._started)
+      return;
+    Promise.resolve().then(async () => {
+      let request;
+      while (this._started && (request = this._pending.splice(0, 1)[0])) {
+        const connection = this._available.splice(0, 1)[0];
+        if (!connection) {
+          if (request.pending)
+            this._pending.unshift(request);
+          return this._runCreateLoop();
+        }
+        if (!request.pending) {
+          if (this._available.length >= this._maximumIdleConnections) {
+            this._evict(connection);
+          } else {
+            this._available.push(connection);
+          }
+          continue;
+        }
+        const valid = await this._validate(connection);
+        if (!this._started) {
+          request.reject(new Error(`Pool stopped while validatin connection ${connection.id}`));
+          return;
+        }
+        if (!valid) {
+          if (request.pending)
+            this._pending.unshift(request);
+          this._evict(connection);
+          continue;
+        }
+        if (!request.pending) {
+          this.release(connection);
+          continue;
+        }
+        const timeout = setTimeout(() => {
+          this._logger.error(`Connection "${connection.id}" borrowed for too long`);
+          this._evict(connection);
+        }, this._borrowTimeoutMs).unref();
+        this._borrowed.set(connection, timeout);
+        this._emit("connection_acquired", connection);
+        request.resolve(connection);
+      }
+    }).catch(
+      /* coverage ignore next */
+      (error) => {
+        const retry = `retrying in ${this._retryIntervalMs} ms`;
+        this._logger.error(`Error in borrow loop, ${retry}:`, error);
+        setTimeout(() => this._runBorrowLoop(), this._retryIntervalMs);
+      }
+    );
+  }
+  /* ===== CONNECTION LIFECYCLE ============================================= */
+  /** Acquire a {@link Connection} from this {@link ConnectionPool} */
+  acquire() {
+    (0, import_node_assert.default)(this._started, "Connection pool not started");
+    const deferred = new ConnectionRequest(this._acquireTimeoutMs);
+    this._pending.push(deferred);
+    this._runBorrowLoop();
+    return deferred.promise;
+  }
+  /** Release a {@link Connection} back to this {@link ConnectionPool} */
+  release(connection) {
+    if (this._evicted.has(connection))
+      return;
+    (0, import_node_assert.default)(this._connections.has(connection), `Connection "${connection.id}" not owned by this pool`);
+    Promise.resolve().then(async () => {
+      this._logger.debug(`Releasing connection "${connection.id}"`);
+      clearTimeout(this._borrowed.get(connection));
+      if (!connection.connected) {
+        this._logger.info(`Disconnected connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else if (this._available.length >= this._maximumIdleConnections) {
+        this._logger.info(`Extra connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else if (!await this._recycle(connection)) {
+        this._logger.info(`Non-validated connection "${connection.id}" discarded`);
+        this._evict(connection);
+      } else {
+        this._logger.debug(`Connection "${connection.id}" released`);
+        this._borrowed.delete(connection);
+        this._available.push(connection);
+        this._emit("connection_released", connection);
+      }
+    }).catch((error) => {
+      this._logger.error(`Error releasing connection "${connection.id}":`, error);
+      this._evict(connection);
+    }).finally(() => this._runBorrowLoop());
+  }
+  /* ===== POOL LIFECYCLE =================================================== */
+  /** Start this {@link ConnectionPool} validating an initial connection */
+  async start() {
+    if (this._started || this._starting)
+      return this;
+    this._logger.debug("Starting connection pool");
+    this._starting = true;
+    try {
+      const connection = this._create(this._logger, this._connectionOptions);
+      await connection.connect();
+      const valid = await this._validate(connection);
+      (0, import_node_assert.default)(valid, `Unable to validate initial connection "${connection.id}"`);
+      this._logger.debug(`Initial connection "${connection.id}" validated`);
+      this._adopt(connection);
+      this._started = true;
+      this._emit("started");
+      this._emit("connection_created", connection);
+      if (this._maximumIdleConnections > 0) {
+        this._available.push(connection);
+      } else {
+        this._evict(connection);
+      }
+      this._runCreateLoop();
+      return this;
+    } finally {
+      this._starting = false;
+    }
+  }
+  /** Stop this {@link ConnectionPool} and disconnect all connections. */
+  stop() {
+    if (!this._started)
+      return;
+    this._started = false;
+    const connections = `${this._connections.size} connections`;
+    const requests = `${this._pending.length} pending requests`;
+    this._logger.info(`Stopping connection pool with ${connections} and ${requests}`);
+    for (const pending of this._pending) {
+      pending.reject(new Error("Connection pool stopped"));
+    }
+    this._available.splice(0, Number.MAX_SAFE_INTEGER);
+    this._borrowed.clear();
+    try {
+      this._emit("stopped");
+    } finally {
+      this._connections.clear();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionPool
+});
+//# sourceMappingURL=pool.cjs.map

package/dist/pool.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/pool.ts"],
+  "mappings": "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",
+  "names": ["assert"]
+}

package/dist/pool.d.ts

@@ -0,0 +1,159 @@
+import { Connection } from './connection';
+import { Emitter } from './events';
+import type { ConnectionOptions } from './connection';
+import type { Logger } from './index';
+/** Configuration for our {@link ConnectionPool}. */
+export interface ConnectionPoolConfig {
+    /**
+     * The minimum number of connections to keep in the pool
+     *
+     * * _default_: `0`
+     * * _environment varaible_: `PGPOOLMINSIZE`
+     */
+    minimumPoolSize?: number;
+    /**
+     * The maximum number of connections to keep in the pool
+     *
+     * * _default_: `20` more than `minimumPoolSize`
+     * * _environment varaible_: `PGPOOLMAXSIZE`
+     */
+    maximumPoolSize?: number;
+    /**
+     * The maximum number of idle connections that can be sitting in the pool.
+     *
+     * * _default_: the average between `minimumPoolSize` and `maximumPoolSize`
+     * * _environment varaible_: `PGPOOLIDLECONN`
+     */
+    maximumIdleConnections?: number;
+    /**
+     * The number of seconds after which an `acquire()` call will fail
+     *
+     * * _default_: `30` sec.
+     * * _environment varaible_: `PGPOOLACQUIRETIMEOUT`
+     */
+    acquireTimeout?: number;
+    /**
+     * The maximum number of seconds a connection can be borrowed for
+     *
+     * * _default_: `120` sec.
+     * * _environment varaible_: `PGPOOLBORROWTIMEOUT`
+     */
+    borrowTimeout?: number;
+    /**
+     * The number of seconds to wait after the creation of a connection failed
+     *
+     * * _default_: `5` sec.
+     * * _environment varaible_: `PGPOOLRETRYINTERVAL`
+     */
+    retryInterval?: number;
+    /**
+     * Whether to validate connections on borrow or not
+     *
+     * * _default_: `true`.
+     * * _environment varaible_: `PGPOOLVALIDATEONBORROW`
+     */
+    validateOnBorrow?: boolean;
+}
+/** Constructor options for our {@link ConnectionPool} */
+export interface ConnectionPoolOptions extends ConnectionPoolConfig, ConnectionOptions {
+}
+/** Statistical informations about a {@link ConnectionPool} */
+export interface ConnectionPoolStats {
+    /** The number of {@link Connection}s currently available in the pool */
+    available: number;
+    /** The number of {@link Connection}s currently borrowed out by the pool */
+    borrowed: number;
+    /** The number of {@link Connection}s currently connecting */
+    connecting: number;
+    /** The total number of {@link Connection}s managed by the pool */
+    total: number;
+}
+/** Events generated by our {@link ConnectionPool} */
+interface ConnectionPoolEvents {
+    started: () => unknown;
+    stopped: () => unknown;
+    /** Emitted after the connection has been created, connected and adopted */
+    connection_created: (connection: Connection) => unknown;
+    /** Emitted after the connection has been evicted and destroyed */
+    connection_destroyed: (connection: Connection) => unknown;
+    /** Emitted when a created connection can not be connected */
+    connection_aborted: (connection: Connection) => unknown;
+    /** Emitted when a connection has been acquired */
+    connection_acquired: (connection: Connection) => unknown;
+    /** Emitted when a connection has been released */
+    connection_released: (connection: Connection) => unknown;
+}
+export declare class ConnectionPool extends Emitter<ConnectionPoolEvents> {
+    /** Borrowed connections mapped to their borrow timeout */
+    private readonly _borrowed;
+    /** Array of all _available_ connections (that is, not borrowed out) */
+    private readonly _available;
+    /** Array of all pending {@link ConnectionRequest}s */
+    private readonly _pending;
+    /** All connections mapped to their evictor callback handler */
+    private readonly _connections;
+    /** A {@link WeakMap} of connections already evicted by this pool */
+    private readonly _evicted;
+    /** The minimum number of connections to keep in the pool */
+    private readonly _minimumPoolSize;
+    /** The maximum number of connections to keep in the pool */
+    private readonly _maximumPoolSize;
+    /** The maximum number of idle connections that can be sitting in the pool */
+    private readonly _maximumIdleConnections;
+    /** The number of *milliseconds* after which an `acquire()` call will fail */
+    private readonly _acquireTimeoutMs;
+    /** The maximum number of *milliseconds* a connection can be borrowed for */
+    private readonly _borrowTimeoutMs;
+    /** The number of *milliseconds* to wait after the creation of a connection failed */
+    private readonly _retryIntervalMs;
+    /** Whether to validate connections on borrow or not */
+    private readonly _validateOnBorrow;
+    /** The {@link ConnectionOptions} converted into a string for `LibPQ` */
+    private readonly _connectionOptions;
+    /** Indicator on whether this {@link ConnectionPool} was started or not */
+    private _started;
+    /** Indicator on whether this {@link ConnectionPool} is starting or not */
+    private _starting;
+    /** Create a new {@link ConnectionPool} */
+    constructor(logger: Logger, options?: ConnectionPoolOptions);
+    /** Statistical informations about a {@link ConnectionPool} */
+    get stats(): ConnectionPoolStats;
+    /** Returns a flag indicating whether this pool is running or not */
+    get running(): boolean;
+    /** Returns the running configuration of this instance */
+    get configuration(): Required<ConnectionPoolConfig>;
+    /** Create a connection */
+    protected _create(logger: Logger, params: string): Connection;
+    /** Validate a connection by issuing a super-simple statement */
+    protected _validate(connection: Connection): Promise<boolean>;
+    /** Recycle a connection rolling back any running transaction */
+    protected _recycle(connection: Connection): Promise<boolean>;
+    /** Adopt a connection tying it to our events */
+    private _adopt;
+    /** Destroy a connection, it will be wiped from this pool */
+    private _evict;
+    /**
+     * Run the create connection loop.
+     *
+     * This loop simply creates connections, connects them, sets up the various
+     * event handler (on disconnect) and simply adds them to the available array.
+     */
+    private _runCreateLoop;
+    /**
+     * Run the borrow connection loop.
+     *
+     * This loop looks at all the pending connection requests, and fullfills them
+     * with a connection from the available array. If no connections are available
+     * then it simply triggers the create loop.
+     */
+    private _runBorrowLoop;
+    /** Acquire a {@link Connection} from this {@link ConnectionPool} */
+    acquire(): Promise<Connection>;
+    /** Release a {@link Connection} back to this {@link ConnectionPool} */
+    release(connection: Connection): void;
+    /** Start this {@link ConnectionPool} validating an initial connection */
+    start(): Promise<this>;
+    /** Stop this {@link ConnectionPool} and disconnect all connections. */
+    stop(): void;
+}
+export {};