zet-lib 1.4.11 → 1.4.13

package/lib/Pool.js

@@ -1,85 +1,92 @@
-'use strict'
+"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)) {
+        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]
+              return m[k];
             },
-          }
+          };
         }
-        Object.defineProperty(o, k2, desc)
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
-        if (k2 === undefined) k2 = k
-        o[k2] = m[k]
-      })
+        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 })
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
       }
     : function (o, v) {
-        o['default'] = 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')
+    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 { promisify } = require("util");
+const setTimeoutPromise = promisify(setTimeout);
+const pg_1 = require("pg");
 function pgToString(value) {
-  return value.toString()
+  return value.toString();
 }
-pg_1.types.setTypeParser(1082, pgToString) // date
-const uuid_1 = require('uuid')
-const ErrorWithCode_1 = require('./ErrorWithCode')
+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
+    return this.connectionQueue.length;
   }
   /**
    * Gets the number of idle connections
    */
   get idleCount() {
-    return this.idleConnections.length
+    return this.idleConnections.length;
   }
   /**
    * Gets the total number of connections in the pool
    */
   get totalCount() {
-    return this.connections.length
+    return this.connections.length;
   }
-  options
+  options;
   // Internal event emitter used to handle queued connection requests
-  connectionQueueEventEmitter
-  connections = []
+  connectionQueueEventEmitter;
+  connections = [];
   // Should self order by idle timeout ascending
-  idleConnections = []
-  connectionQueue = []
-  isEnding = false
+  idleConnections = [];
+  connectionQueue = [];
+  isEnding = false;
   constructor(options) {
     // eslint-disable-next-line constructor-super
-    super()
+    super();
     const defaultOptions = {
       poolSize: 10,
       idleTimeoutMillis: 10000,
@@ -87,7 +94,12 @@ class Pool extends events_1.EventEmitter {
       connectionTimeoutMillis: 5000,
       retryConnectionMaxRetries: 5,
       retryConnectionWaitMillis: 100,
-      retryConnectionErrorCodes: ['ENOTFOUND', 'EAI_AGAIN', 'ERR_PG_CONNECT_TIMEOUT', 'timeout expired'],
+      retryConnectionErrorCodes: [
+        "ENOTFOUND",
+        "EAI_AGAIN",
+        "ERR_PG_CONNECT_TIMEOUT",
+        "timeout expired",
+      ],
       reconnectOnDatabaseIsStartingError: true,
       waitForDatabaseStartupMillis: 0,
       databaseStartupTimeoutMillis: 90000,
@@ -100,26 +112,28 @@ class Pool extends events_1.EventEmitter {
       namedParameterFindRegExp: /@([\w])+\b/g,
       getNamedParameterReplaceRegExp(namedParameter) {
         // eslint-disable-next-line security/detect-non-literal-regexp
-        return new RegExp(`@${namedParameter}\\b`, 'gm')
+        return new RegExp(`@${namedParameter}\\b`, "gm");
       },
       getNamedParameterName(namedParameterWithSymbols) {
         // Remove leading @ symbol
-        return namedParameterWithSymbols.substring(1)
+        return namedParameterWithSymbols.substring(1);
       },
-    }
-    const { ssl, ...otherOptions } = options
-    this.options = { ...defaultOptions, ...otherOptions }
-    if (ssl === 'aws-rds') {
+    };
+    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',
-      }
+        ca: fs.readFileSync(
+          path.join(__dirname, "./certs/rds-global-bundle.pem")
+        ),
+        minVersion: "TLSv1.2",
+      };
     } else {
-      this.options.ssl = ssl
+      this.options.ssl = ssl;
     }
-    this.connectionQueueEventEmitter = new events_1.EventEmitter()
+    this.connectionQueueEventEmitter = new events_1.EventEmitter();
   }
   /**
    * Gets a client connection from the pool.
@@ -127,56 +141,66 @@ class Pool extends events_1.EventEmitter {
    */
   async connect() {
     if (this.isEnding) {
-      throw new ErrorWithCode_1.ErrorWithCode('Cannot use pool after calling end() on the pool', 'ERR_PG_CONNECT_POOL_ENDED')
+      throw new ErrorWithCode_1.ErrorWithCode(
+        "Cannot use pool after calling end() on the pool",
+        "ERR_PG_CONNECT_POOL_ENDED"
+      );
     }
-    const idleConnection = this.idleConnections.shift()
+    const idleConnection = this.idleConnections.shift();
     if (idleConnection) {
       if (idleConnection.idleTimeoutTimer) {
-        clearTimeout(idleConnection.idleTimeoutTimer)
+        clearTimeout(idleConnection.idleTimeoutTimer);
       }
-      this.emit('idleConnectionActivated')
-      return idleConnection
+      this.emit("idleConnectionActivated");
+      return idleConnection;
     }
-    const id = (0, uuid_1.v4)()
+    const id = (0, uuid_1.v4)();
     if (this.connections.length < this.options.poolSize) {
-      this.connections.push(id)
+      this.connections.push(id);
       try {
-        const connection = await this._createConnection(id)
-        return connection
+        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)
+        const connectionIndex = this.connections.indexOf(id);
         if (connectionIndex > -1) {
-          this.connections.splice(connectionIndex, 1)
+          this.connections.splice(connectionIndex, 1);
         }
-        throw ex
+        throw ex;
       }
     }
