pg 8.4.0 → 8.5.1

package/lib/client.js

@@ -57,6 +57,15 @@ class Client extends EventEmitter {
     this.processID = null
     this.secretKey = null
     this.ssl = this.connectionParameters.ssl || false
+    // As with Password, make SSL->Key (the private key) non-enumerable.
+    // It won't show up in stack traces
+    // or if the client is console.logged
+    if (this.ssl && this.ssl.key) {
+      Object.defineProperty(this.ssl, 'key', {
+        enumerable: false,
+      })
+    }
+
     this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0
   }
 

package/lib/connection-parameters.js

@@ -80,10 +80,20 @@ class ConnectionParameters {
 
     this.ssl = typeof config.ssl === 'undefined' ? readSSLConfigFromEnvironment() : config.ssl
 
+    if (typeof this.ssl === 'string') {
+      if (this.ssl === 'true') {
+        this.ssl = true
+      }
+    }
     // support passing in ssl=no-verify via connection string
     if (this.ssl === 'no-verify') {
       this.ssl = { rejectUnauthorized: false }
     }
+    if (this.ssl && this.ssl.key) {
+      Object.defineProperty(this.ssl, 'key', {
+        enumerable: false,
+      })
+    }
 
     this.client_encoding = val('client_encoding', config)
     this.replication = val('replication', config)

package/lib/connection.js

@@ -76,12 +76,18 @@ class Connection extends EventEmitter {
           return self.emit('error', new Error('There was an error establishing an SSL connection'))
       }
       var tls = require('tls')
-      const options = Object.assign(
-        {
-          socket: self.stream,
-        },
-        self.ssl
-      )
+      const options = {
+        socket: self.stream,
+      }
+
+      if (self.ssl !== true) {
+        Object.assign(options, self.ssl)
+
+        if ('key' in self.ssl) {
+          options.key = self.ssl.key
+        }
+      }
+
       if (net.isIP(host) === 0) {
         options.servername = host
       }

package/lib/index.js

@@ -40,9 +40,6 @@ if (typeof process.env.NODE_PG_FORCE_NATIVE !== 'undefined') {
         if (err.code !== 'MODULE_NOT_FOUND') {
           throw err
         }
-        /* eslint-disable no-console */
-        console.error(err.message)
-        /* eslint-enable no-console */
       }
 
       // overwrite module.exports.native so that getter is never called again

package/lib/query.js

@@ -96,39 +96,28 @@ class Query extends EventEmitter {
     }
   }
 
-  handleCommandComplete(msg, con) {
+  handleCommandComplete(msg, connection) {
     this._checkForMultirow()
     this._result.addCommandComplete(msg)
     // need to sync after each command complete of a prepared statement
-    if (this.isPreparedStatement) {
-      con.sync()
+    // if we were using a row count which results in multiple calls to _getRows
+    if (this.rows) {
+      connection.sync()
     }
   }
 
   // if a named prepared statement is created with empty query text
   // the backend will send an emptyQuery message but *not* a command complete message
-  // execution on the connection will hang until the backend receives a sync message
-  handleEmptyQuery(con) {
-    if (this.isPreparedStatement) {
-      con.sync()
-    }
-  }
-
-  handleReadyForQuery(con) {
-    if (this._canceledDueToError) {
-      return this.handleError(this._canceledDueToError, con)
-    }
-    if (this.callback) {
-      this.callback(null, this._results)
+  // since we pipeline sync immediately after execute we don't need to do anything here
+  // unless we have rows specified, in which case we did not pipeline the intial sync call
+  handleEmptyQuery(connection) {
+    if (this.rows) {
+      connection.sync()
     }
-    this.emit('end', this._results)
   }
 
   handleError(err, connection) {
     // need to sync after error during a prepared statement
-    if (this.isPreparedStatement) {
-      connection.sync()
-    }
     if (this._canceledDueToError) {
       err = this._canceledDueToError
       this._canceledDueToError = false
@@ -141,6 +130,16 @@ class Query extends EventEmitter {
     this.emit('error', err)
   }
 
+  handleReadyForQuery(con) {
+    if (this._canceledDueToError) {
+      return this.handleError(this._canceledDueToError, con)
+    }
+    if (this.callback) {
+      this.callback(null, this._results)
+    }
+    this.emit('end', this._results)
+  }
+
   submit(connection) {
     if (typeof this.text !== 'string' && typeof this.name !== 'string') {
       return new Error('A query must have either text or a name. Supplying neither is unsupported.')
@@ -173,7 +172,14 @@ class Query extends EventEmitter {
       portal: this.portal,
       rows: rows,
     })
-    connection.flush()
+    // if we're not reading pages of rows send the sync command
+    // to indicate the pipeline is finished
+    if (!rows) {
+      connection.sync()
+    } else {
+      // otherwise flush the call out to read more rows
+      connection.flush()
+    }
   }
 
   // http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY
@@ -191,22 +197,22 @@ class Query extends EventEmitter {
       })
     }
 
-    if (this.values) {
-      try {
-        this.values = this.values.map(utils.prepareValue)
-      } catch (err) {
-        this.handleError(err, connection)
-        return
-      }
+    // because we're mapping user supplied values to
+    // postgres wire protocol compatible values it could
+    // throw an exception, so try/catch this section
+    try {
+      connection.bind({
+        portal: this.portal,
+        statement: this.name,
+        values: this.values,
+        binary: this.binary,
+        valueMapper: utils.prepareValue,
+      })
+    } catch (err) {
+      this.handleError(err, connection)
+      return
     }
 
-    connection.bind({
-      portal: this.portal,
-      statement: this.name,
-      values: this.values,
-      binary: this.binary,
-    })
-
     connection.describe({
       type: 'P',
       name: this.portal || '',

package/lib/utils.js

@@ -38,6 +38,10 @@ function arrayString(val) {
 // note: you can override this function to provide your own conversion mechanism
 // for complex types, etc...
 var prepareValue = function (val, seen) {
+  // null and undefined are both null for postgres
+  if (val == null) {
+    return null
+  }
   if (val instanceof Buffer) {
     return val
   }
@@ -58,9 +62,6 @@ var prepareValue = function (val, seen) {
   if (Array.isArray(val)) {
     return arrayString(val)
   }
-  if (val === null || typeof val === 'undefined') {
-    return null
-  }
   if (typeof val === 'object') {
     return prepareObject(val, seen)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg",
-  "version": "8.4.0",
+  "version": "8.5.1",
   "description": "PostgreSQL client - pure javascript & libpq with the same API",
   "keywords": [
     "database",
@@ -22,8 +22,8 @@
     "buffer-writer": "2.0.0",
     "packet-reader": "1.0.0",
     "pg-connection-string": "^2.4.0",
-    "pg-pool": "^3.2.1",
-    "pg-protocol": "^1.3.0",
+    "pg-pool": "^3.2.2",
+    "pg-protocol": "^1.4.0",
     "pg-types": "^2.1.0",
     "pgpass": "1.x"
   },
@@ -52,5 +52,5 @@
   "engines": {
     "node": ">= 8.0.0"
   },
-  "gitHead": "7ffe68eba056b9a6d0fa88f928aa85e768c28838"
+  "gitHead": "0b9bb349dcb10f6473737001062082b65efc74be"
 }