Remove deprecated methods

Author: brianc

Makefile

@@ -17,7 +17,7 @@ help:
 
 test: test-unit
 
-test-all: jshint test-missing-native test-unit test-integration test-native test-binary
+test-all: jshint test-missing-native test-unit test-integration test-native
 
 
 update-npm:

lib/index.js

@@ -15,7 +15,6 @@ var ConnectionParameters = require('./connection-parameters');
 var poolFactory = require('./pool-factory');
 
 var PG = function(clientConstructor) {
-  EventEmitter.call(this);
   this.defaults = defaults;
   this.Client = clientConstructor;
   this.Query = this.Client.Query;
@@ -25,74 +24,6 @@ var PG = function(clientConstructor) {
   this.types = require('pg-types');
 };
 
-util.inherits(PG, EventEmitter);
-
-PG.prototype.end = util.deprecate(function() {
-  var self = this;
-  var keys = Object.keys(this._pools);
-  var count = keys.length;
-  if(count === 0) {
-    self.emit('end');
-  } else {
-    keys.forEach(function(key) {
-      var pool = self._pools[key];
-      delete self._pools[key];
-      pool.pool.drain(function() {
-        pool.pool.destroyAllNow(function() {
-          count--;
-          if(count === 0) {
-            self.emit('end');
-          }
-        });
-      });
-    });
-  }
-},
-'pg.end() is deprecated - please construct pools directly via new pg.Pool()');
-
-PG.prototype.connect = util.deprecate(function(config, callback) {
-  if(typeof config == "function") {
-    callback = config;
-    config = null;
-  }
-  if (typeof config == 'string') {
-    config = new ConnectionParameters(config);
-  }
-
-  config = config || {};
-
-  //for backwards compatibility
-  config.max = config.max || config.poolSize || defaults.poolSize;
-  config.idleTimeoutMillis = config.idleTimeoutMillis || config.poolIdleTimeout || defaults.poolIdleTimeout;
-  config.log = config.log || config.poolLog || defaults.poolLog;
-
-  var poolName = JSON.stringify(config);
-  this._pools[poolName] = this._pools[poolName] || new this.Pool(config);
-  var pool = this._pools[poolName];
-  if(!pool.listeners('error').length) {
-    //propagate errors up to pg object
-    pool.on('error', function(e) {
-      this.emit('error', e, e.client);
-    }.bind(this));
-  }
-  return pool.connect(callback);
-},
-'pg.connect() is deprecated - please construct pools directly via new pg.Pool()');
-
-// cancel the query running on the given client
-PG.prototype.cancel = util.deprecate(function(config, client, query) {
-  if(client.native) {
-    return client.cancel(query);
-  }
-  var c = config;
-  //allow for no config to be passed
-  if(typeof c === 'function') {
-    c = defaults;
-  }
-  var cancellingClient = new this.Client(c);
-  cancellingClient.cancel(client, query);
-}, 'pg.cancel() is deprecated - please create your own client instances to cancel queries');
-
 if(typeof process.env.NODE_PG_FORCE_NATIVE != 'undefined') {
   module.exports = new PG(require('./native'));
 } else {

lib/native/client.js

@@ -109,8 +109,6 @@ Client.prototype.connect = function(cb) {
   return result
 };
 
-const DeprecatedQuery = require('../utils').deprecateEventEmitter(NativeQuery)
-
 //send a query to the server
 //this method is highly overloaded to take
 //1) string query, optional array of parameters, optional function callback
@@ -132,10 +130,19 @@ Client.prototype.query = function(config, values, callback) {
     return config;
   }
 
-  var query = new DeprecatedQuery(config, values, callback);
+  var query = new NativeQuery(config, values, callback);
+  var result
+  if (!query.callback) {
+    let resolve, reject;
+    result = new Promise((res, rej) => {
+      resolve = res
+      reject = rej
+    })
+    query.callback = (err, res) => err ? reject(err) : resolve(res)
+  }
   this._queryQueue.push(query);
   this._pulseQueryQueue();
-  return query;
+  return result;
 };
 
 //disconnect from the backend server

lib/query.js

@@ -53,23 +53,6 @@ Query.prototype.requiresPreparation = function() {
   return this.values.length > 0;
 };
 
-Query.prototype.then = function(onSuccess, onFailure) {
-  return this._getPromise().then(onSuccess, onFailure);
-};
-
-Query.prototype.catch = function(callback) {
-  return this._getPromise().catch(callback);
-};
-
-Query.prototype._getPromise = function() {
-  if (this._promise) return this._promise;
-  this._promise = new Promise(function(resolve, reject) {
-    this._once('end', resolve);
-    this._once('error', reject);
-  }.bind(this));
-  return this._promise;
-};
-
 //associates row metadata from the supplied
 //message with this query object
 //metadata used when parsing row results

lib/utils.js

@@ -138,29 +138,11 @@ function normalizeQueryConfig (config, values, callback) {
   return config;
 }
 
-const queryEventEmitterOverloadDeprecationMessage = `
-Using the automatically created return value from client.query as an event emitter is deprecated.
-Use either the callback or promise interface.
-`
-
-const deprecateEventEmitter = function(Emitter) {
-  const Result = function () {
-    Emitter.apply(this, arguments)
-  }
-  util.inherits(Result, Emitter)
-  Result.prototype._on = Result.prototype.on
-  Result.prototype._once = Result.prototype.once
-  Result.prototype.on = util.deprecate(Result.prototype.on, queryEventEmitterOverloadDeprecationMessage)
-  Result.prototype.once = util.deprecate(Result.prototype.once, queryEventEmitterOverloadDeprecationMessage)
-  return Result
-}
-
 module.exports = {
   prepareValue: function prepareValueWrapper (value) {
     //this ensures that extra arguments do not get passed into prepareValue
     //by accident, eg: from calling values.map(utils.prepareValue)
     return prepareValue(value);
   },
   normalizeQueryConfig: normalizeQueryConfig,
-  deprecateEventEmitter: deprecateEventEmitter,
 };

test/integration/client/array-tests.js

@@ -3,7 +3,8 @@ var pg = helper.pg;
 
 var suite = new helper.Suite()
 
-pg.connect(assert.calls(function(err, client, release) {
+const pool = new pg.Pool()
+pool.connect(assert.calls(function(err, client, release) {
   assert.isNull(err);
 
   suite.test('nulls', function(done) {
@@ -33,7 +34,7 @@ pg.connect(assert.calls(function(err, client, release) {
   suite.test('cleanup', () => release())
 }));
 
-pg.connect(assert.calls(function (err, client, release) {
+pool.connect(assert.calls(function (err, client, release) {
   assert.isNull(err);
   client.query("CREATE TEMP TABLE why(names text[], numbors integer[])");
   client.query(new pg.Query('INSERT INTO why(names, numbors) VALUES(\'{"aaron", "brian","a b c" }\', \'{1, 2, 3}\')')).on('error', console.log);
@@ -166,8 +167,7 @@ pg.connect(assert.calls(function (err, client, release) {
       assert.equal(names[2][0], 3);
       assert.equal(names[2][1], 100);
       release();
-      pg.end();
-      done();
+      pool.end(done)
     }))
   })
 

test/integration/client/cancel-query-tests.js

@@ -1,6 +1,7 @@
 var helper = require('./test-helper');
+const pool = new helper.pg.Pool()
 
-helper.pg.connect(helper.config, assert.success(function(client, done) {
+pool.connect(assert.success(function(client, done) {
   var types = require('pg-types');
   //1231 = numericOID
   types.setTypeParser(1700, function(){
@@ -14,7 +15,7 @@ helper.pg.connect(helper.config, assert.success(function(client, done) {
   client.query('INSERT INTO bignumz(id) VALUES ($1)', [bignum]);
   client.query('SELECT * FROM bignumz', assert.success(function(result) {
     assert.equal(result.rows[0].id, 'yes')
-    helper.pg.end();
     done();
+    pool.end()
   }))
 }));

test/integration/client/huge-numeric-tests.js

@@ -1,7 +1,8 @@
 var helper = require('./test-helper');
 var assert = require('assert');
 
-helper.pg.connect(assert.success(function (client, done) {
+const pool = new helper.pg.Pool()
+pool.connect(assert.success(function (client, done) {
   helper.versionGTE(client, '9.2.0', assert.success(function (jsonSupported) {
     if (!jsonSupported) {
       console.log('skip json test on older versions of postgres');
@@ -20,7 +21,7 @@ helper.pg.connect(assert.success(function (client, done) {
       assert.strictEqual(row.alive, value.alive);
       assert.equal(JSON.stringify(row.now), JSON.stringify(value.now));
       done();
-      helper.pg.end();
+      pool.end()
     }));
   }));
 }));

test/integration/client/json-type-parsing-tests.js

@@ -1,23 +1,27 @@
-var helper = require(__dirname + '/test-helper');
+var helper = require("./test-helper");
 var pg = helper.pg;
-const suite = new helper.Suite()
+const suite = new helper.Suite();
+const pool = new pg.Pool();
 
-suite.test('can access results when no rows are returned', function() {
-  var checkResult = function(result) {
-    assert(result.fields, 'should have fields definition');
+suite.test("can access results when no rows are returned", function (done) {
+  var checkResult = function (result) {
+    assert(result.fields, "should have fields definition");
     assert.equal(result.fields.length, 1);
-    assert.equal(result.fields[0].name, 'val');
+    assert.equal(result.fields[0].name, "val");
     assert.equal(result.fields[0].dataTypeID, 25);
-    pg.end();
   };
 
-  pg.connect(assert.success(function(client, done) {
-    const q = new pg.Query('select $1::text as val limit 0', ['hi'])
-    var query = client.query(q, assert.success(function(result) {
-      checkResult(result);
-      done();
-    }));
+  pool.connect(
+    assert.success(function (client, release) {
+      const q = new pg.Query("select $1::text as val limit 0", ["hi"]);
+      var query = client.query(q, assert.success(function (result) {
+        checkResult(result);
+        release();
+        pool.end(done);
+      })
+      );
 
-    assert.emits(query, 'end', checkResult);
-  }));
+      assert.emits(query, "end", checkResult);
+    })
+  );
 });

test/integration/client/no-row-result-tests.js

@@ -3,9 +3,10 @@ var helper = require('../test-helper');
 var pg = helper.pg;
 const suite = new helper.Suite()
 
+const pool = new pg.Pool(helper.config)
 suite.test('ability to turn on and off parser', function() {
   if(helper.args.binary) return false;
-  pg.connect(helper.config, assert.success(function(client, done) {
+  pool.connect(assert.success(function(client, done) {
     pg.defaults.parseInt8 = true;
     client.query('CREATE TEMP TABLE asdf(id SERIAL PRIMARY KEY)');
     client.query('SELECT COUNT(*) as "count", \'{1,2,3}\'::bigint[] as array FROM asdf', assert.success(function(res) {
@@ -20,7 +21,7 @@ suite.test('ability to turn on and off parser', function() {
         assert.strictEqual('1', res.rows[0].array[0]);
         assert.strictEqual('2', res.rows[0].array[1]);
         assert.strictEqual('3', res.rows[0].array[2]);
-        pg.end();
+        pool.end();
       }));
     }));
   }));

test/integration/client/parse-int-8-tests.js

@@ -6,22 +6,27 @@ process.on('unhandledRejection', function(e) {
   process.exit(1)
 })
 
-pg.connect(helper.config, assert.success(function(client, done) {
-  client.query('SELECT $1::text as name', ['foo'])
-    .then(function(result) {
-      assert.equal(result.rows[0].name, 'foo')
-      return client
-    })
-    .then(function(client) {
-      client.query('ALKJSDF')
-        .catch(function(e) {
-          assert(e instanceof Error)
-          client.query('SELECT 1 as num')
-            .then(function (result) {
-              assert.equal(result.rows[0].num, 1)
-              done()
-              pg.end()
-            })
-        })
-    })
-}))
+const pool = new pg.Pool()
+const suite = new helper.Suite()
+
+suite.test('promise API', (cb) => {
+  pool.connect().then((client) => {
+    client.query('SELECT $1::text as name', ['foo'])
+      .then(function (result) {
+        assert.equal(result.rows[0].name, 'foo')
+        return client
+      })
+      .then(function (client) {
+        client.query('ALKJSDF')
+          .catch(function (e) {
+            assert(e instanceof Error)
+            client.query('SELECT 1 as num')
+              .then(function (result) {
+                assert.equal(result.rows[0].num, 1)
+                client.release()
+                pool.end(cb)
+              })
+          })
+      })
+  })
+})