pg 8.2.0 → 8.3.2

package/lib/connection-parameters.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 var dns = require('dns')
 
@@ -40,72 +33,6 @@ var readSSLConfigFromEnvironment = function () {
   return defaults.ssl
 }
 
-var ConnectionParameters = function (config) {
-  // if a string is passed, it is a raw connection string so we parse it into a config
-  config = typeof config === 'string' ? parse(config) : config || {}
-
-  // if the config has a connectionString defined, parse IT into the config we use
-  // this will override other default values with what is stored in connectionString
-  if (config.connectionString) {
-    config = Object.assign({}, config, parse(config.connectionString))
-  }
-
-  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)
-
-  // "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' ? readSSLConfigFromEnvironment() : config.ssl
-
-  // support passing in ssl=no-verify via connection string
-  if (this.ssl === 'no-verify') {
-    this.ssl = { rejectUnauthorized: false }
-  }
-
-  this.client_encoding = val('client_encoding', config)
-  this.replication = val('replication', config)
-  // a domain socket begins with '/'
-  this.isDomainSocket = !(this.host || '').indexOf('/')
-
-  this.application_name = val('application_name', config, 'PGAPPNAME')
-  this.fallback_application_name = val('fallback_application_name', config, false)
-  this.statement_timeout = val('statement_timeout', config, false)
-  this.idle_in_transaction_session_timeout = val('idle_in_transaction_session_timeout', config, false)
-  this.query_timeout = val('query_timeout', config, false)
-
-  if (config.connectionTimeoutMillis === undefined) {
-    this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0
-  } else {
-    this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1000)
-  }
-
-  if (config.keepAlive === false) {
-    this.keepalives = 0
-  } else if (config.keepAlive === true) {
-    this.keepalives = 1
-  }
-
-  if (typeof config.keepAliveInitialDelayMillis === 'number') {
-    this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1000)
-  }
-}
-
 // Convert arg to a string, surround in single quotes, and escape single quotes and backslashes
 var quoteParamValue = function (value) {
   return "'" + ('' + value).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'"
@@ -118,42 +45,112 @@ var add = function (params, config, paramName) {
   }
 }
 
-ConnectionParameters.prototype.getLibpqConnectionString = function (cb) {
-  var params = []
-  add(params, this, 'user')
-  add(params, this, 'password')
-  add(params, this, 'port')
-  add(params, this, 'application_name')
-  add(params, this, 'fallback_application_name')
-  add(params, this, 'connect_timeout')
-
-  var ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
-  add(params, ssl, 'sslmode')
-  add(params, ssl, 'sslca')
-  add(params, ssl, 'sslkey')
-  add(params, ssl, 'sslcert')
-  add(params, ssl, 'sslrootcert')
-
-  if (this.database) {
-    params.push('dbname=' + quoteParamValue(this.database))
-  }
-  if (this.replication) {
-    params.push('replication=' + quoteParamValue(this.replication))
+class ConnectionParameters {
+  constructor(config) {
+    // if a string is passed, it is a raw connection string so we parse it into a config
+    config = typeof config === 'string' ? parse(config) : config || {}
+
+    // if the config has a connectionString defined, parse IT into the config we use
+    // this will override other default values with what is stored in connectionString
+    if (config.connectionString) {
+      config = Object.assign({}, config, parse(config.connectionString))
+    }
+
+    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)
+
+    // "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.options = val('options', config)
+
+    this.ssl = typeof config.ssl === 'undefined' ? readSSLConfigFromEnvironment() : config.ssl
+
+    // support passing in ssl=no-verify via connection string
+    if (this.ssl === 'no-verify') {
+      this.ssl = { rejectUnauthorized: false }
+    }
+
+    this.client_encoding = val('client_encoding', config)
+    this.replication = val('replication', config)
+    // a domain socket begins with '/'
+    this.isDomainSocket = !(this.host || '').indexOf('/')
+
+    this.application_name = val('application_name', config, 'PGAPPNAME')
+    this.fallback_application_name = val('fallback_application_name', config, false)
+    this.statement_timeout = val('statement_timeout', config, false)
+    this.idle_in_transaction_session_timeout = val('idle_in_transaction_session_timeout', config, false)
+    this.query_timeout = val('query_timeout', config, false)
+
+    if (config.connectionTimeoutMillis === undefined) {
+      this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0
+    } else {
+      this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1000)
+    }
+
+    if (config.keepAlive === false) {
+      this.keepalives = 0
+    } else if (config.keepAlive === true) {
+      this.keepalives = 1
+    }
+
+    if (typeof config.keepAliveInitialDelayMillis === 'number') {
+      this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1000)
+    }
   }
