chore: use ES6 classes

This improves readability and may allow V8 to optimize better.

Author: cesco69

packages/pg-native/lib/copy-stream.js

@@ -2,114 +2,115 @@ const Duplex = require('stream').Duplex
 const Writable = require('stream').Writable
 const util = require('util')
 
-const CopyStream = (module.exports = function (pq, options) {
-  Duplex.call(this, options)
-  this.pq = pq
-  this._reading = false
-})
 
-util.inherits(CopyStream, Duplex)
-
-// writer methods
-CopyStream.prototype._write = function (chunk, encoding, cb) {
-  const result = this.pq.putCopyData(chunk)
-
-  // sent successfully
-  if (result === 1) return cb()
+class CopyStream extends Duplex {
+  constructor(pq, options) {
+    super(options);
+    this.pq = pq;
+    this._reading = false;
+  }
 
-  // error
-  if (result === -1) return cb(new Error(this.pq.errorMessage()))
 
-  // command would block. wait for writable and call again.
-  const self = this
-  this.pq.writable(function () {
-    self._write(chunk, encoding, cb)
-  })
-}
+  // writer methods
+  _write(chunk, encoding, cb) {
+    const result = this.pq.putCopyData(chunk)
 
-CopyStream.prototype.end = function () {
-  const args = Array.prototype.slice.call(arguments, 0)
-  const self = this
+    // sent successfully
+    if (result === 1) return cb()
 
-  const callback = args.pop()
+    // error
+    if (result === -1) return cb(new Error(this.pq.errorMessage()))
 
-  if (args.length) {
-    this.write(args[0])
-  }
-  const result = this.pq.putCopyEnd()
-
-  // sent successfully
-  if (result === 1) {
-    // consume our results and then call 'end' on the
-    // "parent" writable class so we can emit 'finish' and
-    // all that jazz
-    return consumeResults(this.pq, function (err, res) {
-      Writable.prototype.end.call(self)
-
-      // handle possible passing of callback to end method
-      if (callback) {
-        callback(err)
-      }
+    // command would block. wait for writable and call again.
+    const self = this
+    this.pq.writable(function () {
+      self._write(chunk, encoding, cb)
     })
   }
 
-  // error
-  if (result === -1) {
-    const err = new Error(this.pq.errorMessage())
-    return this.emit('error', err)
-  }
+  end() {
+    const args = Array.prototype.slice.call(arguments, 0)
+    const self = this
 
-  // command would block. wait for writable and call end again
-  // don't pass any buffers to end on the second call because
-  // we already sent them to possible this.write the first time
-  // we called end
-  return this.pq.writable(function () {
-    return self.end.apply(self, callback)
-  })
-}
+    const callback = args.pop()
+
+    if (args.length) {
+      this.write(args[0])
+    }
+    const result = this.pq.putCopyEnd()
+
+    // sent successfully
+    if (result === 1) {
+      // consume our results and then call 'end' on the
+      // "parent" writable class so we can emit 'finish' and
+      // all that jazz
+      return consumeResults(this.pq, function (err, res) {
+        Writable.prototype.end.call(self)
+
+        // handle possible passing of callback to end method
+        if (callback) {
+          callback(err)
+        }
+      })
+    }
+
+    // error
+    if (result === -1) {
+      const err = new Error(this.pq.errorMessage())
+      return this.emit('error', err)
+    }
 
-// reader methods
-CopyStream.prototype._consumeBuffer = function (cb) {
-  const result = this.pq.getCopyData(true)
-  if (result instanceof Buffer) {
-    return setImmediate(function () {
-      cb(null, result)
+    // command would block. wait for writable and call end again
+    // don't pass any buffers to end on the second call because
+    // we already sent them to possible this.write the first time
+    // we called end
+    return this.pq.writable(function () {
+      return self.end.apply(self, callback)
     })
   }
-  if (result === -1) {
-    // end of stream
-    return cb(null, null)
+
+  // reader methods
+  _consumeBuffer(cb) {
+    const result = this.pq.getCopyData(true)
+    if (result instanceof Buffer) {
+      return setImmediate(function () {
+        cb(null, result)
+      })
+    }
+    if (result === -1) {
+      // end of stream
+      return cb(null, null)
+    }
+    if (result === 0) {
+      const self = this
+      this.pq.once('readable', function () {
+        self.pq.stopReader()
+        self.pq.consumeInput()
+        self._consumeBuffer(cb)
+      })
+      return this.pq.startReader()
+    }
+    cb(new Error('Unrecognized read status: ' + result))
   }
-  if (result === 0) {
+
+  _read(size) {
+    if (this._reading) return
+    this._reading = true
+    // console.log('read begin');
     const self = this
-    this.pq.once('readable', function () {
-      self.pq.stopReader()
-      self.pq.consumeInput()
-      self._consumeBuffer(cb)
+    this._consumeBuffer(function (err, buffer) {
+      self._reading = false
+      if (err) {
+        return self.emit('error', err)
+      }
+      if (buffer === false) {
+        // nothing to read for now, return
+        return
+      }
+      self.push(buffer)
     })
-    return this.pq.startReader()
   }
-  cb(new Error('Unrecognized read status: ' + result))
 }
-
-CopyStream.prototype._read = function (size) {
-  if (this._reading) return
-  this._reading = true
-  // console.log('read begin');
-  const self = this
-  this._consumeBuffer(function (err, buffer) {
-    self._reading = false
-    if (err) {
-      return self.emit('error', err)
-    }
-    if (buffer === false) {
-      // nothing to read for now, return
-      return
-    }
-    self.push(buffer)
-  })
-}
-
 const consumeResults = function (pq, cb) {
   const cleanup = function () {
     pq.removeListener('readable', onReadable)