@depup/mysql2 3.19.1-depup.0 → 3.21.0-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/mysql2
 
 | Field | Value |
 |-------|-------|
-| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.19.1 |
-| Processed | 2026-03-09 |
+| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.21.0 |
+| Processed | 2026-04-09 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-04-09T12:30:50.439Z",
+  "totalUpdated": 0
+}

package/lib/auth_plugins/caching_sha2_password.js

@@ -36,6 +36,7 @@ function encrypt(password, scramble, key) {
   return crypto.publicEncrypt(
     {
       key,
+      oaepHash: 'sha1',
       padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
     },
     stage1

package/lib/auth_plugins/sha256_password.js

@@ -13,7 +13,13 @@ const STATE_FINAL = -1;
 
 function encrypt(password, scramble, key) {
   const stage1 = xorRotating(Buffer.from(`${password}\0`, 'utf8'), scramble);
-  return crypto.publicEncrypt(key, stage1);
+  return crypto.publicEncrypt(
+    {
+      key,
+      oaepHash: 'sha1',
+    },
+    stage1
+  );
 }
 
 module.exports =

package/lib/base/connection.js

@@ -28,6 +28,15 @@ const Packets = require('../packets/index.js');
 const Commands = require('../commands/index.js');
 const ConnectionConfig = require('../connection_config.js');
 const CharsetToEncoding = require('../constants/charset_encodings.js');
+const {
+  traceCallback,
+  tracePromise,
+  getServerContext,
+  shouldTrace,
+  queryChannel,
+  executeChannel,
+  connectChannel,
+} = require('../tracing.js');
 
 let _connectionId = 0;
 
@@ -141,6 +150,41 @@ class BaseConnection extends EventEmitter {
         this._notifyError(err);
       });
       this.addCommand(handshakeCommand);
+
+      // Trace the connection handshake
+      if (shouldTrace(connectChannel)) {
+        const config = this.config;
+        tracePromise(
+          connectChannel,
+          () =>
+            new Promise((resolve, reject) => {
+              /* eslint-disable prefer-const */
+              let onConnect, onError;
+              onConnect = (param) => {
+                this.removeListener('error', onError);
+                resolve(param);
+              };
+              onError = (err) => {
+                this.removeListener('connect', onConnect);
+                reject(err);
+              };
+              /* eslint-enable prefer-const */
+              this.once('connect', onConnect);
+              this.once('error', onError);
+            }),
+          () => {
+            const server = getServerContext(config);
+            return {
+              database: config.database || '',
+              serverAddress: server.serverAddress,
+              serverPort: server.serverPort,
+              user: config.user || '',
+            };
+          }
+        ).catch(() => {
+          // errors are already handled by the handshake error listener
+        });
+      }
     }
     // in case there was no initial handshake but we need to read sting, assume it utf-8
     // most common example: "Too many connections" error ( packet is sent immediately on connection attempt, we don't know server encoding yet)
@@ -601,7 +645,57 @@ class BaseConnection extends EventEmitter {
       cmdQuery.values !== undefined ? cmdQuery.values : []
     );
     cmdQuery.sql = rawSql;
-    return this.addCommand(cmdQuery);
+
+    if (cmdQuery.onResult) {
+      // Callback mode: traceCallback wraps the callback with tracing lifecycle, or calls through directly when no subscribers are registered
+      traceCallback(
+        queryChannel,
+        (wrappedCb) => {
+          cmdQuery.onResult = wrappedCb;
+          this.addCommand(cmdQuery);
+        },
+        0,
+        () => {
+          const server = getServerContext(this.config);
+          return {
+            query: cmdQuery.sql,
+            values: cmdQuery.values,
+            database: this.config.database || '',
+            serverAddress: server.serverAddress,
+            serverPort: server.serverPort,
+          };
+        },
+        null,
+        cmdQuery.onResult
+      );
+    } else if (shouldTrace(queryChannel)) {
+      // Event-emitter mode: tracePromise wraps the async lifecycle
+      tracePromise(
+        queryChannel,
+        () =>
+          new Promise((resolve, reject) => {
+            cmdQuery.once('error', reject);
+            cmdQuery.once('end', () => resolve());
+            this.addCommand(cmdQuery);
+          }),
+        () => {
+          const server = getServerContext(this.config);
+          return {
+            query: cmdQuery.sql,
+            values: cmdQuery.values,
+            database: this.config.database || '',
+            serverAddress: server.serverAddress,
+            serverPort: server.serverPort,
+          };
+        }
+      ).catch(() => {
+        // errors are already emitted on the command
+      });
+    } else {
+      this.addCommand(cmdQuery);
+    }
+
+    return cmdQuery;
   }
 
   pause() {
@@ -702,25 +796,78 @@ class BaseConnection extends EventEmitter {
       });
     }
     const executeCommand = new Commands.Execute(options, cb);