-  if (this.host) {
-    params.push('host=' + quoteParamValue(this.host))
-  }
-  if (this.isDomainSocket) {
-    return cb(null, params.join(' '))
-  }
-  if (this.client_encoding) {
-    params.push('client_encoding=' + quoteParamValue(this.client_encoding))
+
+  getLibpqConnectionString(cb) {
+    var params = []
+    add(params, this, 'user')
+    add(params, this, 'password')
+    add(params, this, 'port')
+    add(params, this, 'application_name')
+    add(params, this, 'fallback_application_name')
+    add(params, this, 'connect_timeout')
+    add(params, this, 'options')
+
+    var ssl = typeof this.ssl === 'object' ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}
+    add(params, ssl, 'sslmode')
+    add(params, ssl, 'sslca')
+    add(params, ssl, 'sslkey')
+    add(params, ssl, 'sslcert')
+    add(params, ssl, 'sslrootcert')
+
+    if (this.database) {
+      params.push('dbname=' + quoteParamValue(this.database))
+    }
+    if (this.replication) {
+      params.push('replication=' + quoteParamValue(this.replication))
+    }
+    if (this.host) {
+      params.push('host=' + quoteParamValue(this.host))
+    }
+    if (this.isDomainSocket) {
+      return cb(null, params.join(' '))
+    }
+    if (this.client_encoding) {
+      params.push('client_encoding=' + quoteParamValue(this.client_encoding))
+    }
+    dns.lookup(this.host, function (err, address) {
+      if (err) return cb(err, null)
+      params.push('hostaddr=' + quoteParamValue(address))
+      return cb(null, params.join(' '))
+    })
   }
-  dns.lookup(this.host, function (err, address) {
-    if (err) return cb(err, null)
-    params.push('hostaddr=' + quoteParamValue(address))
-    return cb(null, params.join(' '))
-  })
 }
 
 module.exports = ConnectionParameters

package/lib/connection.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 var net = require('net')
 var EventEmitter = require('events').EventEmitter
@@ -13,201 +6,203 @@ var util = require('util')
 
 const { parse, serialize } = require('pg-protocol')
 