-    this.emit('connectionRequestQueued')
-    this.connectionQueue.push(id)
-    let connectionTimeoutTimer = null
+    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)
+            clearTimeout(connectionTimeoutTimer);
           }
-          this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`)
-          this.emit('connectionRequestDequeued')
-          resolve(client)
-        })
+          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}`)
+        connectionTimeoutTimer = await setTimeoutPromise(
+          this.options.waitForAvailableConnectionTimeoutMillis
+        );
+        this.connectionQueueEventEmitter.removeAllListeners(`connection_${id}`);
         // Remove this connection attempt from the connection queue
-        const index = this.connectionQueue.indexOf(id)
+        const index = this.connectionQueue.indexOf(id);
         if (index > -1) {
-          this.connectionQueue.splice(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')
+        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.
@@ -186,104 +210,140 @@ class Pool extends events_1.EventEmitter {
   query(text, values) {
     /* eslint-enable @typescript-eslint/no-explicit-any */
     if (Array.isArray(values)) {
-      return this._query(text, values)
+      return this._query(text, values);
     }
     if (!values || !Object.keys(values).length) {
-      return this._query(text)
+      return this._query(text);
     }
     // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
-    const tokenMatches = text.match(this.options.namedParameterFindRegExp)
+    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')
+      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 = []
+    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)
+        missingParameters.push(token);
       }
     }
     if (missingParameters.length) {
-      throw new ErrorWithCode_1.ErrorWithCode(`Missing query parameter(s): ${missingParameters.join(', ')}`, 'ERR_PG_QUERY_MISSING_QUERY_PARAMETER')
+      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
+    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
+      sql = sql.replace(
+        this.options.getNamedParameterReplaceRegExp(token),
+        `$${tokenIndex}`
+      );
+      params.push(values[token]);
+      tokenIndex += 1;
     }
-    return this._query(sql, params)
+    return this._query(sql, params);
   }
   /**
    * Drains the pool of all active client connections and prevents additional connections
    */
   end() {
-    this.isEnding = true
-    return this.drainIdleConnections()
+    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)))
+    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
+    const connection = await this.connect();
+    let removeConnection = false;
+    let timeoutError;
+    let connectionError;
     try {
-      const results = await connection.query(text, values)
-      return results
+      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
+      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
+        throw ex;
       }
     } finally {
-      await connection.release(removeConnection)
+      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')
+      this.emit("queryDeniedForReadOnlyTransaction");
     } else if (connectionError) {
       // This can happen when a cluster fails over
-      this.emit('queryDeniedForConnectionError')
+      this.emit("queryDeniedForConnectionError");
     }
     // Clear all idle connections and try the query again with a fresh connection
-    await this.drainIdleConnections()
+    await this.drainIdleConnections();
     if (!reconnectQueryStartTime) {
       // eslint-disable-next-line no-param-reassign
-      reconnectQueryStartTime = process.hrtime()
+      reconnectQueryStartTime = process.hrtime();
     }