-    const prepareCommand = new Commands.Prepare(options, (err, stmt) => {
-      if (err) {
-        // skip execute command if prepare failed, we have main
-        // combined callback here
-        executeCommand.start = function () {
-          return null;
-        };
-        if (cb) {
-          cb(err);
-        } else {
-          executeCommand.emit('error', err);
+
+    const prepareAndExecute = (errorCb) => {
+      const prepareCommand = new Commands.Prepare(options, (err, stmt) => {
+        if (err) {
+          // skip execute command if prepare failed
+          executeCommand.start = function () {
+            return null;
+          };
+          errorCb(err);
+          executeCommand.emit('end');
+          return;
         }
-        executeCommand.emit('end');
-        return;
-      }
-      executeCommand.statement = stmt;
-    });
-    this.addCommand(prepareCommand);
-    this.addCommand(executeCommand);
+        executeCommand.statement = stmt;
+      });
+      this.addCommand(prepareCommand);
+      this.addCommand(executeCommand);
+    };
+
+    if (executeCommand.onResult) {
+      // Callback mode: traceCallback wraps the callback with tracing lifecycle, or calls through directly when no subscribers are registered
+      const origExecCb = executeCommand.onResult;
+      traceCallback(
+        executeChannel,
+        (wrappedCb) => {
+          executeCommand.onResult = wrappedCb;
+          prepareAndExecute(wrappedCb);
+        },
+        0,
+        () => {
+          const server = getServerContext(this.config);
+          return {
+            query: options.sql,
+            values: options.values,
+            database: this.config.database || '',
+            serverAddress: server.serverAddress,
+            serverPort: server.serverPort,
+          };
+        },
+        null,
+        origExecCb
+      );
+    } else if (shouldTrace(executeChannel)) {
+      // Event-emitter mode: tracePromise wraps the async lifecycle
+      tracePromise(
+        executeChannel,
+        () =>
+          new Promise((resolve, reject) => {
+            prepareAndExecute((err) => {
+              executeCommand.emit('error', err);
+            });
+            executeCommand.once('error', reject);
+            executeCommand.once('end', () => resolve());
+          }),
+        () => {
+          const server = getServerContext(this.config);
+          return {
+            query: options.sql,
+            values: options.values,
+            database: this.config.database || '',
+            serverAddress: server.serverAddress,
+            serverPort: server.serverPort,
+          };
+        }
+      ).catch(() => {
+        // errors are already emitted on the command
+      });
+    } else {
+      prepareAndExecute((err) => {
+        executeCommand.emit('error', err);
+      });
+    }
+
     return executeCommand;
   }
 

package/lib/base/pool.js

@@ -7,6 +7,11 @@ const PoolConnection = require('../pool_connection.js');
 const Queue = require('denque');
 const BaseConnection = require('./connection.js');
 const Errors = require('../constants/errors.js');