-// TODO(bmc) support binary mode at some point
-var Connection = function (config) {
-  EventEmitter.call(this)
-  config = config || {}
-  this.stream = config.stream || new net.Socket()
-  this._keepAlive = config.keepAlive
-  this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis
-  this.lastBuffer = false
-  this.parsedStatements = {}
-  this.ssl = config.ssl || false
-  this._ending = false
-  this._emitMessage = false
-  var self = this
-  this.on('newListener', function (eventName) {
-    if (eventName === 'message') {
-      self._emitMessage = true
-    }
-  })
-}
-
-util.inherits(Connection, EventEmitter)
-
-Connection.prototype.connect = function (port, host) {
-  var self = this
-
-  this._connecting = true
-  this.stream.setNoDelay(true)
-  this.stream.connect(port, host)
+const flushBuffer = serialize.flush()
+const syncBuffer = serialize.sync()
+const endBuffer = serialize.end()
 
-  this.stream.once('connect', function () {
-    if (self._keepAlive) {
-      self.stream.setKeepAlive(true, self._keepAliveInitialDelayMillis)
-    }
-    self.emit('connect')
-  })
+// TODO(bmc) support binary mode at some point
+class Connection extends EventEmitter {
+  constructor(config) {
+    super()
+    config = config || {}
+    this.stream = config.stream || new net.Socket()
+    this._keepAlive = config.keepAlive
+    this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis
+    this.lastBuffer = false
+    this.parsedStatements = {}
+    this.ssl = config.ssl || false
+    this._ending = false
+    this._emitMessage = false
+    var self = this
+    this.on('newListener', function (eventName) {
+      if (eventName === 'message') {
+        self._emitMessage = true
+      }
+    })
+  }
 
-  const reportStreamError = function (error) {
-    // errors about disconnections should be ignored during disconnect
-    if (self._ending && (error.code === 'ECONNRESET' || error.code === 'EPIPE')) {
-      return
-    }
-    self.emit('error', error)
-  }
-  this.stream.on('error', reportStreamError)
-
-  this.stream.on('close', function () {
-    self.emit('end')
-  })
-
-  if (!this.ssl) {
-    return this.attachListeners(this.stream)
-  }
-
-  this.stream.once('data', function (buffer) {
-    var responseCode = buffer.toString('utf8')
-    switch (responseCode) {
-      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'))
+  connect(port, host) {
+    var self = this
+
+    this._connecting = true
+    this.stream.setNoDelay(true)
+    this.stream.connect(port, host)
+
+    this.stream.once('connect', function () {
+      if (self._keepAlive) {
+        self.stream.setKeepAlive(true, self._keepAliveInitialDelayMillis)
+      }
+      self.emit('connect')
+    })
+
+    const reportStreamError = function (error) {
+      // errors about disconnections should be ignored during disconnect
+      if (self._ending && (error.code === 'ECONNRESET' || error.code === 'EPIPE')) {
+        return
+      }
+      self.emit('error', error)
     }
-    var tls = require('tls')
-    const options = Object.assign(
-      {
-        socket: self.stream,
-      },
-      self.ssl
-    )
-    if (net.isIP(host) === 0) {
-      options.servername = host
-    }
-    self.stream = tls.connect(options)
-    self.attachListeners(self.stream)
-    self.stream.on('error', reportStreamError)
+    this.stream.on('error', reportStreamError)
 
-    self.emit('sslconnect')
-  })
-}
+    this.stream.on('close', function () {
+      self.emit('end')
+    })
 
-Connection.prototype.attachListeners = function (stream) {
-  stream.on('end', () => {
-    this.emit('end')
-  })
-  parse(stream, (msg) => {
-    var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
-    if (this._emitMessage) {
-      this.emit('message', msg)
+    if (!this.ssl) {
+      return this.attachListeners(this.stream)
     }
-    this.emit(eventName, msg)
-  })
-}
 
-Connection.prototype.requestSsl = function () {
-  this.stream.write(serialize.requestSsl())
-}
+    this.stream.once('data', function (buffer) {
+      var responseCode = buffer.toString('utf8')
+      switch (responseCode) {
+        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 = Object.assign(
+        {
+          socket: self.stream,
+        },
+        self.ssl
+      )
+      if (net.isIP(host) === 0) {
+        options.servername = host
+      }
+      try {
+        self.stream = tls.connect(options)
+      } catch (err) {
+        return self.emit('error', err)
+      }
+      self.attachListeners(self.stream)
+      self.stream.on('error', reportStreamError)
+
+      self.emit('sslconnect')
+    })
+  }
 
-Connection.prototype.startup = function (config) {
-  this.stream.write(serialize.startup(config))
-}
+  attachListeners(stream) {
+    stream.on('end', () => {
+      this.emit('end')
+    })
+    parse(stream, (msg) => {
+      var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
+      if (this._emitMessage) {
+        this.emit('message', msg)
+      }
+      this.emit(eventName, msg)
+    })
+  }
 
-Connection.prototype.cancel = function (processID, secretKey) {
-  this._send(serialize.cancel(processID, secretKey))
-}
+  requestSsl() {
+    this.stream.write(serialize.requestSsl())
+  }
 
-Connection.prototype.password = function (password) {
-  this._send(serialize.password(password))
-}
+  startup(config) {
+    this.stream.write(serialize.startup(config))
+  }
 
-Connection.prototype.sendSASLInitialResponseMessage = function (mechanism, initialResponse) {
-  this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse))
-}
+  cancel(processID, secretKey) {
+    this._send(serialize.cancel(processID, secretKey))
+  }
 
-Connection.prototype.sendSCRAMClientFinalMessage = function (additionalData) {
-  this._send(serialize.sendSCRAMClientFinalMessage(additionalData))
-}
+  password(password) {
+    this._send(serialize.password(password))
+  }
 
-Connection.prototype._send = function (buffer) {
-  if (!this.stream.writable) {
-    return false
+  sendSASLInitialResponseMessage(mechanism, initialResponse) {
+    this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse))
   }
-  return this.stream.write(buffer)
-}
 
-Connection.prototype.query = function (text) {
-  this._send(serialize.query(text))
-}
+  sendSCRAMClientFinalMessage(additionalData) {
+    this._send(serialize.sendSCRAMClientFinalMessage(additionalData))
+  }
 
-// send parse message
-Connection.prototype.parse = function (query) {
-  this._send(serialize.parse(query))
-}
+  _send(buffer) {
+    if (!this.stream.writable) {
+      return false
+    }
+    return this.stream.write(buffer)
+  }
 
-// send bind message
-// "more" === true to buffer the message until flush() is called
-Connection.prototype.bind = function (config) {
-  this._send(serialize.bind(config))
-}
+  query(text) {
+    this._send(serialize.query(text))
+  }
 
-// send execute message
-// "more" === true to buffer the message until flush() is called
-Connection.prototype.execute = function (config) {
-  this._send(serialize.execute(config))
-}
+  // send parse message
+  parse(query) {
+    this._send(serialize.parse(query))
+  }
 
-const flushBuffer = serialize.flush()
-Connection.prototype.flush = function () {
-  if (this.stream.writable) {
-    this.stream.write(flushBuffer)
+  // send bind message
+  bind(config) {
+    this._send(serialize.bind(config))
   }
-}
 
-const syncBuffer = serialize.sync()
-Connection.prototype.sync = function () {
-  this._ending = true
-  this._send(syncBuffer)
-  this._send(flushBuffer)
-}
+  // send execute message
+  execute(config) {
+    this._send(serialize.execute(config))
+  }
 
-const endBuffer = serialize.end()
+  flush() {
+    if (this.stream.writable) {
+      this.stream.write(flushBuffer)
+    }
+  }
 
-Connection.prototype.end = function () {
-  // 0x58 = 'X'
-  this._ending = true
-  if (!this._connecting || !this.stream.writable) {
-    this.stream.end()
-    return
+  sync() {
+    this._ending = true
+    this._send(flushBuffer)
+    this._send(syncBuffer)
   }
-  return this.stream.write(endBuffer, () => {
-    this.stream.end()
-  })
-}
 
-Connection.prototype.close = function (msg) {
-  this._send(serialize.close(msg))
-}
+  end() {
+    // 0x58 = 'X'
+    this._ending = true
+    if (!this._connecting || !this.stream.writable) {
+      this.stream.end()
+      return
+    }
+    return this.stream.write(endBuffer, () => {
+      this.stream.end()
+    })
+  }
 
-Connection.prototype.describe = function (msg) {
-  this._send(serialize.describe(msg))
-}
+  close(msg) {
+    this._send(serialize.close(msg))
+  }
 
-Connection.prototype.sendCopyFromChunk = function (chunk) {
-  this._send(serialize.copyData(chunk))
-}
+  describe(msg) {
+    this._send(serialize.describe(msg))
+  }
 
-Connection.prototype.endCopyFrom = function () {
-  this._send(serialize.copyDone())
-}
+  sendCopyFromChunk(chunk) {
+    this._send(serialize.copyData(chunk))
+  }
 
-Connection.prototype.sendCopyFail = function (msg) {
-  this._send(serialize.copyFail(msg))
+  endCopyFrom() {
+    this._send(serialize.copyDone())
+  }
+
+  sendCopyFail(msg) {
+    this._send(serialize.copyFail(msg))
+  }
 }
 
 module.exports = Connection

package/lib/defaults.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 module.exports = {
   // database host. defaults to localhost
@@ -53,6 +46,8 @@ module.exports = {
 
   fallback_application_name: undefined,
 
+  options: undefined,
+
   parseInputDatesAsUTC: false,
 
   // max milliseconds any query using this connection will execute for before timing out in error.

package/lib/index.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 var Client = require('./client')
 var defaults = require('./defaults')

package/lib/native/client.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 // eslint-disable-next-line
 var Native = require('pg-native')

package/lib/native/query.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 var EventEmitter = require('events').EventEmitter
 var util = require('util')