ES6 refactor: dialects / MSSQL (#6049)

* ES6 refactor of MSSQL ConnectionManager

classes, let, const, arrow functions, export default

* Make Mssql Query an ES6 class

* ES6 refactor of Mssql Query

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

lib/dialects/mssql/connection-manager.js

 'use strict';
 
-var AbstractConnectionManager = require('../abstract/connection-manager')
-  , ConnectionManager
-  , ResourceLock = require('./resource-lock')
-  , Utils = require('../../utils')
-  , Promise = require('../../promise')
-  , sequelizeErrors = require('../../errors')
-  , parserStore = require('../parserStore')('mssql')
-  , _ = require('lodash');
-
-ConnectionManager = function(dialect, sequelize) {
-  AbstractConnectionManager.call(this, dialect, sequelize);
-
-  this.sequelize = sequelize;
-  this.sequelize.config.port = this.sequelize.config.port || 1433;
-  try {
-    this.lib = require(sequelize.config.dialectModulePath || 'tedious');
-  } catch (err) {
-    if (err.code === 'MODULE_NOT_FOUND') {
-      throw new Error('Please install tedious package manually');
+const AbstractConnectionManager = require('../abstract/connection-manager');
+const ResourceLock = require('./resource-lock');
+const Promise = require('../../promise');
+const sequelizeErrors = require('../../errors');
+const parserStore = require('../parserStore')('mssql');
+const _ = require('lodash');
+
+class ConnectionManager extends AbstractConnectionManager {
+  constructor(dialect, sequelize) {
+    super(dialect, sequelize);
+
+    this.sequelize = sequelize;
+    this.sequelize.config.port = this.sequelize.config.port || 1433;
+    try {
+      this.lib = require(sequelize.config.dialectModulePath || 'tedious');
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND') {
+        throw new Error('Please install tedious package manually');
+      }
+      throw err;
     }
-    throw err;
   }
-};
-
-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) {
-  parserStore.refresh(dataType);
-};
-
-ConnectionManager.prototype.$clearTypeParser = function () {
-  parserStore.clear();
-};
-
-ConnectionManager.prototype.connect = function(config) {
-  var self = this;
-  return new Promise(function (resolve, reject) {
-    var connectionConfig = {
-      userName: config.username,
-      password: config.password,
-      server: config.host,
-      options: {
-        port: config.port,
-        database: config.database
-      }
-    };
 
-    if (config.dialectOptions) {
-      // only set port if no instance name was provided
-      if (config.dialectOptions.instanceName) {
-        delete connectionConfig.options.port;
-      }
+  // Expose this as a method so that the parsing may be updated when the user has added additional, custom types
+  $refreshTypeParser(dataType) {
+    parserStore.refresh(dataType);
+  }
 
-      // The 'tedious' driver needs domain property to be in the main Connection config object
-      if(config.dialectOptions.domain) {
-        connectionConfig.domain = config.dialectOptions.domain;
-      }
+  $clearTypeParser() {
+    parserStore.clear();
+  }
 
-      Object.keys(config.dialectOptions).forEach(function(key) {
-        connectionConfig.options[key] = config.dialectOptions[key];
-      });
-    }
+  connect(config) {
+    return new Promise((resolve, reject) => {
+      const connectionConfig = {
+        userName: config.username,
+        password: config.password,
+        server: config.host,
+        options: {
+          port: config.port,
+          database: config.database
+        }
+      };
 
-    var connection = new self.lib.Connection(connectionConfig)
-      , connectionLock = new ResourceLock(connection);
-    connection.lib = self.lib;
+      if (config.dialectOptions) {
+        // only set port if no instance name was provided
+        if (config.dialectOptions.instanceName) {
+          delete connectionConfig.options.port;
+        }
 
-    connection.on('connect', function(err) {
-      if (!err) {
-        resolve(connectionLock);
-        return;
-      }
+        // The 'tedious' driver needs domain property to be in the main Connection config object
+        if(config.dialectOptions.domain) {
+          connectionConfig.domain = config.dialectOptions.domain;
+        }
 
-      if (!err.code) {
-        reject(new sequelizeErrors.ConnectionError(err));
-        return;
+        for (const key of Object.keys(config.dialectOptions)) {
+          connectionConfig.options[key] = config.dialectOptions[key];
+        }
       }
 
-      switch (err.code) {
-      case 'ESOCKET':
-        if (_.includes(err.message, 'connect EHOSTUNREACH')) {
-          reject(new sequelizeErrors.HostNotReachableError(err));
-        } else if (_.includes(err.message, 'connect ECONNREFUSED')) {
-          reject(new sequelizeErrors.ConnectionRefusedError(err));
-        } else {
+      const connection = new this.lib.Connection(connectionConfig);
+      const connectionLock = new ResourceLock(connection);
+      connection.lib = this.lib;
+
+      connection.on('connect', err => {
+        if (!err) {
+          resolve(connectionLock);
+          return;
+        }
+
+        if (!err.code) {
           reject(new sequelizeErrors.ConnectionError(err));
+          return;
         }
-        break;
-      case 'ECONNREFUSED':
-        reject(new sequelizeErrors.ConnectionRefusedError(err));
-        break;
-      case 'ER_ACCESS_DENIED_ERROR':
-        reject(new sequelizeErrors.AccessDeniedError(err));
-        break;
-      case 'ENOTFOUND':
-        reject(new sequelizeErrors.HostNotFoundError(err));
-        break;
-      case 'EHOSTUNREACH':
-        reject(new sequelizeErrors.HostNotReachableError(err));
-        break;
-      case 'EINVAL':
-        reject(new sequelizeErrors.InvalidConnectionError(err));
-        break;
-      default:
-        reject(new sequelizeErrors.ConnectionError(err));
-        break;
-      }
-    });
 
-    if (config.pool.handleDisconnects) {
-      connection.on('error', function (err) {
         switch (err.code) {
-        case 'ESOCKET':
-        case 'ECONNRESET':
-          self.pool.destroy(connectionLock);
+          case 'ESOCKET':
+            if (_.includes(err.message, 'connect EHOSTUNREACH')) {
+              reject(new sequelizeErrors.HostNotReachableError(err));
+            } else if (_.includes(err.message, 'connect ECONNREFUSED')) {
+              reject(new sequelizeErrors.ConnectionRefusedError(err));
+            } else {
+              reject(new sequelizeErrors.ConnectionError(err));
+            }
+            break;
+          case 'ECONNREFUSED':
+            reject(new sequelizeErrors.ConnectionRefusedError(err));
+            break;
+          case 'ER_ACCESS_DENIED_ERROR':
+            reject(new sequelizeErrors.AccessDeniedError(err));
+            break;
+          case 'ENOTFOUND':
+            reject(new sequelizeErrors.HostNotFoundError(err));
+            break;
+          case 'EHOSTUNREACH':
+            reject(new sequelizeErrors.HostNotReachableError(err));
+            break;
+          case 'EINVAL':
+            reject(new sequelizeErrors.InvalidConnectionError(err));
+            break;
+          default:
+            reject(new sequelizeErrors.ConnectionError(err));
+            break;
         }
       });
-    }
-
-  });
-};
 
-ConnectionManager.prototype.disconnect = function(connectionLock) {
-  var connection = connectionLock.unwrap();
+      if (config.pool.handleDisconnects) {
+        connection.on('error', err => {
+          switch (err.code) {
+            case 'ESOCKET':
+            case 'ECONNRESET':
+              this.pool.destroy(connectionLock);
+          }
+        });
+      }
 
-  // Dont disconnect a connection that is already disconnected
-  if (!!connection.closed) {
-    return Promise.resolve();
+    });
   }
 
-  return new Promise(function (resolve, reject) {
-    connection.on('end', resolve);
-    connection.close();
-  });
-};
+  disconnect(connectionLock) {
+    const connection = connectionLock.unwrap();
 
-ConnectionManager.prototype.validate = function(connectionLock) {
-  var connection = connectionLock.unwrap();
+    // Dont disconnect a connection that is already disconnected
+    if (!!connection.closed) {
+      return Promise.resolve();
+    }
 
-  return connection && connection.loggedIn;
-};
+    return new Promise(resolve => {
+      connection.on('end', resolve);
+      connection.close();
+    });
+  }
+
+  validate(connectionLock) {
+    const connection = connectionLock.unwrap();
+
+    return connection && connection.loggedIn;
+  }
+}
 
 module.exports = ConnectionManager;
+module.exports.ConnectionManager = ConnectionManager;
+module.exports.default = ConnectionManager;