zet-lib 1.3.39 → 1.3.41

package/lib/Pool.js

@@ -1,437 +1,437 @@
-'use strict'
-var __createBinding =
-  (this && this.__createBinding) ||
-  (Object.create
-    ? function (o, m, k, k2) {
-        if (k2 === undefined) k2 = k
-        var desc = Object.getOwnPropertyDescriptor(m, k)
-        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-          desc = {
-            enumerable: true,
-            get: function () {
-              return m[k]
-            },
-          }
-        }
-        Object.defineProperty(o, k2, desc)
-      }
-    : function (o, m, k, k2) {
-        if (k2 === undefined) k2 = k
-        o[k2] = m[k]
-      })
-var __setModuleDefault =
-  (this && this.__setModuleDefault) ||
-  (Object.create
-    ? function (o, v) {
-        Object.defineProperty(o, 'default', { enumerable: true, value: v })
-      }
-    : function (o, v) {
-        o['default'] = v
-      })
-var __importStar =
-  (this && this.__importStar) ||
-  function (mod) {
-    if (mod && mod.__esModule) return mod
-    var result = {}
-    if (mod != null) for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-    __setModuleDefault(result, mod)
-    return result
-  }
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.Pool = void 0
-const events_1 = require('events')
-const fs = __importStar(require('fs'))
-const path = __importStar(require('path'))
-const promises_1 = require('timers-promises')
-const pg_1 = require('pg')
-function pgToString(value) {
-  return value.toString()
-}
-pg_1.types.setTypeParser(1082, pgToString) // date
-const uuid_1 = require('uuid')
-const ErrorWithCode_1 = require('./ErrorWithCode')
-class Pool extends events_1.EventEmitter {
-  /**
-   * Gets the number of queued requests waiting for a database connection
-   */
-  get waitingCount() {
-    return this.connectionQueue.length
-  }
-  /**
-   * Gets the number of idle connections
-   */
-  get idleCount() {
-    return this.idleConnections.length
-  }
-  /**
-   * Gets the total number of connections in the pool
-   */
-  get totalCount() {
-    return this.connections.length
-  }
-  options
-  // Internal event emitter used to handle queued connection requests
-  connectionQueueEventEmitter
-  connections = []
-  // Should self order by idle timeout ascending
-  idleConnections = []
-  connectionQueue = []
-  isEnding = false
-  constructor(options) {
-    // eslint-disable-next-line constructor-super
-    super()
-    const defaultOptions = {
-      poolSize: 10,
-      idleTimeoutMillis: 10000,
-      waitForAvailableConnectionTimeoutMillis: 90000,
-      connectionTimeoutMillis: 5000,
-      retryConnectionMaxRetries: 5,
-      retryConnectionWaitMillis: 100,
-      retryConnectionErrorCodes: ['ENOTFOUND', 'EAI_AGAIN', 'ERR_PG_CONNECT_TIMEOUT', 'timeout expired'],
-      reconnectOnDatabaseIsStartingError: true,
-      waitForDatabaseStartupMillis: 0,
-      databaseStartupTimeoutMillis: 90000,
-      reconnectOnReadOnlyTransactionError: true,
-      waitForReconnectReadOnlyTransactionMillis: 0,
-      readOnlyTransactionReconnectTimeoutMillis: 90000,
-      reconnectOnConnectionError: true,
-      waitForReconnectConnectionMillis: 0,
-      connectionReconnectTimeoutMillis: 90000,
-      namedParameterFindRegExp: /@([\w])+\b/g,
-      getNamedParameterReplaceRegExp(namedParameter) {
-        // eslint-disable-next-line security/detect-non-literal-regexp
-        return new RegExp(`@${namedParameter}\\b`, 'gm')
-      },
-      getNamedParameterName(namedParameterWithSymbols) {
-        // Remove leading @ symbol
-        return namedParameterWithSymbols.substring(1)
-      },
-    }
-    const { ssl, ...otherOptions } = options
-    this.options = { ...defaultOptions, ...otherOptions }
-    if (ssl === 'aws-rds') {
-      this.options.ssl = {
-        rejectUnauthorized: true,
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        ca: fs.readFileSync(path.join(__dirname, './certs/rds-global-bundle.pem')),
-        minVersion: 'TLSv1.2',
-      }
-    } else {
-      this.options.ssl = ssl
-    }
-    this.connectionQueueEventEmitter = new events_1.EventEmitter()
-  }
-  /**
-   * Gets a client connection from the pool.
-   * Note: You must call `.release()` when finished with the client connection object. That will release the connection back to the pool to be used by other requests.
-   */
-  async connect() {
-    if (this.isEnding) {
-      throw new ErrorWithCode_1.ErrorWithCode('Cannot use pool after calling end() on the pool', 'ERR_PG_CONNECT_POOL_ENDED')
-    }
-    const idleConnection = this.idleConnections.shift()
-    if (idleConnection) {
-      if (idleConnection.idleTimeoutTimer) {
-        clearTimeout(idleConnection.idleTimeoutTimer)
-      }
-      this.emit('idleConnectionActivated')
-      return idleConnection
-    }
-    const id = (0, uuid_1.v4)()
-    if (this.connections.length < this.options.poolSize) {
-      this.connections.push(id)
-      try {
-        const connection = await this._createConnection(id)
-        return connection
-      } catch (ex) {
-        // Remove the connection id since we failed to connect
-        const connectionIndex = this.connections.indexOf(id)
-        if (connectionIndex > -1) {
-          this.connections.splice(connectionIndex, 1)
-        }
-        throw ex
-      }
-    }
-    this.emit('connectionRequestQueued')
-    this.connectionQueue.push(id)
-    let connectionTimeoutTimer = null
-    return await Promise.race([
-      new Promise((resolve) => {
-        this.connectionQueueEventEmitter.on(`connection_${id}`, (client) => {
-          if (connectionTimeoutTimer) {
-            clearTimeout(connectionTimeoutTimer)
-          }
-          this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`)
-          this.emit('connectionRequestDequeued')
-          resolve(client)
-        })
-      }),
-      (async () => {
-        connectionTimeoutTimer = await (0, promises_1.setTimeout)(this.options.waitForAvailableConnectionTimeoutMillis)
-        this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`)
-        // Remove this connection attempt from the connection queue
-        const index = this.connectionQueue.indexOf(id)
-        if (index > -1) {
-          this.connectionQueue.splice(index, 1)
-        }
-        throw new ErrorWithCode_1.ErrorWithCode('Timed out while waiting for available connection in pool', 'ERR_PG_CONNECT_POOL_CONNECTION_TIMEOUT')
-      })(),
-    ])
-  }
-  /**
-   * Gets a connection to the database and executes the specified query. This method will release the connection back to the pool when the query has finished.
-   * @param {string} text
-   * @param {object | object[]} values - If an object, keys represent named parameters in the query
-   */
-  query(text, values) {
-    /* eslint-enable @typescript-eslint/no-explicit-any */
-    if (Array.isArray(values)) {
-      return this._query(text, values)
-    }
-    if (!values || !Object.keys(values).length) {
-      return this._query(text)
-    }
-    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
-    const tokenMatches = text.match(this.options.namedParameterFindRegExp)
-    if (!tokenMatches) {
-      throw new ErrorWithCode_1.ErrorWithCode('Did not find named parameters in in the query. Expected named parameter form is @foo', 'ERR_PG_QUERY_NO_NAMED_PARAMETERS')
-    }
-    // Get unique token names
-    // https://stackoverflow.com/a/45886147/3085
-    const tokens = Array.from(new Set(tokenMatches.map(this.options.getNamedParameterName)))
-    const missingParameters = []
-    for (const token of tokens) {
-      if (!(token in values)) {
-        missingParameters.push(token)
-      }
-    }
-    if (missingParameters.length) {
-      throw new ErrorWithCode_1.ErrorWithCode(`Missing query parameter(s): ${missingParameters.join(', ')}`, 'ERR_PG_QUERY_MISSING_QUERY_PARAMETER')
-    }
-    let sql = text.slice()
-    const params = []
-    let tokenIndex = 1
-    for (const token of tokens) {
-      sql = sql.replace(this.options.getNamedParameterReplaceRegExp(token), `$${tokenIndex}`)
-      params.push(values[token])
-      tokenIndex += 1
-    }
-    return this._query(sql, params)
-  }
-  /**
-   * Drains the pool of all active client connections and prevents additional connections
-   */
-  end() {
-    this.isEnding = true
-    return this.drainIdleConnections()
-  }
-  /**
-   * Drains the pool of all idle client connections.
-   */
-  async drainIdleConnections() {
-    await Promise.all([...this.idleConnections].map((idleConnection) => this._removeConnection(idleConnection)))
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async _query(text, values, reconnectQueryStartTime) {
-    const connection = await this.connect()
-    let removeConnection = false
-    let timeoutError
-    let connectionError
-    try {
-      const results = await connection.query(text, values)
-      return results
-    } catch (ex) {
-      const { message } = ex
-      if (this.options.reconnectOnReadOnlyTransactionError && /cannot execute [\s\w]+ in a read-only transaction/giu.test(message)) {
-        timeoutError = ex
-        removeConnection = true
-      } else if (this.options.reconnectOnConnectionError && /Client has encountered a connection error and is not queryable/giu.test(message)) {
-        connectionError = ex
-        removeConnection = true
-      } else {
-        throw ex
-      }
-    } finally {
-      await connection.release(removeConnection)
-    }
-    // If we get here, that means that the query was attempted with a read-only connection.
-    // This can happen when the cluster fails over to a read-replica
-    if (timeoutError) {
-      this.emit('queryDeniedForReadOnlyTransaction')
-    } else if (connectionError) {
-      // This can happen when a cluster fails over
-      this.emit('queryDeniedForConnectionError')
-    }
-    // Clear all idle connections and try the query again with a fresh connection
-    await this.drainIdleConnections()
-    if (!reconnectQueryStartTime) {
-      // eslint-disable-next-line no-param-reassign
-      reconnectQueryStartTime = process.hrtime()
-    }
-    if (timeoutError && this.options.waitForReconnectReadOnlyTransactionMillis > 0) {
-      await (0, promises_1.setTimeout)(this.options.waitForReconnectReadOnlyTransactionMillis)
-    }
-    if (connectionError && this.options.waitForReconnectConnectionMillis > 0) {
-      await (0, promises_1.setTimeout)(this.options.waitForReconnectConnectionMillis)
-    }
-    const diff = process.hrtime(reconnectQueryStartTime)
-    const timeSinceLastRun = Number((diff[0] * 1e3 + diff[1] * 1e-6).toFixed(3))
-    if (timeoutError && timeSinceLastRun > this.options.readOnlyTransactionReconnectTimeoutMillis) {
-      throw timeoutError
-    }
-    if (connectionError && timeSinceLastRun > this.options.connectionReconnectTimeoutMillis) {
-      throw connectionError
-    }
-    const results = await this._query(text, values, reconnectQueryStartTime)
-    return results
-  }
-  /**
-   * Creates a new client connection to add to the pool
-   * @param {string} connectionId
-   * @param {number} [retryAttempt=0]
-   * @param {bigint} [createConnectionStartTime] - High-resolution time (in nanoseconds) for when the connection was created
-   * @param {[number,number]} [databaseStartupStartTime] - hrtime when the db was first listed as starting up
-   */
-  async _createConnection(connectionId, retryAttempt = 0, createConnectionStartTime = process.hrtime.bigint(), databaseStartupStartTime) {
-    const client = new pg_1.Client(this.options)
-    client.uniqueId = connectionId
-    /**
-     * Releases the client connection back to the pool, to be used by another query.
-     *
-     * @param {boolean} [removeConnection=false]
-     */
-    client.release = async (removeConnection = false) => {
-      if (this.isEnding || removeConnection) {
-        await this._removeConnection(client)
-        return
-      }
-      const id = this.connectionQueue.shift()
-      // Return the connection to be used by a queued request
-      if (id) {
-        this.connectionQueueEventEmitter.emit(`connection_${id}`, client)
-      } else if (this.options.idleTimeoutMillis > 0) {
-        client.idleTimeoutTimer = setTimeout(() => {
-          // eslint-disable-next-line no-void
-          void this._removeConnection(client)
-        }, this.options.idleTimeoutMillis)
-        this.idleConnections.push(client)
-        this.emit('connectionIdle')
-      } else {
-        await this._removeConnection(client)
-      }
-    }
-    client.errorHandler = (err) => {
-      // fire and forget, we will always emit the error.
-      // eslint-disable-next-line no-void
-      void this._removeConnection(client).finally(() => this.emit('error', err, client))
-    }
-    client.on('error', client.errorHandler)
-    let connectionTimeoutTimer = null
-    const { connectionTimeoutMillis } = this.options
-    try {
-      await Promise.race([
-        (async function connectClient() {
-          try {
-            await client.connect()
-          } finally {
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (connectionTimeoutTimer) {
-              clearTimeout(connectionTimeoutTimer)
-            }
-          }
-        })(),
-        (async function connectTimeout() {
-          connectionTimeoutTimer = await (0, promises_1.setTimeout)(connectionTimeoutMillis)
-          throw new ErrorWithCode_1.ErrorWithCode('Timed out trying to connect to postgres', 'ERR_PG_CONNECT_TIMEOUT')
-        })(),
-      ])
-      this.emit('connectionAddedToPool', {
-        connectionId,
-        retryAttempt,
-        startTime: createConnectionStartTime,
-      })
-    } catch (ex) {
-      const { connection } = client
-      if (connection) {
-        // Force a disconnect of the socket, if it exists.
-        connection.stream.destroy()
-      }
-      await client.end()
-      const { message, code } = ex
-      let retryConnection = false
-      if (this.options.retryConnectionMaxRetries) {
-        if (code) {
-          retryConnection = this.options.retryConnectionErrorCodes.includes(code)
-        } else {
-          for (const errorCode of this.options.retryConnectionErrorCodes) {
-            if (message.includes(errorCode)) {
-              retryConnection = true
-              break
-            }
-          }
-        }
-      }
-      if (retryConnection && retryAttempt < this.options.retryConnectionMaxRetries) {
-        this.emit('retryConnectionOnError')
-        if (this.options.retryConnectionWaitMillis > 0) {
-          await (0, promises_1.setTimeout)(this.options.retryConnectionWaitMillis)
-        }
-        const connectionAfterRetry = await this._createConnection(connectionId, retryAttempt + 1, createConnectionStartTime, databaseStartupStartTime)
-        return connectionAfterRetry
-      }
-      if (this.options.reconnectOnDatabaseIsStartingError && /the database system is starting up/giu.test(message)) {
-        this.emit('waitingForDatabaseToStart')
-        if (!databaseStartupStartTime) {
-          // eslint-disable-next-line no-param-reassign
-          databaseStartupStartTime = process.hrtime()
-        }
-        if (this.options.waitForDatabaseStartupMillis > 0) {
-          await (0, promises_1.setTimeout)(this.options.waitForDatabaseStartupMillis)
-        }
-        const diff = process.hrtime(databaseStartupStartTime)
-        const timeSinceFirstConnectAttempt = Number((diff[0] * 1e3 + diff[1] * 1e-6).toFixed(3))
-        if (timeSinceFirstConnectAttempt > this.options.databaseStartupTimeoutMillis) {
-          throw ex
-        }
-        const connectionAfterRetry = await this._createConnection(connectionId, 0, createConnectionStartTime, databaseStartupStartTime)
-        return connectionAfterRetry
-      }
-      throw ex
-    }
-    return client
-  }
-  /**
-   * Removes the client connection from the pool and tries to gracefully shut it down
-   * @param {PoolClient} client
-   */
-  async _removeConnection(client) {
-    client.removeListener('error', client.errorHandler)
-    // Ignore any errors when ending the connection
-    client.on('error', () => {
-      // NOOP
-    })
-    if (client.idleTimeoutTimer) {
-      clearTimeout(client.idleTimeoutTimer)
-    }
-    const idleConnectionIndex = this.idleConnections.findIndex((connection) => connection.uniqueId === client.uniqueId)
-    if (idleConnectionIndex > -1) {
-      this.idleConnections.splice(idleConnectionIndex, 1)
-      this.emit('connectionRemovedFromIdlePool')
-    }
-    const connectionIndex = this.connections.indexOf(client.uniqueId)
-    if (connectionIndex > -1) {
-      this.connections.splice(connectionIndex, 1)
-    }
-    try {
-      await client.end()
-    } catch (ex) {
-      const { message } = ex
-      if (!/This socket has been ended by the other party/giu.test(message)) {
-        this.emit('error', ex)
-      }
-    }
-    this.emit('connectionRemovedFromPool')
-  }
-}
-exports.Pool = Pool
-//# sourceMappingURL=index.js.map
+'use strict'
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k
+        var desc = Object.getOwnPropertyDescriptor(m, k)
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k]
+            },
+          }
+        }
+        Object.defineProperty(o, k2, desc)
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k
+        o[k2] = m[k]
+      })
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v })
+      }
+    : function (o, v) {
+        o['default'] = v
+      })
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod
+    var result = {}
+    if (mod != null) for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
+    __setModuleDefault(result, mod)
+    return result
+  }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.Pool = void 0
+const events_1 = require('events')
+const fs = __importStar(require('fs'))
+const path = __importStar(require('path'))
+const promises_1 = require('timers-promises')
+const pg_1 = require('pg')
+function pgToString(value) {
+  return value.toString()
+}
+pg_1.types.setTypeParser(1082, pgToString) // date
+const uuid_1 = require('uuid')
+const ErrorWithCode_1 = require('./ErrorWithCode')
+class Pool extends events_1.EventEmitter {
+  /**
+   * Gets the number of queued requests waiting for a database connection
+   */
+  get waitingCount() {
+    return this.connectionQueue.length
+  }
+  /**
+   * Gets the number of idle connections
+   */
+  get idleCount() {
+    return this.idleConnections.length
+  }
+  /**
+   * Gets the total number of connections in the pool
+   */
+  get totalCount() {
+    return this.connections.length
+  }
+  options
+  // Internal event emitter used to handle queued connection requests
+  connectionQueueEventEmitter
+  connections = []
+  // Should self order by idle timeout ascending
+  idleConnections = []
+  connectionQueue = []
+  isEnding = false
+  constructor(options) {
+    // eslint-disable-next-line constructor-super
+    super()
+    const defaultOptions = {
+      poolSize: 10,
+      idleTimeoutMillis: 10000,
+      waitForAvailableConnectionTimeoutMillis: 90000,
+      connectionTimeoutMillis: 5000,
+      retryConnectionMaxRetries: 5,
+      retryConnectionWaitMillis: 100,
+      retryConnectionErrorCodes: ['ENOTFOUND', 'EAI_AGAIN', 'ERR_PG_CONNECT_TIMEOUT', 'timeout expired'],
+      reconnectOnDatabaseIsStartingError: true,
+      waitForDatabaseStartupMillis: 0,
+      databaseStartupTimeoutMillis: 90000,
+      reconnectOnReadOnlyTransactionError: true,
+      waitForReconnectReadOnlyTransactionMillis: 0,
+      readOnlyTransactionReconnectTimeoutMillis: 90000,
+      reconnectOnConnectionError: true,
+      waitForReconnectConnectionMillis: 0,
+      connectionReconnectTimeoutMillis: 90000,
+      namedParameterFindRegExp: /@([\w])+\b/g,
+      getNamedParameterReplaceRegExp(namedParameter) {
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        return new RegExp(`@${namedParameter}\\b`, 'gm')
+      },
+      getNamedParameterName(namedParameterWithSymbols) {
+        // Remove leading @ symbol
+        return namedParameterWithSymbols.substring(1)
+      },
+    }
+    const { ssl, ...otherOptions } = options
+    this.options = { ...defaultOptions, ...otherOptions }
+    if (ssl === 'aws-rds') {
+      this.options.ssl = {
+        rejectUnauthorized: true,
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        ca: fs.readFileSync(path.join(__dirname, './certs/rds-global-bundle.pem')),
+        minVersion: 'TLSv1.2',
+      }
+    } else {
+      this.options.ssl = ssl
+    }
+    this.connectionQueueEventEmitter = new events_1.EventEmitter()
+  }
+  /**
+   * Gets a client connection from the pool.
+   * Note: You must call `.release()` when finished with the client connection object. That will release the connection back to the pool to be used by other requests.
+   */
+  async connect() {
+    if (this.isEnding) {
+      throw new ErrorWithCode_1.ErrorWithCode('Cannot use pool after calling end() on the pool', 'ERR_PG_CONNECT_POOL_ENDED')
+    }
+    const idleConnection = this.idleConnections.shift()
+    if (idleConnection) {
+      if (idleConnection.idleTimeoutTimer) {
+        clearTimeout(idleConnection.idleTimeoutTimer)
+      }
+      this.emit('idleConnectionActivated')
+      return idleConnection
+    }
+    const id = (0, uuid_1.v4)()
+    if (this.connections.length < this.options.poolSize) {
+      this.connections.push(id)
+      try {
+        const connection = await this._createConnection(id)
+        return connection
+      } catch (ex) {
+        // Remove the connection id since we failed to connect
+        const connectionIndex = this.connections.indexOf(id)
+        if (connectionIndex > -1) {
+          this.connections.splice(connectionIndex, 1)
+        }
+        throw ex
+      }
+    }
+    this.emit('connectionRequestQueued')
+    this.connectionQueue.push(id)
+    let connectionTimeoutTimer = null
+    return await Promise.race([
+      new Promise((resolve) => {
+        this.connectionQueueEventEmitter.on(`connection_${id}`, (client) => {
+          if (connectionTimeoutTimer) {
+            clearTimeout(connectionTimeoutTimer)
+          }
+          this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`)
+          this.emit('connectionRequestDequeued')
+          resolve(client)
+        })
+      }),
+      (async () => {
+        connectionTimeoutTimer = await (0, promises_1.setTimeout)(this.options.waitForAvailableConnectionTimeoutMillis)
+        this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`)
+        // Remove this connection attempt from the connection queue
+        const index = this.connectionQueue.indexOf(id)
+        if (index > -1) {
+          this.connectionQueue.splice(index, 1)
+        }
+        throw new ErrorWithCode_1.ErrorWithCode('Timed out while waiting for available connection in pool', 'ERR_PG_CONNECT_POOL_CONNECTION_TIMEOUT')
+      })(),
+    ])
+  }
+  /**
+   * Gets a connection to the database and executes the specified query. This method will release the connection back to the pool when the query has finished.
+   * @param {string} text
+   * @param {object | object[]} values - If an object, keys represent named parameters in the query
+   */
+  query(text, values) {
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    if (Array.isArray(values)) {
+      return this._query(text, values)
+    }
+    if (!values || !Object.keys(values).length) {
+      return this._query(text)
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+    const tokenMatches = text.match(this.options.namedParameterFindRegExp)
+    if (!tokenMatches) {
+      throw new ErrorWithCode_1.ErrorWithCode('Did not find named parameters in in the query. Expected named parameter form is @foo', 'ERR_PG_QUERY_NO_NAMED_PARAMETERS')
+    }
+    // Get unique token names
+    // https://stackoverflow.com/a/45886147/3085
+    const tokens = Array.from(new Set(tokenMatches.map(this.options.getNamedParameterName)))
+    const missingParameters = []
+    for (const token of tokens) {
+      if (!(token in values)) {
+        missingParameters.push(token)
+      }
+    }
+    if (missingParameters.length) {
+      throw new ErrorWithCode_1.ErrorWithCode(`Missing query parameter(s): ${missingParameters.join(', ')}`, 'ERR_PG_QUERY_MISSING_QUERY_PARAMETER')
+    }
+    let sql = text.slice()
+    const params = []
+    let tokenIndex = 1
+    for (const token of tokens) {
+      sql = sql.replace(this.options.getNamedParameterReplaceRegExp(token), `$${tokenIndex}`)
+      params.push(values[token])
+      tokenIndex += 1
+    }
+    return this._query(sql, params)
+  }
+  /**
+   * Drains the pool of all active client connections and prevents additional connections
+   */
+  end() {
+    this.isEnding = true
+    return this.drainIdleConnections()
+  }
+  /**
+   * Drains the pool of all idle client connections.
+   */
+  async drainIdleConnections() {
+    await Promise.all([...this.idleConnections].map((idleConnection) => this._removeConnection(idleConnection)))
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async _query(text, values, reconnectQueryStartTime) {
+    const connection = await this.connect()
+    let removeConnection = false
+    let timeoutError
+    let connectionError
+    try {
+      const results = await connection.query(text, values)
+      return results
+    } catch (ex) {
+      const { message } = ex
+      if (this.options.reconnectOnReadOnlyTransactionError && /cannot execute [\s\w]+ in a read-only transaction/giu.test(message)) {
+        timeoutError = ex
+        removeConnection = true
+      } else if (this.options.reconnectOnConnectionError && /Client has encountered a connection error and is not queryable/giu.test(message)) {
+        connectionError = ex
+        removeConnection = true
+      } else {
+        throw ex
+      }
+    } finally {
+      await connection.release(removeConnection)
+    }
+    // If we get here, that means that the query was attempted with a read-only connection.
+    // This can happen when the cluster fails over to a read-replica
+    if (timeoutError) {
+      this.emit('queryDeniedForReadOnlyTransaction')
+    } else if (connectionError) {
+      // This can happen when a cluster fails over
+      this.emit('queryDeniedForConnectionError')
+    }
+    // Clear all idle connections and try the query again with a fresh connection
+    await this.drainIdleConnections()
+    if (!reconnectQueryStartTime) {
+      // eslint-disable-next-line no-param-reassign
+      reconnectQueryStartTime = process.hrtime()
+    }
+    if (timeoutError && this.options.waitForReconnectReadOnlyTransactionMillis > 0) {
+      await (0, promises_1.setTimeout)(this.options.waitForReconnectReadOnlyTransactionMillis)
+    }
+    if (connectionError && this.options.waitForReconnectConnectionMillis > 0) {
+      await (0, promises_1.setTimeout)(this.options.waitForReconnectConnectionMillis)
+    }
+    const diff = process.hrtime(reconnectQueryStartTime)
+    const timeSinceLastRun = Number((diff[0] * 1e3 + diff[1] * 1e-6).toFixed(3))
+    if (timeoutError && timeSinceLastRun > this.options.readOnlyTransactionReconnectTimeoutMillis) {
+      throw timeoutError
+    }
+    if (connectionError && timeSinceLastRun > this.options.connectionReconnectTimeoutMillis) {
+      throw connectionError
+    }
+    const results = await this._query(text, values, reconnectQueryStartTime)
+    return results
+  }
+  /**
+   * Creates a new client connection to add to the pool
+   * @param {string} connectionId
+   * @param {number} [retryAttempt=0]
+   * @param {bigint} [createConnectionStartTime] - High-resolution time (in nanoseconds) for when the connection was created
+   * @param {[number,number]} [databaseStartupStartTime] - hrtime when the db was first listed as starting up
+   */
+  async _createConnection(connectionId, retryAttempt = 0, createConnectionStartTime = process.hrtime.bigint(), databaseStartupStartTime) {
+    const client = new pg_1.Client(this.options)
+    client.uniqueId = connectionId
+    /**
+     * Releases the client connection back to the pool, to be used by another query.
+     *
+     * @param {boolean} [removeConnection=false]
+     */
+    client.release = async (removeConnection = false) => {
+      if (this.isEnding || removeConnection) {
+        await this._removeConnection(client)
+        return
+      }
+      const id = this.connectionQueue.shift()
+      // Return the connection to be used by a queued request
+      if (id) {
+        this.connectionQueueEventEmitter.emit(`connection_${id}`, client)
+      } else if (this.options.idleTimeoutMillis > 0) {
+        client.idleTimeoutTimer = setTimeout(() => {
+          // eslint-disable-next-line no-void
+          void this._removeConnection(client)
+        }, this.options.idleTimeoutMillis)
+        this.idleConnections.push(client)
+        this.emit('connectionIdle')
+      } else {
+        await this._removeConnection(client)
+      }
+    }
+    client.errorHandler = (err) => {
+      // fire and forget, we will always emit the error.
+      // eslint-disable-next-line no-void
+      void this._removeConnection(client).finally(() => this.emit('error', err, client))
+    }
+    client.on('error', client.errorHandler)
+    let connectionTimeoutTimer = null
+    const { connectionTimeoutMillis } = this.options
+    try {
+      await Promise.race([
+        (async function connectClient() {
+          try {
+            await client.connect()
+          } finally {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (connectionTimeoutTimer) {
+              clearTimeout(connectionTimeoutTimer)
+            }
+          }
+        })(),
+        (async function connectTimeout() {
+          connectionTimeoutTimer = await (0, promises_1.setTimeout)(connectionTimeoutMillis)
+          throw new ErrorWithCode_1.ErrorWithCode('Timed out trying to connect to postgres', 'ERR_PG_CONNECT_TIMEOUT')
+        })(),
+      ])
+      this.emit('connectionAddedToPool', {
+        connectionId,
+        retryAttempt,
+        startTime: createConnectionStartTime,
+      })
+    } catch (ex) {
+      const { connection } = client
+      if (connection) {
+        // Force a disconnect of the socket, if it exists.
+        connection.stream.destroy()
+      }
+      await client.end()
+      const { message, code } = ex
+      let retryConnection = false
+      if (this.options.retryConnectionMaxRetries) {
+        if (code) {
+          retryConnection = this.options.retryConnectionErrorCodes.includes(code)
+        } else {
+          for (const errorCode of this.options.retryConnectionErrorCodes) {
+            if (message.includes(errorCode)) {
+              retryConnection = true
+              break
+            }
+          }
+        }
+      }
+      if (retryConnection && retryAttempt < this.options.retryConnectionMaxRetries) {
+        this.emit('retryConnectionOnError')
+        if (this.options.retryConnectionWaitMillis > 0) {
+          await (0, promises_1.setTimeout)(this.options.retryConnectionWaitMillis)
+        }
+        const connectionAfterRetry = await this._createConnection(connectionId, retryAttempt + 1, createConnectionStartTime, databaseStartupStartTime)
+        return connectionAfterRetry
+      }
+      if (this.options.reconnectOnDatabaseIsStartingError && /the database system is starting up/giu.test(message)) {
+        this.emit('waitingForDatabaseToStart')
+        if (!databaseStartupStartTime) {
+          // eslint-disable-next-line no-param-reassign
+          databaseStartupStartTime = process.hrtime()
+        }
+        if (this.options.waitForDatabaseStartupMillis > 0) {
+          await (0, promises_1.setTimeout)(this.options.waitForDatabaseStartupMillis)
+        }
+        const diff = process.hrtime(databaseStartupStartTime)
+        const timeSinceFirstConnectAttempt = Number((diff[0] * 1e3 + diff[1] * 1e-6).toFixed(3))
+        if (timeSinceFirstConnectAttempt > this.options.databaseStartupTimeoutMillis) {
+          throw ex
+        }
+        const connectionAfterRetry = await this._createConnection(connectionId, 0, createConnectionStartTime, databaseStartupStartTime)
+        return connectionAfterRetry
+      }
+      throw ex
+    }
+    return client
+  }
+  /**
+   * Removes the client connection from the pool and tries to gracefully shut it down
+   * @param {PoolClient} client
+   */
+  async _removeConnection(client) {
+    client.removeListener('error', client.errorHandler)
+    // Ignore any errors when ending the connection
+    client.on('error', () => {
+      // NOOP
+    })
+    if (client.idleTimeoutTimer) {
+      clearTimeout(client.idleTimeoutTimer)
+    }
+    const idleConnectionIndex = this.idleConnections.findIndex((connection) => connection.uniqueId === client.uniqueId)
+    if (idleConnectionIndex > -1) {
+      this.idleConnections.splice(idleConnectionIndex, 1)
+      this.emit('connectionRemovedFromIdlePool')
+    }
+    const connectionIndex = this.connections.indexOf(client.uniqueId)
+    if (connectionIndex > -1) {
+      this.connections.splice(connectionIndex, 1)
+    }
+    try {
+      await client.end()
+    } catch (ex) {
+      const { message } = ex
+      if (!/This socket has been ended by the other party/giu.test(message)) {
+        this.emit('error', ex)
+      }
+    }
+    this.emit('connectionRemovedFromPool')
+  }
+}
+exports.Pool = Pool
+//# sourceMappingURL=index.js.map