mysql2 3.0.0 → 3.1.0

package/README.md

@@ -132,6 +132,8 @@ const pool = mysql.createPool({
   database: 'test',
   waitForConnections: true,
   connectionLimit: 10,
+  maxIdle: 10, // max idle connections, the default value is the same as `connectionLimit`
+  idleTimeout: 60000, // idle connections timeout, in milliseconds, the default value 60000
   queueLimit: 0
 });
 ```

package/index.d.ts

@@ -180,6 +180,8 @@ export interface ConnectionOptions extends mysql.ConnectionOptions {
   stream?: any;
   uri?: string;
   connectionLimit?: number;
+  maxIdle?: number;
+  idleTimeout?: number;
   Promise?: any;
   queueLimit?: number;
   waitForConnections?: boolean;

package/lib/auth_41.js

@@ -41,16 +41,7 @@ function sha1(msg, msg1, msg2) {
 }
 
 function xor(a, b) {
-  if (!Buffer.isBuffer(a)) {
-    a = Buffer.from(a, 'binary');
-  }
-
-  if (!Buffer.isBuffer(b)) {
-    b = Buffer.from(b, 'binary');
-  }
-
   const result = Buffer.allocUnsafe(a.length);
-
   for (let i = 0; i < a.length; i++) {
     result[i] = a[i] ^ b[i];
   }
@@ -60,7 +51,6 @@ function xor(a, b) {
 exports.xor = xor;
 
 function token(password, scramble1, scramble2) {
-  // TODO: use buffers (not sure why strings here)
   if (!password) {
     return Buffer.alloc(0);
   }
@@ -94,14 +84,6 @@ exports.doubleSha1 = function(password) {
 };
 
 function xorRotating(a, seed) {
-  if (!Buffer.isBuffer(a)) {
-    a = Buffer.from(a, 'binary');
-  }
-
-  if (!Buffer.isBuffer(seed)) {
-    seed = Buffer.from(seed, 'binary');
-  }
-
   const result = Buffer.allocUnsafe(a.length);
   const seedLen = seed.length;
 

package/lib/auth_plugins/caching_sha2_password.js

@@ -17,24 +17,24 @@ const STATE_FINAL = -1;
 
 function sha256(msg) {
   const hash = crypto.createHash('sha256');
-  hash.update(msg, 'binary');
-  return hash.digest('binary');
+  hash.update(msg);
+  return hash.digest();
 }
 
 function calculateToken(password, scramble) {
   if (!password) {
     return Buffer.alloc(0);
   }
-  const stage1 = sha256(Buffer.from(password, 'utf8').toString('binary'));
+  const stage1 = sha256(Buffer.from(password));
   const stage2 = sha256(stage1);
-  const stage3 = sha256(stage2 + scramble.toString('binary'));
+  const stage3 = sha256(Buffer.concat([stage2, scramble]));
   return xor(stage1, stage3);
 }
 
 function encrypt(password, scramble, key) {
   const stage1 = xorRotating(
-    Buffer.from(`${password}\0`, 'utf8').toString('binary'),
-    scramble.toString('binary')
+    Buffer.from(`${password}\0`, 'utf8'),
+    scramble
   );
   return crypto.publicEncrypt(key, stage1);
 }
@@ -86,6 +86,7 @@ module.exports = (pluginOptions = {}) => ({ connection }) => {
           `Invalid AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_TOKEN_SENT state.`
         );
       case STATE_WAIT_SERVER_KEY:
+        console.log('Server pub key:', data);
         if (pluginOptions.onServerPublicKey) {
           pluginOptions.onServerPublicKey(data);
         }

package/lib/auth_plugins/sha256_password.js

@@ -12,8 +12,8 @@ const STATE_FINAL = -1;
 
 function encrypt(password, scramble, key) {
   const stage1 = xorRotating(
-    Buffer.from(`${password}\0`, 'utf8').toString('binary'),
-    scramble.toString('binary')
+    Buffer.from(`${password}\0`, 'utf8'),
+    scramble
   );
   return crypto.publicEncrypt(key, stage1);
 }

package/lib/connection_config.js

@@ -59,6 +59,8 @@ const validOptions = {
   user: 1,
   // These options are used for Pool
   connectionLimit: 1,
+  maxIdle: 1,
+  idleTimeout: 1,
   Promise: 1,
   queueLimit: 1,
   waitForConnections: 1
@@ -89,7 +91,7 @@ class ConnectionConfig {
     this.isServer = options.isServer;
     this.stream = options.stream;
     this.host = options.host || 'localhost';
-    this.port = options.port || 3306;
+    this.port = (typeof options.port === 'string' ? parseInt(options.port, 10) : options.port)|| 3306;
     this.localAddress = options.localAddress;
     this.socketPath = options.socketPath;
     this.user = options.user || undefined;
@@ -252,7 +254,7 @@ class ConnectionConfig {
     const parsedUrl = new URL(url);
     const options = {
       host: parsedUrl.hostname,
-      port: parsedUrl.port,
+      port: parseInt(parsedUrl.port, 10),
       database: parsedUrl.pathname.slice(1),
       user: parsedUrl.username,
       password: parsedUrl.password

package/lib/pool.js

@@ -27,6 +27,10 @@ class Pool extends EventEmitter {
     this._freeConnections = new Queue();
     this._connectionQueue = new Queue();
     this._closed = false;
+    if (this.config.maxIdle < this.config.connectionLimit) {
+      // create idle connection timeout automatically release job
+      this._removeIdleTimeoutConnections();
+    }
   }
 
   promise(promiseImpl) {
@@ -40,7 +44,7 @@ class Pool extends EventEmitter {
     }
     let connection;
     if (this._freeConnections.length > 0) {
-      connection = this._freeConnections.shift();
+      connection = this._freeConnections.pop();
       this.emit('acquire', connection);
       return process.nextTick(() => cb(null, connection));
     }
@@ -187,6 +191,26 @@ class Pool extends EventEmitter {
     this.releaseConnection(connection);
   }
 
+  _removeIdleTimeoutConnections() {
+    if (this._removeIdleTimeoutConnectionsTimer) {
+      clearTimeout(this._removeIdleTimeoutConnectionsTimer);
+    }
+
+    this._removeIdleTimeoutConnectionsTimer = setTimeout(() => {
+      try {
+        while (
+          this._freeConnections.length > this.config.maxIdle &&
+          Date.now() - this._freeConnections.get(0).lastActiveTime >
+            this.config.idleTimeout
+        ) {
+          this._freeConnections.get(0).destroy();
+        }
+      } finally {
+        this._removeIdleTimeoutConnections();
+      }
+    }, 1000);
+  }
+
   format(sql, values) {
     return mysql.format(
       sql,

package/lib/pool_config.js

@@ -15,6 +15,12 @@ class PoolConfig {
     this.connectionLimit = isNaN(options.connectionLimit)
       ? 10
       : Number(options.connectionLimit);
+    this.maxIdle = isNaN(options.maxIdle)
+      ? this.connectionLimit
+      : Number(options.maxIdle);
+    this.idleTimeout = isNaN(options.idleTimeout)
+      ? 60000
+      : Number(options.idleTimeout);
     this.queueLimit = isNaN(options.queueLimit)
       ? 0
       : Number(options.queueLimit);

package/lib/pool_connection.js

@@ -6,6 +6,8 @@ class PoolConnection extends Connection {
   constructor(pool, options) {
     super(options);
     this._pool = pool;
+    // The last active time of this connection
+    this.lastActiveTime = Date.now();
     // When a fatal error occurs the connection's protocol ends, which will cause
     // the connection to end as well, thus we only need to watch for the end event
     // and we will be notified of disconnects.
@@ -22,6 +24,8 @@ class PoolConnection extends Connection {
     if (!this._pool || this._pool._closed) {
       return;
     }
+    // update last active time
+    this.lastActiveTime = Date.now();
     this._pool.releaseConnection(this);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "directories": {
@@ -56,7 +56,6 @@
   "license": "MIT",
   "dependencies": {
     "denque": "^2.1.0",
-    "eslint-config-prettier": "^8.5.0",
     "generate-function": "^2.3.1",
     "iconv-lite": "^0.6.3",
     "long": "^5.2.1",
@@ -77,6 +76,7 @@
     "chai": "^4.3.7",
     "error-stack-parser": "^2.0.3",
     "eslint": "^8.27.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-async-await": "0.0.0",
     "eslint-plugin-markdown": "^3.0.0",
     "husky": "^8.0.2",

package/typings/mysql/lib/Pool.d.ts

@@ -26,6 +26,16 @@ declare namespace Pool {
          */
         connectionLimit?: number;
 
+        /**
+         * The minimum number of idle connections. (Default: 10)
+         */
+         maxIdle?: number;
+
+        /**
+         * The idle connections timeout, in milliseconds. (Default: 60000)
+         */
+         idleTimeout?: number;
+
         /**
          * The maximum number of connection requests the pool will queue before returning an error from getConnection. If set to 0, there
          * is no limit to the number of queued connection requests. (Default: 0)