-    if (timeoutError && this.options.waitForReconnectReadOnlyTransactionMillis > 0) {
-      await (0, promises_1.setTimeout)(this.options.waitForReconnectReadOnlyTransactionMillis)
+    if (
+      timeoutError &&
+      this.options.waitForReconnectReadOnlyTransactionMillis > 0
+    ) {
+      await setTimeoutPromise(
+        this.options.waitForReconnectReadOnlyTransactionMillis
+      );
     }
     if (connectionError && this.options.waitForReconnectConnectionMillis > 0) {
-      await (0, promises_1.setTimeout)(this.options.waitForReconnectConnectionMillis)
+      await setTimeoutPromise(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
+    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
+    if (
+      connectionError &&
+      timeSinceLastRun > this.options.connectionReconnectTimeoutMillis
+    ) {
+      throw connectionError;
     }
-    const results = await this._query(text, values, reconnectQueryStartTime)
-    return results
+    const results = await this._query(text, values, reconnectQueryStartTime);
+    return results;
   }
   /**
    * Creates a new client connection to add to the pool
@@ -292,9 +352,14 @@ class Pool extends events_1.EventEmitter {
    * @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
+  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.
      *
@@ -302,136 +367,167 @@ class Pool extends events_1.EventEmitter {
      */
     client.release = async (removeConnection = false) => {
       if (this.isEnding || removeConnection) {
-        await this._removeConnection(client)
-        return
+        await this._removeConnection(client);
+        return;
       }
-      const id = this.connectionQueue.shift()
+      const id = this.connectionQueue.shift();
       // Return the connection to be used by a queued request
       if (id) {
-        this.connectionQueueEventEmitter.emit(`connection_${id}`, client)
+        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')
+          void this._removeConnection(client);
+        }, this.options.idleTimeoutMillis);
+        this.idleConnections.push(client);
+        this.emit("connectionIdle");
       } else {
-        await this._removeConnection(client)
+        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
+      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()
+            await client.connect();
           } finally {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             if (connectionTimeoutTimer) {
-              clearTimeout(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')
+          connectionTimeoutTimer = await setTimeoutPromise(
+            connectionTimeoutMillis
+          );
+          throw new ErrorWithCode_1.ErrorWithCode(
+            "Timed out trying to connect to postgres",
+            "ERR_PG_CONNECT_TIMEOUT"
+          );
         })(),
-      ])
-      this.emit('connectionAddedToPool', {
+      ]);
+      this.emit("connectionAddedToPool", {
         connectionId,
         retryAttempt,
         startTime: createConnectionStartTime,
-      })
+      });
     } catch (ex) {
-      const { connection } = client
+      const { connection } = client;
       if (connection) {
         // Force a disconnect of the socket, if it exists.
-        connection.stream.destroy()
+        connection.stream.destroy();
       }
-      await client.end()
-      const { message, code } = ex
-      let retryConnection = false
+      await client.end();
+      const { message, code } = ex;
+      let retryConnection = false;
       if (this.options.retryConnectionMaxRetries) {
         if (code) {
-          retryConnection = this.options.retryConnectionErrorCodes.includes(code)
+          retryConnection =
+            this.options.retryConnectionErrorCodes.includes(code);
         } else {
           for (const errorCode of this.options.retryConnectionErrorCodes) {
             if (message.includes(errorCode)) {
-              retryConnection = true
-              break
+              retryConnection = true;
+              break;
             }
           }
         }
       }
-      if (retryConnection && retryAttempt < this.options.retryConnectionMaxRetries) {
-        this.emit('retryConnectionOnError')
+      if (
+        retryConnection &&
+        retryAttempt < this.options.retryConnectionMaxRetries
+      ) {
+        this.emit("retryConnectionOnError");
         if (this.options.retryConnectionWaitMillis > 0) {
-          await (0, promises_1.setTimeout)(this.options.retryConnectionWaitMillis)
+          await setTimeoutPromise(this.options.retryConnectionWaitMillis);
         }
-        const connectionAfterRetry = await this._createConnection(connectionId, retryAttempt + 1, createConnectionStartTime, databaseStartupStartTime)
-        return connectionAfterRetry
+        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 (
+        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()
+          databaseStartupStartTime = process.hrtime();
         }
         if (this.options.waitForDatabaseStartupMillis > 0) {
-          await (0, promises_1.setTimeout)(this.options.waitForDatabaseStartupMillis)
+          await setTimeoutPromise(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 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
+        const connectionAfterRetry = await this._createConnection(
+          connectionId,
+          0,
+          createConnectionStartTime,
+          databaseStartupStartTime
+        );
+        return connectionAfterRetry;
       }
-      throw ex
+      throw ex;
     }
-    return client
+    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)
+    client.removeListener("error", client.errorHandler);
     // Ignore any errors when ending the connection
-    client.on('error', () => {
+    client.on("error", () => {
       // NOOP
-    })
+    });
     if (client.idleTimeoutTimer) {
-      clearTimeout(client.idleTimeoutTimer)
+      clearTimeout(client.idleTimeoutTimer);
     }
-    const idleConnectionIndex = this.idleConnections.findIndex((connection) => connection.uniqueId === client.uniqueId)
+    const idleConnectionIndex = this.idleConnections.findIndex(
+      (connection) => connection.uniqueId === client.uniqueId
+    );
     if (idleConnectionIndex > -1) {
-      this.idleConnections.splice(idleConnectionIndex, 1)
-      this.emit('connectionRemovedFromIdlePool')
+      this.idleConnections.splice(idleConnectionIndex, 1);
+      this.emit("connectionRemovedFromIdlePool");
     }
-    const connectionIndex = this.connections.indexOf(client.uniqueId)
+    const connectionIndex = this.connections.indexOf(client.uniqueId);
     if (connectionIndex > -1) {
-      this.connections.splice(connectionIndex, 1)
+      this.connections.splice(connectionIndex, 1);
     }
     try {
-      await client.end()
+      await client.end();
     } catch (ex) {
-      const { message } = ex
+      const { message } = ex;
       if (!/This socket has been ended by the other party/giu.test(message)) {
-        this.emit('error', ex)
+        this.emit("error", ex);
       }
     }
-    this.emit('connectionRemovedFromPool')
+    this.emit("connectionRemovedFromPool");
   }
 }
-exports.Pool = Pool
+exports.Pool = Pool;
 //# sourceMappingURL=index.js.map