ES6 refactor: dialects / PostgreSQL (#6048)

* ES6 refactor of hstore.js

const, export

* ES6 refactor of PostgresDialect

const, classes, property shorthands, export default

* ES6 refactor of postgres ConnectionManager

classes, let, const, arrow functions, for of, export default

* Make postgres Query an ES6 class

* ES6 refactor of postgres Query

let, const, arrow functions, property shorthands, export default

* ES6 refactor of postgres QueryGenerator

let, const, arrow functions, template strings where it was easy to implement

* ES6 refactor of postgres range.js

let, const, arrow functions, export

lib/dialects/postgres/connection-manager.js

 'use strict';
 
-var AbstractConnectionManager = require('../abstract/connection-manager')
-  , ConnectionManager
-  , Utils = require('../../utils')
-  , Promise = require('../../promise')
-  , sequelizeErrors = require('../../errors')
-  , semver = require('semver')
-  , dataTypes = require('../../data-types')
-  , moment = require('moment-timezone');
-
-ConnectionManager = function(dialect, sequelize) {
-  AbstractConnectionManager.call(this, dialect, sequelize);
+const AbstractConnectionManager = require('../abstract/connection-manager');
+const Utils = require('../../utils');
+const Promise = require('../../promise');
+const sequelizeErrors = require('../../errors');
+const semver = require('semver');
+const dataTypes = require('../../data-types');
+const moment = require('moment-timezone');
+
+class ConnectionManager extends AbstractConnectionManager {
+  constructor(dialect, sequelize) {
+    super(dialect, sequelize);
 
     this.sequelize = sequelize;
     this.sequelize.config.port = this.sequelize.config.port || 5432;
     try {
-    var pgLib;
+      let pgLib;
       if (sequelize.config.dialectModulePath) {
         pgLib = require(sequelize.config.dialectModulePath);
       } else {
@@ -30,39 +30,32 @@ ConnectionManager = function(dialect, sequelize) {
     }
 
     this.refreshTypeParser(dataTypes.postgres);
-};
-
-Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+  }
 
-// Expose this as a method so that the parsing may be updated when the user has added additional, custom types
-ConnectionManager.prototype.$refreshTypeParser = function (dataType) {
-  var self = this;
+  // Expose this as a method so that the parsing may be updated when the user has added additional, custom types
+  $refreshTypeParser(dataType) {
 
     if (dataType.types.postgres.oids) {
-    dataType.types.postgres.oids.forEach(function (oid) {
-      self.lib.types.setTypeParser(oid, function (value) {
-        return dataType.parse(value, oid, self.lib.types.getTypeParser);
-      });
-    });
+      for (const oid of dataType.types.postgres.oids) {
+        this.lib.types.setTypeParser(oid, value => dataType.parse(value, oid, this.lib.types.getTypeParser));
+      }
     }
 
     if (dataType.types.postgres.array_oids) {
-    dataType.types.postgres.array_oids.forEach(function (oid) {
-      self.lib.types.setTypeParser(oid, function (value) {
-        return self.lib.types.arrayParser.create(value, function (value) {
-          return dataType.parse(value, oid, self.lib.types.getTypeParser);
-        }).parse();
-      });
-    });
+      for (const oid of dataType.types.postgres.array_oids) {
+        this.lib.types.setTypeParser(oid, value =>
+          this.lib.types.arrayParser.create(value, value =>
+            dataType.parse(value, oid, this.lib.types.getTypeParser)
+          ).parse()
+        );
+      }
+    }
   }
-};
 
-ConnectionManager.prototype.connect = function(config) {
-  var self = this
-    , connectionConfig = {};
+  connect(config) {
 
     config.user = config.username;
-  connectionConfig = Utils._.pick(config, [
+    const connectionConfig = Utils._.pick(config, [
       'user', 'password', 'host', 'database', 'port'
     ]);
 
@@ -86,11 +79,11 @@ ConnectionManager.prototype.connect = function(config) {
       ]));
     }
 
-  return new Promise(function (resolve, reject) {
-    var connection = new self.lib.Client(connectionConfig)
-      , responded = false;
+    return new Promise((resolve, reject) => {
+      const connection = new this.lib.Client(connectionConfig);
+      let responded = false;
 
-    connection.connect(function(err) {
+      connection.connect(err => {
         if (err) {
           if (err.code) {
             switch (err.code) {
@@ -120,30 +113,30 @@ ConnectionManager.prototype.connect = function(config) {
       });
 
       // If we didn't ever hear from the client.connect() callback the connection timeout, node-postgres does not treat this as an error since no active query was ever emitted
-    connection.on('end', function () {
+      connection.on('end', () => {
         if (!responded) {
           reject(new sequelizeErrors.ConnectionTimedOutError(new Error('Connection timed out')));
         }
       });
 
       // Don't let a Postgres restart (or error) to take down the whole app
-    connection.on('error', function() {
+      connection.on('error', () => {
         connection._invalid = true;
       });
-  }).tap(function (connection) {
+    }).tap(connection => {
       // Disable escape characters in strings, see https://github.com/sequelize/sequelize/issues/3545
-    var query = '';
+      let query = '';
 
-    if (self.sequelize.options.databaseVersion !== 0 && semver.gte(self.sequelize.options.databaseVersion, '8.2.0')) {
+      if (this.sequelize.options.databaseVersion !== 0 && semver.gte(this.sequelize.options.databaseVersion, '8.2.0')) {
         query += 'SET standard_conforming_strings=on;';
       }
 
-    if (!self.sequelize.config.keepDefaultTimezone) {
-      var isZone = !!moment.tz.zone(self.sequelize.options.timezone);
+      if (!this.sequelize.config.keepDefaultTimezone) {
+        const isZone = !!moment.tz.zone(this.sequelize.options.timezone);
         if (isZone) {
-        query += 'SET client_min_messages TO warning; SET TIME ZONE \'' + self.sequelize.options.timezone + '\';';
+          query += 'SET client_min_messages TO warning; SET TIME ZONE \'' + this.sequelize.options.timezone + '\';';
         } else {
-        query += 'SET client_min_messages TO warning; SET TIME ZONE INTERVAL \'' + self.sequelize.options.timezone + '\' HOUR TO MINUTE;';
+          query += 'SET client_min_messages TO warning; SET TIME ZONE INTERVAL \'' + this.sequelize.options.timezone + '\' HOUR TO MINUTE;';
         }
       }
 
@@ -152,11 +145,11 @@ ConnectionManager.prototype.connect = function(config) {
         query += 'SELECT typname, oid, typarray FROM pg_type WHERE typtype = \'b\' AND typname IN (\'hstore\', \'geometry\', \'geography\')';
       }
 
-    return new Promise(function (resolve, reject) {
-      connection.query(query).on('error', function (err) {
-        reject(err);
-      }).on('row', function (row) {
-        var type;
+      return new Promise((resolve, reject) => {
+        connection.query(query)
+          .on('error', err => reject(err))
+          .on('row', row => {
+            let type;
             if (row.typname === 'geometry') {
               type = dataTypes.postgres.GEOMETRY;
             } else if (row.typname === 'hstore') {
@@ -168,22 +161,26 @@ ConnectionManager.prototype.connect = function(config) {
             type.types.postgres.oids.push(row.oid);
             type.types.postgres.array_oids.push(row.typarray);
 
-        self.$refreshTypeParser(type);
-      }).on('end', function () {
-        resolve();
+            this.$refreshTypeParser(type);
+          })
+          .on('end', () => resolve());
       });
     });
-  });
-};
-ConnectionManager.prototype.disconnect = function(connection) {
-  return new Promise(function (resolve, reject) {
+  }
+  disconnect(connection) {
+    return new Promise((resolve, reject) => {
       connection.end();
       resolve();
     });
-};
+  }
 
-ConnectionManager.prototype.validate = function(connection) {
+  validate(connection) {
     return connection._invalid === undefined;
-};
+  }
+}
+
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
 
 module.exports = ConnectionManager;
+module.exports.ConnectionManager = ConnectionManager;
+module.exports.default = ConnectionManager;

lib/dialects/postgres/hstore.js

 'use strict';
 
-var hstore = require('pg-hstore')({sanitize : true});
+const hstore = require('pg-hstore')({sanitize : true});
 
 function stringify (data) {
     if (data === null) return null;
     return hstore.stringify(data);
 }
+exports.stringify = stringify;
 
 function parse (value) {
     if (value === null) return null;
     return hstore.parse(value);
 }
-
-module.exports = {
-    stringify: stringify,
-    parse: parse
-};
+exports.parse = parse;

lib/dialects/postgres/index.js

 'use strict';
 
-var _ = require('lodash')
-  , Abstract = require('../abstract')
-  , ConnectionManager = require('./connection-manager')
-  , Query = require('./query')
-  , QueryGenerator = require('./query-generator')
-  , DataTypes = require('../../data-types').postgres;
+const _ = require('lodash');
+const AbstractDialect = require('../abstract');
+const ConnectionManager = require('./connection-manager');
+const Query = require('./query');
+const QueryGenerator = require('./query-generator');
+const DataTypes = require('../../data-types').postgres;
 
-var PostgresDialect = function(sequelize) {
+class PostgresDialect extends AbstractDialect {
+  constructor(sequelize) {
+    super();
     this.sequelize = sequelize;
     this.connectionManager = new ConnectionManager(this, sequelize);
     this.connectionManager.initPools();
@@ -15,11 +17,12 @@ var PostgresDialect = function(sequelize) {
     this.QueryGenerator = _.extend({}, QueryGenerator, {
       options: sequelize.options,
       _dialect: this,
-    sequelize: sequelize
+      sequelize
     });
-};
+  }
+}
 
-PostgresDialect.prototype.supports = _.merge(_.cloneDeep(Abstract.prototype.supports), {
+PostgresDialect.prototype.supports = _.merge(_.cloneDeep(AbstractDialect.prototype.supports), {
   'DEFAULT VALUES': true,
   'EXCEPTION': true,
   'ON DUPLICATE KEY': false,
@@ -59,3 +62,5 @@ PostgresDialect.prototype.TICK_CHAR_LEFT = PostgresDialect.prototype.TICK_CHAR;
 PostgresDialect.prototype.TICK_CHAR_RIGHT = PostgresDialect.prototype.TICK_CHAR;
 
 module.exports = PostgresDialect;
+module.exports.default = PostgresDialect;
+module.exports.PostgresDialect = PostgresDialect;

lib/dialects/postgres/range.js

 'use strict';
 
-var _ = require('lodash');
+const _ = require('lodash');
 
 function stringifyRangeBound (bound) {
   if (bound === null) {
@@ -39,44 +39,38 @@ function stringify (data) {
     data.inclusive = [true, false];
   }
 
-  _.each(data, function (value, index) {
+  _.each(data, (value, index) => {
     if (_.isObject(value)) {
       if (value.hasOwnProperty('inclusive')) data.inclusive[index] = !!value.inclusive;
       if (value.hasOwnProperty('value')) data[index] = value.value;
     }
   });
 
-  var lowerBound = stringifyRangeBound(data[0]);
-  var upperBound = stringifyRangeBound(data[1]);
+  const lowerBound = stringifyRangeBound(data[0]);
+  const upperBound = stringifyRangeBound(data[1]);
 
   return (data.inclusive[0] ? '[' : '(') + lowerBound + ',' + upperBound + (data.inclusive[1] ? ']' : ')');
 }
+exports.stringify = stringify;
 
 function parse (value, parser) {
   if (value === null) return null;
   if (value === 'empty') {
-    var empty = [];
+    const empty = [];
     empty.inclusive = [];
     return empty;
   }
 
-  var result = value
+  let result = value
     .substring(1, value.length - 1)
     .split(',', 2);
 
   if (result.length !== 2) return value;
 
-  result = result
-    .map(function (value) {
-      return parseRangeBound(value, parser);
-    });
+  result = result.map(value => parseRangeBound(value, parser));
 
   result.inclusive = [(value[0] === '['), (value[value.length - 1] === ']')];
 
   return result;
 }
-
-module.exports = {
-  stringify: stringify,
-  parse: parse
-};
+exports.parse = parse;