pg 7.18.2 → 8.0.3

package/lib/client.js

@@ -30,7 +30,16 @@ var Client = function (config) {
   this.database = this.connectionParameters.database
   this.port = this.connectionParameters.port
   this.host = this.connectionParameters.host
-  this.password = this.connectionParameters.password
+
+  // "hiding" the password so it doesn't show up in stack traces
+  // or if the client is console.logged
+  Object.defineProperty(this, 'password', {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: this.connectionParameters.password,
+  })
+
   this.replication = this.connectionParameters.replication
 
   var c = config || {}
@@ -43,13 +52,15 @@ var Client = function (config) {
   this._connectionError = false
   this._queryable = true
 
-  this.connection = c.connection || new Connection({
-    stream: c.stream,
-    ssl: this.connectionParameters.ssl,
-    keepAlive: c.keepAlive || false,
-    keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
-    encoding: this.connectionParameters.client_encoding || 'utf8'
-  })
+  this.connection =
+    c.connection ||
+    new Connection({
+      stream: c.stream,
+      ssl: this.connectionParameters.ssl,
+      keepAlive: c.keepAlive || false,
+      keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
+      encoding: this.connectionParameters.client_encoding || 'utf8',
+    })
   this.queryQueue = []
   this.binary = c.binary || defaults.binary
   this.processID = null
@@ -118,9 +129,10 @@ Client.prototype._connect = function (callback) {
   function checkPgPass(cb) {
     return function (msg) {
       if (typeof self.password === 'function') {
-        self._Promise.resolve()
+        self._Promise
+          .resolve()
           .then(() => self.password())
-          .then(pass => {
+          .then((pass) => {
             if (pass !== undefined) {
               if (typeof pass !== 'string') {
                 con.emit('error', new TypeError('Password must be a string'))
@@ -131,7 +143,8 @@ Client.prototype._connect = function (callback) {
               self.connectionParameters.password = self.password = null
             }
             cb(msg)
-          }).catch(err => {
+          })
+          .catch((err) => {
             con.emit('error', err)
           })
       } else if (self.password !== null) {
@@ -148,22 +161,31 @@ Client.prototype._connect = function (callback) {
   }
 
   // password request handling
-  con.on('authenticationCleartextPassword', checkPgPass(function () {
-    con.password(self.password)
-  }))
+  con.on(
+    'authenticationCleartextPassword',
+    checkPgPass(function () {
+      con.password(self.password)
+    })
+  )
 
   // password request handling
-  con.on('authenticationMD5Password', checkPgPass(function (msg) {
-    con.password(utils.postgresMd5PasswordHash(self.user, self.password, msg.salt))
-  }))
+  con.on(
+    'authenticationMD5Password',
+    checkPgPass(function (msg) {
+      con.password(utils.postgresMd5PasswordHash(self.user, self.password, msg.salt))
+    })
+  )
 
   // password request handling (SASL)
   var saslSession
-  con.on('authenticationSASL', checkPgPass(function (msg) {
-    saslSession = sasl.startSession(msg.mechanisms)
+  con.on(
+    'authenticationSASL',
+    checkPgPass(function (msg) {
+      saslSession = sasl.startSession(msg.mechanisms)
 
-    con.sendSASLInitialResponseMessage(saslSession.mechanism, saslSession.response)
-  }))
+      con.sendSASLInitialResponseMessage(saslSession.mechanism, saslSession.response)
+    })
+  )
 
   // password request handling (SASL)
   con.on('authenticationSASLContinue', function (msg) {
@@ -250,9 +272,7 @@ Client.prototype._connect = function (callback) {
   })
 
   con.once('end', () => {
-    const error = this._ending
-      ? new Error('Connection terminated')
-      : new Error('Connection terminated unexpectedly')
+    const error = this._ending ? new Error('Connection terminated') : new Error('Connection terminated unexpectedly')
 
     clearTimeout(connectionTimeoutHandle)
     this._errorAllQueries(error)
@@ -358,7 +378,7 @@ Client.prototype.getStartupConf = function () {
 
   var data = {
     user: params.user,
-    database: params.database
+    database: params.database,
   }
 
   var appName = params.application_name || params.fallback_application_name
@@ -413,11 +433,11 @@ Client.prototype.escapeIdentifier = function (str) {
 // Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
 Client.prototype.escapeLiteral = function (str) {
   var hasBackslash = false
-  var escaped = '\''
+  var escaped = "'"
 
   for (var i = 0; i < str.length; i++) {
     var c = str[i]
-    if (c === '\'') {
+    if (c === "'") {
       escaped += c + c
     } else if (c === '\\') {
       escaped += c + c
@@ -427,7 +447,7 @@ Client.prototype.escapeLiteral = function (str) {
     }
   }
 
-  escaped += '\''
+  escaped += "'"
 
   if (hasBackslash === true) {
     escaped = ' E' + escaped
@@ -479,7 +499,7 @@ Client.prototype.query = function (config, values, callback) {
     query = new Query(config, values, callback)
     if (!query.callback) {
       result = new this._Promise((resolve, reject) => {
-        query.callback = (err, res) => err ? reject(err) : resolve(res)
+        query.callback = (err, res) => (err ? reject(err) : resolve(res))
       })
     }
   }
@@ -498,7 +518,7 @@ Client.prototype.query = function (config, values, callback) {
 
       // we already returned an error,
       // just do nothing if query completes
-      query.callback = () => { }
+      query.callback = () => {}
 
       // Remove from queue
       var index = this.queryQueue.indexOf(query)
@@ -545,6 +565,15 @@ Client.prototype.query = function (config, values, callback) {
 Client.prototype.end = function (cb) {
   this._ending = true
 
+  // if we have never connected, then end is a noop, callback immediately
+  if (!this.connection._connecting) {
+    if (cb) {
+      cb()
+    } else {
+      return this._Promise.resolve()
+    }
+  }
+
   if (this.activeQuery || !this._queryable) {
     // if we have an active query we need to force a disconnect
     // on the socket - otherwise a hung query could block end forever

package/lib/connection-fast.js

@@ -11,17 +11,12 @@ var net = require('net')
 var EventEmitter = require('events').EventEmitter
 var util = require('util')
 
-var Writer = require('buffer-writer')
 // eslint-disable-next-line
-var PacketStream = require('pg-packet-stream')
-
-var warnDeprecation = require('./compat/warn-deprecation')
-
-var TEXT_MODE = 0
+const { parse, serialize } = require('../../pg-protocol/dist')
 
 // TODO(bmc) support binary mode here
 // var BINARY_MODE = 1
-console.log('using faster connection')
+console.log('***using faster connection***')
 var Connection = function (config) {
   EventEmitter.call(this)
   config = config || {}
@@ -30,15 +25,9 @@ var Connection = function (config) {
   this._keepAlive = config.keepAlive
   this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis
   this.lastBuffer = false
-  this.lastOffset = 0
-  this.buffer = null
-  this.offset = null
-  this.encoding = config.encoding || 'utf8'
   this.parsedStatements = {}
-  this.writer = new Writer()
   this.ssl = config.ssl || false
   this._ending = false
-  this._mode = TEXT_MODE
   this._emitMessage = false
   var self = this
   this.on('newListener', function (eventName) {
@@ -53,13 +42,10 @@ util.inherits(Connection, EventEmitter)
 Connection.prototype.connect = function (port, host) {
   var self = this
 
-  if (this.stream.readyState === 'closed') {
-    this.stream.connect(port, host)
-  } else if (this.stream.readyState === 'open') {
-    this.emit('connect')
-  }
+  this._connecting = true
+  this.stream.connect(port, host)
 
-  this.stream.on('connect', function () {
+  this.stream.once('connect', function () {
     if (self._keepAlive) {
       self.stream.setKeepAlive(true, self._keepAliveInitialDelayMillis)
     }
@@ -86,30 +72,23 @@ Connection.prototype.connect = function (port, host) {
   this.stream.once('data', function (buffer) {
     var responseCode = buffer.toString('utf8')
     switch (responseCode) {
-      case 'N': // Server does not support SSL connections
-        return self.emit('error', new Error('The server does not support SSL connections'))
       case 'S': // Server supports SSL connections, continue with a secure connection
         break
+      case 'N': // Server does not support SSL connections
+        self.stream.end()
+        return self.emit('error', new Error('The server does not support SSL connections'))
       default:
         // Any other response byte, including 'E' (ErrorResponse) indicating a server error
+        self.stream.end()
         return self.emit('error', new Error('There was an error establishing an SSL connection'))
     }
     var tls = require('tls')
-    const options = {
-      socket: self.stream,
-      checkServerIdentity: self.ssl.checkServerIdentity || tls.checkServerIdentity,
-      rejectUnauthorized: self.ssl.rejectUnauthorized,
-      ca: self.ssl.ca,
-      pfx: self.ssl.pfx,
-      key: self.ssl.key,
-      passphrase: self.ssl.passphrase,
-      cert: self.ssl.cert,
-      secureOptions: self.ssl.secureOptions,
-      NPNProtocols: self.ssl.NPNProtocols
-    }
-    if (typeof self.ssl.rejectUnauthorized !== 'boolean') {
-      warnDeprecation('Implicit disabling of certificate verification is deprecated and will be removed in pg 8. Specify `rejectUnauthorized: true` to require a valid CA or `rejectUnauthorized: false` to explicitly opt out of MITM protection.', 'PG-SSL-VERIFY')
-    }
+    const options = Object.assign(
+      {
+        socket: self.stream,
+      },
+      self.ssl
+    )
     if (net.isIP(host) === 0) {
       options.servername = host
     }
@@ -122,257 +101,116 @@ Connection.prototype.connect = function (port, host) {
 }
 
 Connection.prototype.attachListeners = function (stream) {
-  var self = this
-  const mode = this._mode === TEXT_MODE ? 'text' : 'binary'
-  const packetStream = new PacketStream.PgPacketStream({ mode })
-  this.stream.pipe(packetStream)
-  packetStream.on('data', (msg) => {
+  stream.on('end', () => {
+    this.emit('end')
+  })
+  parse(stream, (msg) => {
     var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
-    if (self._emitMessage) {
-      self.emit('message', msg)
+    if (this._emitMessage) {
+      this.emit('message', msg)
     }
-    self.emit(eventName, msg)
-  })
-  stream.on('end', function () {
-    self.emit('end')
+    this.emit(eventName, msg)
   })
 }
 
 Connection.prototype.requestSsl = function () {
-  var bodyBuffer = this.writer
-    .addInt16(0x04d2)
-    .addInt16(0x162f)
-    .flush()
-
-  var length = bodyBuffer.length + 4
-
-  var buffer = new Writer()
-    .addInt32(length)
-    .add(bodyBuffer)
-    .join()
-  this.stream.write(buffer)
+  this.stream.write(serialize.requestSsl())
 }
 
 Connection.prototype.startup = function (config) {
-  var writer = this.writer.addInt16(3).addInt16(0)
-
-  Object.keys(config).forEach(function (key) {
-    var val = config[key]
-    writer.addCString(key).addCString(val)
-  })
-
-  writer.addCString('client_encoding').addCString("'utf-8'")
-
-  var bodyBuffer = writer.addCString('').flush()
-  // this message is sent without a code
-
-  var length = bodyBuffer.length + 4
-
-  var buffer = new Writer()
-    .addInt32(length)
-    .add(bodyBuffer)
-    .join()
-  this.stream.write(buffer)
+  this.stream.write(serialize.startup(config))
 }
 
 Connection.prototype.cancel = function (processID, secretKey) {
-  var bodyBuffer = this.writer
-    .addInt16(1234)
-    .addInt16(5678)
-    .addInt32(processID)
-    .addInt32(secretKey)
-    .flush()
-
-  var length = bodyBuffer.length + 4
-
-  var buffer = new Writer()
-    .addInt32(length)
-    .add(bodyBuffer)
-    .join()
-  this.stream.write(buffer)
+  this._send(serialize.cancel(processID, secretKey))
 }
 
 Connection.prototype.password = function (password) {
-  // 0x70 = 'p'
-  this._send(0x70, this.writer.addCString(password))
+  this._send(serialize.password(password))
 }
 
 Connection.prototype.sendSASLInitialResponseMessage = function (mechanism, initialResponse) {
-  // 0x70 = 'p'
-  this.writer
-    .addCString(mechanism)
-    .addInt32(Buffer.byteLength(initialResponse))
-    .addString(initialResponse)
-
-  this._send(0x70)
+  this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse))
 }
 
 Connection.prototype.sendSCRAMClientFinalMessage = function (additionalData) {
-  // 0x70 = 'p'
-  this.writer.addString(additionalData)
-
-  this._send(0x70)
+  this._send(serialize.sendSCRAMClientFinalMessage(additionalData))
 }
 
-Connection.prototype._send = function (code, more) {
+Connection.prototype._send = function (buffer) {
   if (!this.stream.writable) {
     return false
   }
-  return this.stream.write(this.writer.flush(code))
+  return this.stream.write(buffer)
 }
 
 Connection.prototype.query = function (text) {
-  // 0x51 = Q
-  this.stream.write(this.writer.addCString(text).flush(0x51))
+  this._send(serialize.query(text))
 }
 
 // send parse message
 Connection.prototype.parse = function (query) {
-  // expect something like this:
-  // { name: 'queryName',
-  //   text: 'select * from blah',
-  //   types: ['int8', 'bool'] }
-
-  // normalize missing query names to allow for null
-  query.name = query.name || ''
-  if (query.name.length > 63) {
-    /* eslint-disable no-console */
-    console.error('Warning! Postgres only supports 63 characters for query names.')
-    console.error('You supplied %s (%s)', query.name, query.name.length)
-    console.error('This can cause conflicts and silent errors executing queries')
-    /* eslint-enable no-console */
-  }
-  // normalize null type array
-  query.types = query.types || []
-  var len = query.types.length
-  var buffer = this.writer
-    .addCString(query.name) // name of query
-    .addCString(query.text) // actual query text
-    .addInt16(len)
-  for (var i = 0; i < len; i++) {
-    buffer.addInt32(query.types[i])
-  }
-
-  var code = 0x50
-  this._send(code)
-  this.flush()
+  this._send(serialize.parse(query))
 }
 
 // send bind message
 // "more" === true to buffer the message until flush() is called
 Connection.prototype.bind = function (config) {
-  // normalize config
-  config = config || {}
-  config.portal = config.portal || ''
-  config.statement = config.statement || ''
-  config.binary = config.binary || false
-  var values = config.values || []
-  var len = values.length
-  var useBinary = false
-  for (var j = 0; j < len; j++) {
-    useBinary |= values[j] instanceof Buffer
-  }
-  var buffer = this.writer.addCString(config.portal).addCString(config.statement)
-  if (!useBinary) {
-    buffer.addInt16(0)
-  } else {
-    buffer.addInt16(len)
-    for (j = 0; j < len; j++) {
-      buffer.addInt16(values[j] instanceof Buffer)
-    }
-  }
-  buffer.addInt16(len)
-  for (var i = 0; i < len; i++) {
-    var val = values[i]
-    if (val === null || typeof val === 'undefined') {
-      buffer.addInt32(-1)
-    } else if (val instanceof Buffer) {
-      buffer.addInt32(val.length)
-      buffer.add(val)
-    } else {
-      buffer.addInt32(Buffer.byteLength(val))
-      buffer.addString(val)
-    }
-  }
-
-  if (config.binary) {
-    buffer.addInt16(1) // format codes to use binary
-    buffer.addInt16(1)
-  } else {
-    buffer.addInt16(0) // format codes to use text
-  }
-  // 0x42 = 'B'
-  this._send(0x42)
-  this.flush()
+  this._send(serialize.bind(config))
 }
 
 // send execute message
 // "more" === true to buffer the message until flush() is called
 Connection.prototype.execute = function (config) {
-  config = config || {}
-  config.portal = config.portal || ''
-  config.rows = config.rows || ''
-  this.writer.addCString(config.portal).addInt32(config.rows)
-
-  // 0x45 = 'E'
-  this._send(0x45)
-  this.flush()
+  this._send(serialize.execute(config))
 }
 
-var emptyBuffer = Buffer.alloc(0)
-
-const flushBuffer = Buffer.from([0x48, 0x00, 0x00, 0x00, 0x04])
+const flushBuffer = serialize.flush()
 Connection.prototype.flush = function () {
   if (this.stream.writable) {
     this.stream.write(flushBuffer)
   }
 }
 
-const syncBuffer = Buffer.from([0x53, 0x00, 0x00, 0x00, 0x04])
+const syncBuffer = serialize.sync()
 Connection.prototype.sync = function () {
   this._ending = true
-  // clear out any pending data in the writer
-  this.writer.clear()
-  if (this.stream.writable) {
-    this.stream.write(syncBuffer)
-    this.stream.write(flushBuffer)
-  }
+  this._send(syncBuffer)
+  this._send(flushBuffer)
 }
 
-const END_BUFFER = Buffer.from([0x58, 0x00, 0x00, 0x00, 0x04])
+const endBuffer = serialize.end()
 
 Connection.prototype.end = function () {
   // 0x58 = 'X'
-  this.writer.clear()
   this._ending = true
-  return this.stream.write(END_BUFFER, () => {
+  if (!this._connecting || !this.stream.writable) {
+    this.stream.end()
+    return
+  }
+  return this.stream.write(endBuffer, () => {
     this.stream.end()
   })
 }
 
 Connection.prototype.close = function (msg) {
-  this.writer.addCString(msg.type + (msg.name || ''))
-  this._send(0x43)
+  this._send(serialize.close(msg))
 }
 
 Connection.prototype.describe = function (msg) {
-  this.writer.addCString(msg.type + (msg.name || ''))
-  this._send(0x44)
-  this.flush()
+  this._send(serialize.describe(msg))
 }
 
 Connection.prototype.sendCopyFromChunk = function (chunk) {
-  this.stream.write(this.writer.add(chunk).flush(0x64))
+  this._send(serialize.copyData(chunk))
 }
 
 Connection.prototype.endCopyFrom = function () {
-  this.stream.write(this.writer.add(emptyBuffer).flush(0x63))
+  this._send(serialize.copyDone())
 }
 
 Connection.prototype.sendCopyFail = function (msg) {
-  // this.stream.write(this.writer.add(emptyBuffer).flush(0x66));
-  this.writer.addCString(msg)
-  this._send(0x66)
+  this._send(serialize.copyFail(msg))
 }
 
 module.exports = Connection

package/lib/connection-parameters.js

@@ -22,9 +22,7 @@ var val = function (key, config, envVar) {
     envVar = process.env[envVar]
   }
 
-  return config[key] ||
-    envVar ||
-    defaults[key]
+  return config[key] || envVar || defaults[key]
 }
 
 var useSsl = function () {
@@ -52,15 +50,29 @@ var ConnectionParameters = function (config) {
 
   this.user = val('user', config)
   this.database = val('database', config)
+
+  if (this.database === undefined) {
+    this.database = this.user
+  }
+
   this.port = parseInt(val('port', config), 10)
   this.host = val('host', config)
-  this.password = val('password', config)
+
+  // "hiding" the password so it doesn't show up in stack traces
+  // or if the client is console.logged
+  Object.defineProperty(this, 'password', {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: val('password', config),
+  })
+
   this.binary = val('binary', config)
   this.ssl = typeof config.ssl === 'undefined' ? useSsl() : config.ssl
   this.client_encoding = val('client_encoding', config)
   this.replication = val('replication', config)
   // a domain socket begins with '/'
-  this.isDomainSocket = (!(this.host || '').indexOf('/'))
+  this.isDomainSocket = !(this.host || '').indexOf('/')
 
   this.application_name = val('application_name', config, 'PGAPPNAME')
   this.fallback_application_name = val('fallback_application_name', config, false)