pg 8.0.2 → 8.2.1

package/lib/connection.js

@@ -11,11 +11,9 @@ var net = require('net')
 var EventEmitter = require('events').EventEmitter
 var util = require('util')
 
-var Writer = require('buffer-writer')
-var Reader = require('packet-reader')
+const { parse, serialize } = require('pg-protocol')
 
-var TEXT_MODE = 0
-var BINARY_MODE = 1
+// TODO(bmc) support binary mode at some point
 var Connection = function (config) {
   EventEmitter.call(this)
   config = config || {}
@@ -23,20 +21,10 @@ 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
-  this._reader = new Reader({
-    headerSize: 1,
-    lengthPadding: -4
-  })
   var self = this
   this.on('newListener', function (eventName) {
     if (eventName === 'message') {
@@ -50,13 +38,11 @@ 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.setNoDelay(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)
     }
@@ -88,608 +74,140 @@ Connection.prototype.connect = function (port, host) {
       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
+      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)
+    const options = Object.assign(
+      {
+        socket: self.stream,
+      },
+      self.ssl
+    )
     if (net.isIP(host) === 0) {
       options.servername = host
     }
     self.stream = tls.connect(options)
-    self.stream.on('error', reportStreamError)
     self.attachListeners(self.stream)
+    self.stream.on('error', reportStreamError)
+
     self.emit('sslconnect')
   })
 }
 
 Connection.prototype.attachListeners = function (stream) {
-  var self = this
-  stream.on('data', function (buff) {
-    self._reader.addChunk(buff)
-    var packet = self._reader.read()
-    while (packet) {
-      var msg = self.parseMessage(packet)
-      var eventName = msg.name === 'error' ? 'errorMessage' : msg.name
-      if (self._emitMessage) {
-        self.emit('message', msg)
-      }
-      self.emit(eventName, msg)
-      packet = self._reader.read()
-    }
+  stream.on('end', () => {
+    this.emit('end')
   })
-  stream.on('end', function () {
-    self.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.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
   }
-  if (more === true) {
-    this.writer.addHeader(code)
-  } else {
-    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
-// "more" === true to buffer the message until flush() is called
-Connection.prototype.parse = function (query, more) {
-  // 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, more)
+Connection.prototype.parse = function (query) {
+  this._send(serialize.parse(query))
 }
 
 // send bind message
 // "more" === true to buffer the message until flush() is called
-Connection.prototype.bind = function (config, more) {
-  // 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, more)
+Connection.prototype.bind = function (config) {
+  this._send(serialize.bind(config))
 }
 
 // send execute message
 // "more" === true to buffer the message until flush() is called
-Connection.prototype.execute = function (config, more) {
-  config = config || {}
-  config.portal = config.portal || ''
-  config.rows = config.rows || ''
-  this.writer
-    .addCString(config.portal)
-    .addInt32(config.rows)
-
-  // 0x45 = 'E'
-  this._send(0x45, more)
+Connection.prototype.execute = function (config) {
+  this._send(serialize.execute(config))
 }
 
-var emptyBuffer = Buffer.alloc(0)
-
+const flushBuffer = serialize.flush()
 Connection.prototype.flush = function () {
-  // 0x48 = 'H'
-  this.writer.add(emptyBuffer)
-  this._send(0x48)
+  if (this.stream.writable) {
+    this.stream.write(flushBuffer)
+  }
 }
 
+const syncBuffer = serialize.sync()
 Connection.prototype.sync = function () {
-  // clear out any pending data in the writer
-  this.writer.flush(0)
-
-  this.writer.add(emptyBuffer)
   this._ending = true
-  this._send(0x53)
+  this._send(flushBuffer)
+  this._send(syncBuffer)
 }
 
-const END_BUFFER = Buffer.from([0x58, 0x00, 0x00, 0x00, 0x04])
+const endBuffer = serialize.end()
 
 Connection.prototype.end = function () {
   // 0x58 = 'X'
-  this.writer.add(emptyBuffer)
   this._ending = true
-  if (!this.stream.writable) {
+  if (!this._connecting || !this.stream.writable) {
     this.stream.end()
     return
   }
-  return this.stream.write(END_BUFFER, () => {
+  return this.stream.write(endBuffer, () => {
     this.stream.end()
   })
 }
 
-Connection.prototype.close = function (msg, more) {
-  this.writer.addCString(msg.type + (msg.name || ''))
-  this._send(0x43, more)
+Connection.prototype.close = function (msg) {
+  this._send(serialize.close(msg))
 }
 
-Connection.prototype.describe = function (msg, more) {
-  this.writer.addCString(msg.type + (msg.name || ''))
-  this._send(0x44, more)
+Connection.prototype.describe = function (msg) {
+  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)
-}
-
-var Message = function (name, length) {
-  this.name = name
-  this.length = length
-}
-
-Connection.prototype.parseMessage = function (buffer) {
-  this.offset = 0
-  var length = buffer.length + 4
-  switch (this._reader.header) {
-    case 0x52: // R
-      return this.parseR(buffer, length)
-
-    case 0x53: // S
-      return this.parseS(buffer, length)
-
-    case 0x4b: // K
-      return this.parseK(buffer, length)
-
-    case 0x43: // C
-      return this.parseC(buffer, length)
-
-    case 0x5a: // Z
-      return this.parseZ(buffer, length)
-
-    case 0x54: // T
-      return this.parseT(buffer, length)
-
-    case 0x44: // D
-      return this.parseD(buffer, length)
-
-    case 0x45: // E
-      return this.parseE(buffer, length)
-
-    case 0x4e: // N
-      return this.parseN(buffer, length)
-
-    case 0x31: // 1
-      return new Message('parseComplete', length)
-
-    case 0x32: // 2
-      return new Message('bindComplete', length)
-
-    case 0x33: // 3
-      return new Message('closeComplete', length)
-
-    case 0x41: // A
-      return this.parseA(buffer, length)
-
-    case 0x6e: // n
-      return new Message('noData', length)
-
-    case 0x49: // I
-      return new Message('emptyQuery', length)
-
-    case 0x73: // s
-      return new Message('portalSuspended', length)
-
-    case 0x47: // G
-      return this.parseG(buffer, length)
-
-    case 0x48: // H
-      return this.parseH(buffer, length)
-
-    case 0x57: // W
-      return new Message('replicationStart', length)
-
-    case 0x63: // c
-      return new Message('copyDone', length)
-
-    case 0x64: // d
-      return this.parsed(buffer, length)
-  }
-}
-
-Connection.prototype.parseR = function (buffer, length) {
-  var code = this.parseInt32(buffer)
-
-  var msg = new Message('authenticationOk', length)
-
-  switch (code) {
-    case 0: // AuthenticationOk
-      return msg
-    case 3: // AuthenticationCleartextPassword
-      if (msg.length === 8) {
-        msg.name = 'authenticationCleartextPassword'
-        return msg
-      }
-      break
-    case 5: // AuthenticationMD5Password
-      if (msg.length === 12) {
-        msg.name = 'authenticationMD5Password'
-        msg.salt = Buffer.alloc(4)
-        buffer.copy(msg.salt, 0, this.offset, this.offset + 4)
-        this.offset += 4
-        return msg
-      }
-
-      break
-    case 10: // AuthenticationSASL
-      msg.name = 'authenticationSASL'
-      msg.mechanisms = []
-      do {
-        var mechanism = this.parseCString(buffer)
-
-        if (mechanism) {
-          msg.mechanisms.push(mechanism)
-        }
-      } while (mechanism)
-
-      return msg
-    case 11: // AuthenticationSASLContinue
-      msg.name = 'authenticationSASLContinue'
-      msg.data = this.readString(buffer, length - 4)
-
-      return msg
-    case 12: // AuthenticationSASLFinal
-      msg.name = 'authenticationSASLFinal'
-      msg.data = this.readString(buffer, length - 4)
-
-      return msg
-  }
-
-  throw new Error('Unknown authenticationOk message type' + util.inspect(msg))
-}
-
-Connection.prototype.parseS = function (buffer, length) {
-  var msg = new Message('parameterStatus', length)
-  msg.parameterName = this.parseCString(buffer)
-  msg.parameterValue = this.parseCString(buffer)
-  return msg
-}
-
-Connection.prototype.parseK = function (buffer, length) {
-  var msg = new Message('backendKeyData', length)
-  msg.processID = this.parseInt32(buffer)
-  msg.secretKey = this.parseInt32(buffer)
-  return msg
-}
-
-Connection.prototype.parseC = function (buffer, length) {
-  var msg = new Message('commandComplete', length)
-  msg.text = this.parseCString(buffer)
-  return msg
-}
-
-Connection.prototype.parseZ = function (buffer, length) {
-  var msg = new Message('readyForQuery', length)
-  msg.name = 'readyForQuery'
-  msg.status = this.readString(buffer, 1)
-  return msg
+  this._send(serialize.copyFail(msg))
 }
 
-var ROW_DESCRIPTION = 'rowDescription'
-Connection.prototype.parseT = function (buffer, length) {
-  var msg = new Message(ROW_DESCRIPTION, length)
-  msg.fieldCount = this.parseInt16(buffer)
-  var fields = []
-  for (var i = 0; i < msg.fieldCount; i++) {
-    fields.push(this.parseField(buffer))
-  }
-  msg.fields = fields
-  return msg
-}
-
-var Field = function () {
-  this.name = null
-  this.tableID = null
-  this.columnID = null
-  this.dataTypeID = null
-  this.dataTypeSize = null
-  this.dataTypeModifier = null
-  this.format = null
-}
-
-var FORMAT_TEXT = 'text'
-var FORMAT_BINARY = 'binary'
-Connection.prototype.parseField = function (buffer) {
-  var field = new Field()
-  field.name = this.parseCString(buffer)
-  field.tableID = this.parseInt32(buffer)
-  field.columnID = this.parseInt16(buffer)
-  field.dataTypeID = this.parseInt32(buffer)
-  field.dataTypeSize = this.parseInt16(buffer)
-  field.dataTypeModifier = this.parseInt32(buffer)
-  if (this.parseInt16(buffer) === TEXT_MODE) {
-    this._mode = TEXT_MODE
-    field.format = FORMAT_TEXT
-  } else {
-    this._mode = BINARY_MODE
-    field.format = FORMAT_BINARY
-  }
-  return field
-}
-
-var DATA_ROW = 'dataRow'
-var DataRowMessage = function (length, fieldCount) {
-  this.name = DATA_ROW
-  this.length = length
-  this.fieldCount = fieldCount
-  this.fields = []
-}
-
-// extremely hot-path code
-Connection.prototype.parseD = function (buffer, length) {
-  var fieldCount = this.parseInt16(buffer)
-  var msg = new DataRowMessage(length, fieldCount)
-  for (var i = 0; i < fieldCount; i++) {
-    msg.fields.push(this._readValue(buffer))
-  }
-  return msg
-}
-
-// extremely hot-path code
-Connection.prototype._readValue = function (buffer) {
-  var length = this.parseInt32(buffer)
-  if (length === -1) return null
-  if (this._mode === TEXT_MODE) {
-    return this.readString(buffer, length)
-  }
-  return this.readBytes(buffer, length)
-}
-
-// parses error
-Connection.prototype.parseE = function (buffer, length, isNotice) {
-  var fields = {}
-  var fieldType = this.readString(buffer, 1)
-  while (fieldType !== '\0') {
-    fields[fieldType] = this.parseCString(buffer)
-    fieldType = this.readString(buffer, 1)
-  }
-
-  // the msg is an Error instance
-  var msg = isNotice ? { message: fields.M } : new Error(fields.M)
-
-  // for compatibility with Message
-  msg.name = isNotice ? 'notice' : 'error'
-  msg.length = length
-
-  msg.severity = fields.S
-  msg.code = fields.C
-  msg.detail = fields.D
-  msg.hint = fields.H
-  msg.position = fields.P
-  msg.internalPosition = fields.p
-  msg.internalQuery = fields.q
-  msg.where = fields.W
-  msg.schema = fields.s
-  msg.table = fields.t
-  msg.column = fields.c
-  msg.dataType = fields.d
-  msg.constraint = fields.n
-  msg.file = fields.F
-  msg.line = fields.L
-  msg.routine = fields.R
-  return msg
-}
-
-// same thing, different name
-Connection.prototype.parseN = function (buffer, length) {
-  var msg = this.parseE(buffer, length, true)
-  msg.name = 'notice'
-  return msg
-}
-
-Connection.prototype.parseA = function (buffer, length) {
-  var msg = new Message('notification', length)
-  msg.processId = this.parseInt32(buffer)
-  msg.channel = this.parseCString(buffer)
-  msg.payload = this.parseCString(buffer)
-  return msg
-}
-
-Connection.prototype.parseG = function (buffer, length) {
-  var msg = new Message('copyInResponse', length)
-  return this.parseGH(buffer, msg)
-}
-
-Connection.prototype.parseH = function (buffer, length) {
-  var msg = new Message('copyOutResponse', length)
-  return this.parseGH(buffer, msg)
-}
-
-Connection.prototype.parseGH = function (buffer, msg) {
-  var isBinary = buffer[this.offset] !== 0
-  this.offset++
-  msg.binary = isBinary
-  var columnCount = this.parseInt16(buffer)
-  msg.columnTypes = []
-  for (var i = 0; i < columnCount; i++) {
-    msg.columnTypes.push(this.parseInt16(buffer))
-  }
-  return msg
-}
-
-Connection.prototype.parsed = function (buffer, length) {
-  var msg = new Message('copyData', length)
-  msg.chunk = this.readBytes(buffer, msg.length - 4)
-  return msg
-}
-
-Connection.prototype.parseInt32 = function (buffer) {
-  var value = buffer.readInt32BE(this.offset)
-  this.offset += 4
-  return value
-}
-
-Connection.prototype.parseInt16 = function (buffer) {
-  var value = buffer.readInt16BE(this.offset)
-  this.offset += 2
-  return value
-}
-
-Connection.prototype.readString = function (buffer, length) {
-  return buffer.toString(this.encoding, this.offset, (this.offset += length))
-}
-
-Connection.prototype.readBytes = function (buffer, length) {
-  return buffer.slice(this.offset, (this.offset += length))
-}
-
-Connection.prototype.parseCString = function (buffer) {
-  var start = this.offset
-  var end = buffer.indexOf(0, start)
-  this.offset = end + 1
-  return buffer.toString(this.encoding, start, end)
-}
-// end parsing methods
 module.exports = Connection