Downgrade to prettier@1.x to support node@8.x

Author: brianc

.prettierrc.json

@@ -23,6 +23,13 @@
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^3.1.2",
     "lerna": "^3.19.0",
-    "prettier": "^2.0.4"
+    "prettier": "1.19.1"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 120,
+    "arrowParens": "always",
+    "trailingComma": "es5",
+    "singleQuote": true
   }
 }

package.json

@@ -25,18 +25,18 @@ function Cursor(text, values, config) {
 
 util.inherits(Cursor, EventEmitter)
 
-Cursor.prototype._ifNoData = function () {
+Cursor.prototype._ifNoData = function() {
   this.state = 'idle'
   this._shiftQueue()
 }
 
-Cursor.prototype._rowDescription = function () {
+Cursor.prototype._rowDescription = function() {
   if (this.connection) {
     this.connection.removeListener('noData', this._ifNoData)
   }
 }
 
-Cursor.prototype.submit = function (connection) {
+Cursor.prototype.submit = function(connection) {
   this.connection = connection
   this._portal = 'C_' + nextUniqueID++
 
@@ -75,13 +75,13 @@ Cursor.prototype.submit = function (connection) {
   con.once('rowDescription', this._rowDescription)
 }
 
-Cursor.prototype._shiftQueue = function () {
+Cursor.prototype._shiftQueue = function() {
   if (this._queue.length) {
     this._getRows.apply(this, this._queue.shift())
   }
 }
 
-Cursor.prototype._closePortal = function () {
+Cursor.prototype._closePortal = function() {
   // because we opened a named portal to stream results
   // we need to close the same named portal.  Leaving a named portal
   // open can lock tables for modification if inside a transaction.
@@ -90,19 +90,19 @@ Cursor.prototype._closePortal = function () {
   this.connection.sync()
 }
 
-Cursor.prototype.handleRowDescription = function (msg) {
+Cursor.prototype.handleRowDescription = function(msg) {
   this._result.addFields(msg.fields)
   this.state = 'idle'
   this._shiftQueue()
 }
 
-Cursor.prototype.handleDataRow = function (msg) {
+Cursor.prototype.handleDataRow = function(msg) {
   const row = this._result.parseRow(msg.fields)
   this.emit('row', row, this._result)
   this._rows.push(row)
 }
 
-Cursor.prototype._sendRows = function () {
+Cursor.prototype._sendRows = function() {
   this.state = 'idle'
   setImmediate(() => {
     const cb = this._cb
@@ -118,26 +118,26 @@ Cursor.prototype._sendRows = function () {
   })
 }
 
-Cursor.prototype.handleCommandComplete = function (msg) {
+Cursor.prototype.handleCommandComplete = function(msg) {
   this._result.addCommandComplete(msg)
   this._closePortal()
 }
 
-Cursor.prototype.handlePortalSuspended = function () {
+Cursor.prototype.handlePortalSuspended = function() {
   this._sendRows()
 }
 
-Cursor.prototype.handleReadyForQuery = function () {
+Cursor.prototype.handleReadyForQuery = function() {
   this._sendRows()
   this.state = 'done'
   this.emit('end', this._result)
 }
 
-Cursor.prototype.handleEmptyQuery = function () {
+Cursor.prototype.handleEmptyQuery = function() {
   this.connection.sync()
 }
 
-Cursor.prototype.handleError = function (msg) {
+Cursor.prototype.handleError = function(msg) {
   this.connection.removeListener('noData', this._ifNoData)
   this.connection.removeListener('rowDescription', this._rowDescription)
   this.state = 'error'
@@ -159,7 +159,7 @@ Cursor.prototype.handleError = function (msg) {
   this.connection.sync()
 }
 
-Cursor.prototype._getRows = function (rows, cb) {
+Cursor.prototype._getRows = function(rows, cb) {
   this.state = 'busy'
   this._cb = cb
   this._rows = []
@@ -173,15 +173,15 @@ Cursor.prototype._getRows = function (rows, cb) {
 
 // users really shouldn't be calling 'end' here and terminating a connection to postgres
 // via the low level connection.end api
-Cursor.prototype.end = util.deprecate(function (cb) {
+Cursor.prototype.end = util.deprecate(function(cb) {
   if (this.state !== 'initialized') {
     this.connection.sync()
   }
   this.connection.once('end', cb)
   this.connection.end()
 }, 'Cursor.end is deprecated. Call end on the client itself to end a connection to the database.')
 
-Cursor.prototype.close = function (cb) {
+Cursor.prototype.close = function(cb) {
   if (!this.connection || this.state === 'done') {
     if (cb) {
       return setImmediate(cb)
@@ -192,13 +192,13 @@ Cursor.prototype.close = function (cb) {
   this._closePortal()
   this.state = 'done'
   if (cb) {
-    this.connection.once('readyForQuery', function () {
+    this.connection.once('readyForQuery', function() {
       cb()
     })
   }
 }
 
-Cursor.prototype.read = function (rows, cb) {
+Cursor.prototype.read = function(rows, cb) {
   if (this.state === 'idle') {
     return this._getRows(rows, cb)
   }

packages/pg-cursor/index.js

@@ -3,51 +3,51 @@ const Cursor = require('../')
 const pg = require('pg')
 
 const text = 'SELECT generate_series as num FROM generate_series(0, 50)'
-describe('close', function () {
-  beforeEach(function (done) {
+describe('close', function() {
+  beforeEach(function(done) {
     const client = (this.client = new pg.Client())
     client.connect(done)
   })
 
-  this.afterEach(function (done) {
+  this.afterEach(function(done) {
     this.client.end(done)
   })
 
-  it('can close a finished cursor without a callback', function (done) {
+  it('can close a finished cursor without a callback', function(done) {
     const cursor = new Cursor(text)
     this.client.query(cursor)
     this.client.query('SELECT NOW()', done)
-    cursor.read(100, function (err) {
+    cursor.read(100, function(err) {
       assert.ifError(err)
       cursor.close()
     })
   })
 
-  it('closes cursor early', function (done) {
+  it('closes cursor early', function(done) {
     const cursor = new Cursor(text)
     this.client.query(cursor)
     this.client.query('SELECT NOW()', done)
-    cursor.read(25, function (err) {
+    cursor.read(25, function(err) {
       assert.ifError(err)
       cursor.close()
     })
   })
 
-  it('works with callback style', function (done) {
+  it('works with callback style', function(done) {
     const cursor = new Cursor(text)
     const client = this.client
     client.query(cursor)
-    cursor.read(25, function (err, rows) {
+    cursor.read(25, function(err, rows) {
       assert.ifError(err)
       assert.strictEqual(rows.length, 25)
-      cursor.close(function (err) {
+      cursor.close(function(err) {
         assert.ifError(err)
         client.query('SELECT NOW()', done)
       })
     })
   })
 
-  it('is a no-op to "close" the cursor before submitting it', function (done) {
+  it('is a no-op to "close" the cursor before submitting it', function(done) {
     const cursor = new Cursor(text)
     cursor.close(done)
   })

packages/pg-cursor/test/close.js

@@ -5,14 +5,14 @@ const pg = require('pg')
 
 const text = 'SELECT generate_series as num FROM generate_series(0, 4)'
 
-describe('error handling', function () {
-  it('can continue after error', function (done) {
+describe('error handling', function() {
+  it('can continue after error', function(done) {
     const client = new pg.Client()
     client.connect()
     const cursor = client.query(new Cursor('asdfdffsdf'))
-    cursor.read(1, function (err) {
+    cursor.read(1, function(err) {
       assert(err)
-      client.query('SELECT NOW()', function (err) {
+      client.query('SELECT NOW()', function(err) {
         assert.ifError(err)
         client.end()
         done()
@@ -27,11 +27,11 @@ describe('read callback does not fire sync', () => {
     client.connect()
     const cursor = client.query(new Cursor('asdfdffsdf'))
     let after = false
-    cursor.read(1, function (err) {
+    cursor.read(1, function(err) {
       assert(err, 'error should be returned')
       assert.strictEqual(after, true, 'should not call read sync')
       after = false
-      cursor.read(1, function (err) {
+      cursor.read(1, function(err) {
         assert(err, 'error should be returned')
         assert.strictEqual(after, true, 'should not call read sync')
         client.end()
@@ -47,13 +47,13 @@ describe('read callback does not fire sync', () => {
     client.connect()
     const cursor = client.query(new Cursor('SELECT NOW()'))
     let after = false
-    cursor.read(1, function (err) {
+    cursor.read(1, function(err) {
       assert(!err)
       assert.strictEqual(after, true, 'should not call read sync')
-      cursor.read(1, function (err) {
+      cursor.read(1, function(err) {
         assert(!err)
         after = false
-        cursor.read(1, function (err) {
+        cursor.read(1, function(err) {
           assert(!err)
           assert.strictEqual(after, true, 'should not call read sync')
           client.end()
@@ -66,16 +66,16 @@ describe('read callback does not fire sync', () => {
   })
 })
 
-describe('proper cleanup', function () {
-  it('can issue multiple cursors on one client', function (done) {
+describe('proper cleanup', function() {
+  it('can issue multiple cursors on one client', function(done) {
     const client = new pg.Client()
     client.connect()
     const cursor1 = client.query(new Cursor(text))
-    cursor1.read(8, function (err, rows) {
+    cursor1.read(8, function(err, rows) {
       assert.ifError(err)
       assert.strictEqual(rows.length, 5)
       const cursor2 = client.query(new Cursor(text))
-      cursor2.read(8, function (err, rows) {
+      cursor2.read(8, function(err, rows) {
         assert.ifError(err)
         assert.strictEqual(rows.length, 5)
         client.end()