feat: Add dynamic retrieval for client password

lib/client.js

@@ -114,7 +114,28 @@ Client.prototype._connect = function (callback) {
 
   function checkPgPass (cb) {
     return function (msg) {
-      if (self.password !== null) {
+      if (typeof(self.password) === 'function') {
+        try {
+          self._Promise.resolve(self.password())
+            .then(pass => {
+              if (undefined !== pass) {
+                if (typeof(pass) !== 'string') {
+                  con.emit('error', new TypeError('Password must be a string'))
+                  return
+                }
+                self.connectionParameters.password = self.password = pass
+              } else {
+                self.connectionParameters.password = self.password = null
+              }
+              cb(msg)
+            })
+            .catch(err => {
+              con.emit('error', err)
+            })
+        } catch (err) {
+          con.emit('error', err)
+        }
+      } else if (self.password !== null) {
         cb(msg)
       } else {
         pgPass(self.connectionParameters, function (pass) {

test/integration/connection/dynamic-password.js

@@ -0,0 +1,113 @@
+'use strict'
+const assert = require('assert')
+const helper = require('./../test-helper')
+const suite = new helper.Suite()
+const pg = require('../../../lib/index');
+const Client = pg.Client;
+
+const password = process.env.PGPASSWORD || null;
+const sleep = millis => new Promise(resolve => setTimeout(resolve, millis))
+
+suite.testAsync('Get password from a sync function', function () {
+    let wasCalled = false
+    function getPassword() {
+        wasCalled = true
+        return password;
+    }
+    const client = new Client({
+        password: getPassword,
+    })
+    return client.connect()
+        .then(() => {
+            assert.ok(wasCalled, 'Our password function should have been called')
+            return client.end()
+        })
+})
+
+suite.testAsync('Throw error from a sync function', function () {
+    let wasCalled = false
+    const myError = new Error('Oops!')
+    function getPassword() {
+        wasCalled = true
+        throw myError
+    }
+    const client = new Client({
+        password: getPassword,
+    })
+    let wasThrown = false
+    return client.connect()
+        .catch(err => {
+            assert.equal(err, myError, 'Our sync error should have been thrown')
+            wasThrown = true
+        })
+        .then(() => {
+            assert.ok(wasCalled, 'Our password function should have been called')
+            assert.ok(wasThrown, 'Our error should have been thrown')
+            return client.end()
+        })
+})
+
+suite.testAsync('Get password from a function asynchronously', function () {
+    let wasCalled = false
+    function getPassword() {
+        wasCalled = true
+        return sleep(100).then(() => password)
+    }
+    const client = new Client({
+        password: getPassword,
+    })
+    return client.connect()
+        .then(() => {
+            assert.ok(wasCalled, 'Our password function should have been called')
+            return client.end()
+        })
+})
+
+suite.testAsync('Throw error from an async function', function () {
+    let wasCalled = false
+    const myError = new Error('Oops!')
+    function getPassword() {
+        wasCalled = true
+        return sleep(100).then(() => {
+            throw myError
+        })
+    }
+    const client = new Client({
+        password: getPassword,
+    })
+    let wasThrown = false
+    return client.connect()
+        .catch(err => {
+            assert.equal(err, myError, 'Our async error should have been thrown')
+            wasThrown = true
+        })
+        .then(() => {
+            assert.ok(wasCalled, 'Our password function should have been called')
+            assert.ok(wasThrown, 'Our error should have been thrown')
+            return client.end()
+        })
+})
+
+suite.testAsync('Password function must return a string', function () {
+    let wasCalled = false
+    function getPassword() {
+        wasCalled = true
+        // Return a password that is not a string
+        return 12345
+    }
+    const client = new Client({
+        password: getPassword,
+    })
+    let wasThrown = false
+    return client.connect()
+        .catch(err => {
+            assert.ok(err instanceof TypeError, 'A TypeError should have been thrown')
+            assert.equal(err.message, 'Password must be a string')
+            wasThrown = true
+        })
+        .then(() => {
+            assert.ok(wasCalled, 'Our password function should have been called')
+            assert.ok(wasThrown, 'Our error should have been thrown')
+            return client.end()
+        })
+})

test/suite.js

@@ -72,6 +72,19 @@ class Suite {
     const test = new Test(name, cb)
     this._queue.push(test)
   }
+
+  testAsync (name, action) {
+    const test = new Test(name, cb => {
+      try {
+        Promise.resolve(action())
+          .then(() => cb(null))
+          .catch((err) => cb(err))
+      } catch (err) {
+        cb(err)
+      }
+    })
+    this._queue.push(test)
+  }
 }
 
 process.on('unhandledRejection', (e) => {