+const {
+  traceCallback,
+  getServerContext,
+  poolConnectChannel,
+} = require('../tracing.js');
 
 // Source: https://github.com/go-sql-driver/mysql/blob/76c00e35a8d48f8f70f0e7dffe584692bd3fa612/packets.go#L598-L613
 function isReadOnlyError(err) {
@@ -49,46 +54,69 @@ class BasePool extends EventEmitter {
   }
 
   getConnection(cb) {
-    if (this._closed) {
-      return process.nextTick(() => cb(new Error('Pool is closed.')));
-    }
-    let connection;
-    if (this._freeConnections.length > 0) {
-      connection = this._freeConnections.pop();
-      this.emit('acquire', connection);
-      return process.nextTick(() => cb(null, connection));
-    }
-    if (
-      this.config.connectionLimit === 0 ||
-      this._allConnections.length < this.config.connectionLimit
-    ) {
-      connection = new PoolConnection(this, {
-        config: this.config.connectionConfig,
-      });
-      this._allConnections.push(connection);
-      return connection.connect((err) => {
-        if (this._closed) {
-          return cb(new Error('Pool is closed.'));
-        }
-        if (err) {
-          return cb(err);
-        }
-        this.emit('connection', connection);
+    const _getConnection = (cb) => {
+      if (this._closed) {
+        return process.nextTick(() => cb(new Error('Pool is closed.')));
+      }
+      let connection;
+      if (this._freeConnections.length > 0) {
+        connection = this._freeConnections.pop();
         this.emit('acquire', connection);
-        return cb(null, connection);
-      });
-    }
-    if (!this.config.waitForConnections) {
-      return process.nextTick(() => cb(new Error('No connections available.')));
-    }
-    if (
-      this.config.queueLimit &&
-      this._connectionQueue.length >= this.config.queueLimit
-    ) {
-      return cb(new Error('Queue limit reached.'));
-    }
-    this.emit('enqueue');
-    return this._connectionQueue.push(cb);
+        return process.nextTick(() => {
+          connection._released = false;
+          cb(null, connection);
+        });
+      }
+      if (
+        this.config.connectionLimit === 0 ||
+        this._allConnections.length < this.config.connectionLimit
+      ) {
+        connection = new PoolConnection(this, {
+          config: this.config.connectionConfig,
+        });
+        this._allConnections.push(connection);
+        return connection.connect((err) => {
+          if (this._closed) {
+            return cb(new Error('Pool is closed.'));
+          }
+          if (err) {
+            return cb(err);
+          }
+          this.emit('connection', connection);
+          this.emit('acquire', connection);
+          return cb(null, connection);
+        });
+      }
+      if (!this.config.waitForConnections) {
+        return process.nextTick(() =>
+          cb(new Error('No connections available.'))
+        );
+      }
+      if (
+        this.config.queueLimit &&
+        this._connectionQueue.length >= this.config.queueLimit
+      ) {
+        return cb(new Error('Queue limit reached.'));
+      }
+      this.emit('enqueue');
+      return this._connectionQueue.push(cb);
+    };
+    const config = this.config.connectionConfig;
+    traceCallback(
+      poolConnectChannel,
+      _getConnection,
+      0,
+      () => {
+        const server = getServerContext(config);
+        return {
+          database: config.database || '',
+          serverAddress: server.serverAddress,
+          serverPort: server.serverPort,
+        };
+      },
+      null,
+      cb
+    );
   }
 
   releaseConnection(connection) {
@@ -101,7 +129,10 @@ class BasePool extends EventEmitter {
       }
     } else if (this._connectionQueue.length) {
       cb = this._connectionQueue.shift();
-      process.nextTick(cb.bind(null, null, connection));
+      process.nextTick(() => {
+        connection._released = false;
+        cb(null, connection);
+      });
     } else {
       this._freeConnections.push(connection);
       this.emit('release', connection);

package/lib/commands/execute.js

@@ -43,11 +43,15 @@ class Execute extends Command {
     this._connection = connection;
     this.options = Object.assign({}, connection.config, this._executeOptions);
     this._setTimeout();
+    const clientFlags =
+      connection.config.clientFlags & (connection.serverCapabilityFlags || 0);
     const executePacket = new Packets.Execute(
       this.statement.id,
       this.parameters,
       connection.config.charsetNumber,
-      connection.config.timezone
+      connection.config.timezone,
+      this._executeOptions.attributes,
+      clientFlags
     );
     //For reasons why this try-catch is here, please see
     // https://github.com/sidorares/node-mysql2/pull/689

package/lib/commands/query.js

@@ -53,9 +53,13 @@ class Query extends Command {
     this.options = Object.assign({}, connection.config, this._queryOptions);
     this._setTimeout();
 
+    const clientFlags =
+      connection.config.clientFlags & (connection.serverCapabilityFlags || 0);
     const cmdPacket = new Packets.Query(
       this.sql,
-      connection.config.charsetNumber
+      connection.config.charsetNumber,
+      this._queryOptions.attributes,
+      clientFlags
     );
     connection.writePacket(cmdPacket.toPacket(1));
     return Query.prototype.resultsetHeader;

package/lib/connection_config.js

@@ -239,6 +239,7 @@ class ConnectionConfig {
       'TRANSACTIONS',
       'SESSION_TRACK',
       'CONNECT_ATTRS',
+      'CLIENT_QUERY_ATTRIBUTES',
     ];
     if (options && options.multipleStatements) {
       defaultFlags.push('MULTI_STATEMENTS');

package/lib/constants/client.js

@@ -31,6 +31,7 @@ exports.CONNECT_ATTRS = 0x00100000; /* permits connection attributes */
 exports.PLUGIN_AUTH_LENENC_CLIENT_DATA = 0x00200000; /* Understands length-encoded integer for auth response data in Protocol::HandshakeResponse41. */
 exports.CAN_HANDLE_EXPIRED_PASSWORDS = 0x00400000; /* Announces support for expired password extension. */
 exports.SESSION_TRACK = 0x00800000; /* Can set SERVER_SESSION_STATE_CHANGED in the Status Flags and send session-state change data after a OK packet. */
+exports.CLIENT_QUERY_ATTRIBUTES = 0x08000000; /* support query attributes in COM_QUERY and COM_STMT_EXECUTE */
 
 exports.SSL_VERIFY_SERVER_CERT = 0x40000000;
 exports.REMEMBER_OPTIONS = 0x80000000;

package/lib/constants/cursor.js

@@ -5,4 +5,5 @@ module.exports = {
   READ_ONLY: 1,
   FOR_UPDATE: 2,
   SCROLLABLE: 3,
+  PARAMETER_COUNT_AVAILABLE: 8,
 };

package/lib/packets/encode_parameter.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const Types = require('../constants/types');
+const Packet = require('../packets/packet');
+
+function isJSON(value) {
+  return (
+    Array.isArray(value) ||
+    value.constructor === Object ||
+    (typeof value.toJSON === 'function' && !Buffer.isBuffer(value))
+  );
+}
+
+function toParameter(value, encoding, timezone) {
+  let type = Types.VAR_STRING;
+  let length;
+  let writer = function (value) {
+    // eslint-disable-next-line no-invalid-this
+    return Packet.prototype.writeLengthCodedString.call(this, value, encoding);
+  };
+  if (value !== null) {
+    switch (typeof value) {
+      case 'undefined':
+        throw new TypeError('Bind parameters must not contain undefined');
+
+      case 'number':
+        type = Types.DOUBLE;
+        length = 8;
+        writer = Packet.prototype.writeDouble;
+        break;
+
+      case 'boolean':
+        value = value | 0;
+        type = Types.TINY;
+        length = 1;
+        writer = Packet.prototype.writeInt8;
+        break;
+
+      case 'object':
+        if (Object.prototype.toString.call(value) === '[object Date]') {
+          type = Types.DATETIME;
+          length = 12;
+          writer = function (value) {
+            // eslint-disable-next-line no-invalid-this
+            return Packet.prototype.writeDate.call(this, value, timezone);
+          };
+        } else if (isJSON(value)) {
+          value = JSON.stringify(value);
+          type = Types.JSON;
+        } else if (Buffer.isBuffer(value)) {
+          length = Packet.lengthCodedNumberLength(value.length) + value.length;
+          writer = Packet.prototype.writeLengthCodedBuffer;
+        }
+        break;
+
+      default:
+        value = value.toString();
+    }
+  } else {
+    value = '';
+    type = Types.NULL;
+  }
+  if (!length) {
+    length = Packet.lengthCodedStringLength(value, encoding);
+  }
+  return { value, type, length, writer };
+}
+
+module.exports = { toParameter, isJSON };