@depup/mysql2 3.24.0-depup.0 → 3.24.2-depup.0

package/README.md

@@ -13,7 +13,7 @@ npm install @depup/mysql2
 
 | Field | Value |
 |-------|-------|
-| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.24.0 |
+| Original | [mysql2](https://www.npmjs.com/package/mysql2) @ 3.24.2 |
 | Processed | 2026-08-24 |
 | Smoke test | passed |
 | Deps updated | 0 |

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-08-24T00:15:42.327Z",
+  "timestamp": "2026-08-24T16:12:27.785Z",
   "totalUpdated": 0
 }

package/lib/packets/encode_parameter.js

@@ -88,14 +88,28 @@ function toParameter(value, encoding, timezone, jsonAsString, hint) {
     length = 0;
     writer = writeNothing;
   }
+  let byteLength;
   if (length === undefined) {
-    value = StringParser.encode(value, encoding);
-    length = Packet.lengthCodedNumberLength(value.length) + value.length;
+    // a non-string here (e.g. a Uint8Array) keeps the Buffer.from coercion
+    // inside StringParser.encode
+    if (
+      typeof value === 'string' &&
+      StringParser.hasFastUtf8Write &&
+      (encoding === 'utf8' || encoding === 'utf-8')
+    ) {
+      byteLength = Buffer.byteLength(value, 'utf8');
+      length = Packet.lengthCodedNumberLength(byteLength) + byteLength;
+      writer = Packet.prototype.writeLengthCodedUtf8String;
+    } else {
+      value = StringParser.encode(value, encoding);
+      length = Packet.lengthCodedNumberLength(value.length) + value.length;
+    }
   }
   return {
     value,
     type,
     length,
+    byteLength,
     writer,
     unsigned: false,
     isNull: type === Types.NULL,

package/lib/packets/execute.js

@@ -206,7 +206,7 @@ class Execute {
       for (let i = 0; i < totalParams; i++) {
         const parameter = allParams[i];
         if (!parameter.isNull) {
-          parameter.writer.call(packet, parameter.value);
+          parameter.writer.call(packet, parameter.value, parameter.byteLength);
         }
       }
     }

package/lib/packets/packet.js

@@ -1030,6 +1030,18 @@ class Packet {
     this.offset += buf.length;
   }
 
+  // byteLength, when the caller sized the packet, must be
+  // Buffer.byteLength(string, 'utf8'); only used where
+  // Buffer.prototype.utf8Write exists
+  writeLengthCodedUtf8String(string, byteLength) {
+    if (byteLength === undefined) {
+      byteLength = Buffer.byteLength(string, 'utf8');
+    }
+    this.writeLengthCodedNumber(byteLength);
+    this.buffer.utf8Write(string, this.offset, byteLength);
+    this.offset += byteLength;
+  }
+
   writeLengthCodedBuffer(b) {
     this.writeLengthCodedNumber(b.length);
     b.copy(this.buffer, this.offset);
@@ -1123,7 +1135,7 @@ class Packet {
       return 3;
     }
     if (n < 0xffffff) {
-      return 5;
+      return 4;
     }
     return 9;
   }

package/lib/packets/prepare_statement.js

@@ -13,6 +13,18 @@ class PrepareStatement {
   }
 
   toPacket() {
+    if (
+      StringParser.hasFastUtf8Write &&
+      (this.encoding === 'utf8' || this.encoding === 'utf-8')
+    ) {
+      const length = 5 + Buffer.byteLength(this.query, 'utf8');
+      const buffer = Buffer.allocUnsafe(length);
+      buffer[4] = CommandCodes.STMT_PREPARE;
+      buffer.utf8Write(this.query, 5, length - 5);
+      const packet = new Packet(0, buffer, 0, length);
+      packet.offset = length;
+      return packet;
+    }
     const buf = StringParser.encode(this.query, this.encoding);
     const length = 5 + buf.length;
     const buffer = Buffer.allocUnsafe(length);

package/lib/packets/query.js

@@ -7,6 +7,19 @@ const CharsetToEncoding = require('../constants/charset_encodings.js');
 const ClientConstants = require('../constants/client.js');
 const { toParameter } = require('./encode_parameter.js');
 
+const { hasFastUtf8Write } = StringParser;
+
+function toQueryPacket(buffer, headerLength, length) {
+  buffer[4] = CommandCode.QUERY;
+  if (headerLength === 7) {
+    buffer[5] = 0; // parameter_count
+    buffer[6] = 1; // parameter_set_count, always 1
+  }
+  const packet = new Packet(0, buffer, 0, length);
+  packet.offset = length;
+  return packet;
+}
+
 class Query {
   constructor(sql, charsetNumber, attributes, clientFlags) {
     this.query = sql;
@@ -25,36 +38,30 @@ class Query {
         : 0;
 
     if (attributeCount === 0) {
-      // fast path: no attribute values to serialize, so the packet length is
-      // known upfront and the SQL can be encoded straight into the buffer
+      // fast path: no attribute values to serialize, so the packet is the
+      // header plus the encoded SQL
       const headerLength = useQueryAttributes ? 7 : 5;
+      if (
+        hasFastUtf8Write &&
+        (this.encoding === 'utf8' || this.encoding === 'utf-8')
+      ) {
+        const length = headerLength + Buffer.byteLength(this.query, 'utf8');
+        const buffer = Buffer.allocUnsafe(length);
+        buffer.utf8Write(this.query, headerLength, length - headerLength);
+        return toQueryPacket(buffer, headerLength, length);
+      }
       if (Buffer.isEncoding(this.encoding)) {
-        const sqlLength = Buffer.byteLength(this.query, this.encoding);
-        const length = headerLength + sqlLength;
+        const length =
+          headerLength + Buffer.byteLength(this.query, this.encoding);
         const buffer = Buffer.allocUnsafe(length);
-        const packet = new Packet(0, buffer, 0, length);
-        packet.offset = 4;
-        packet.writeInt8(CommandCode.QUERY);
-        if (useQueryAttributes) {
-          packet.writeInt8(0); // parameter_count
-          packet.writeInt8(1); // parameter_set_count, always 1
-        }
-        buffer.write(this.query, packet.offset, this.encoding);
-        packet.offset = length;
-        return packet;
+        buffer.write(this.query, headerLength, this.encoding);
+        return toQueryPacket(buffer, headerLength, length);
       }
-      const buf = StringParser.encode(this.query, this.encoding);
-      const length = headerLength + buf.length;
+      const sqlBuffer = StringParser.encode(this.query, this.encoding);
+      const length = headerLength + sqlBuffer.length;
       const buffer = Buffer.allocUnsafe(length);
-      const packet = new Packet(0, buffer, 0, length);
-      packet.offset = 4;
-      packet.writeInt8(CommandCode.QUERY);
-      if (useQueryAttributes) {
-        packet.writeInt8(0); // parameter_count
-        packet.writeInt8(1); // parameter_set_count, always 1
-      }
-      packet.writeBuffer(buf);
-      return packet;
+      sqlBuffer.copy(buffer, headerLength);
+      return toQueryPacket(buffer, headerLength, length);
     }
 
     const names = Object.keys(this.attributes);
@@ -120,7 +127,11 @@ class Query {
 
     for (let i = 0; i < attributeCount; i++) {
       if (!parameters[i].isNull) {
-        parameters[i].writer.call(packet, parameters[i].value);
+        parameters[i].writer.call(
+          packet,
+          parameters[i].value,
+          parameters[i].byteLength
+        );
       }
     }
 

package/lib/packets/typed_parameter.js

@@ -238,15 +238,25 @@ function timeEncoder() {
 
 function lengthCodedEncoder(encoding) {
   return (value) => {
-    const buffer = Buffer.isBuffer(value)
-      ? value
-      : StringParser.encode(
-          typeof value === 'string' ? value : String(value),
-          encoding
-        );
+    if (!Buffer.isBuffer(value)) {
+      const string = typeof value === 'string' ? value : String(value);
+      if (
+        StringParser.hasFastUtf8Write &&
+        (encoding === 'utf8' || encoding === 'utf-8')
+      ) {
+        const byteLength = Buffer.byteLength(string, 'utf8');
+        return {
+          value: string,
+          length: Packet.lengthCodedNumberLength(byteLength) + byteLength,
+          byteLength,
+          writer: Packet.prototype.writeLengthCodedUtf8String,
+        };
+      }
+      value = StringParser.encode(string, encoding);
+    }
     return {
-      value: buffer,
-      length: Packet.lengthCodedNumberLength(buffer.length) + buffer.length,
+      value,
+      length: Packet.lengthCodedNumberLength(value.length) + value.length,
       writer: Packet.prototype.writeLengthCodedBuffer,
     };
   };

package/lib/parsers/string.js

@@ -15,6 +15,10 @@ const hasFastSlices =
   typeof Buffer.prototype.latin1Slice === 'function' &&
   typeof Buffer.prototype.asciiSlice === 'function';
 
+// utf8Write skips the per-call encoding normalization and dispatch inside
+// buffer.write(); same stability story as the slice methods above
+exports.hasFastUtf8Write = typeof Buffer.prototype.utf8Write === 'function';
+
 exports.decode = function (buffer, encoding, start, end, options) {
   if (hasFastSlices) {
     // replicate buffer.toString() bounds coercion exactly (the *Slice

package/lib/pool_cluster.js

@@ -141,6 +141,17 @@ class PoolNamespace {
     });
   }
 
+  get trace() {
+    const nodeIds = this._cluster._findNodeIds(this._pattern, true);
+    for (let i = 0; i < nodeIds.length; i++) {
+      const node = this._cluster._getNode(nodeIds[i]);
+      if (node?.pool.config.connectionConfig.trace) {
+        return true;
+      }
+    }
+    return nodeIds.length === 0;
+  }
+
   _getClusterNode() {
     const foundNodeIds = this._cluster._findNodeIds(this._pattern);
     if (foundNodeIds.length === 0) {

package/lib/promise/connection.js

@@ -82,9 +82,9 @@ class PromiseConnection extends EventEmitter {
 
   beginTransaction() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(
-      PromiseConnection.prototype.beginTransaction
-    );
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.beginTransaction)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       const done = makeDoneCb(resolve, reject, stackHolder);
       c.beginTransaction(done);
@@ -93,7 +93,9 @@ class PromiseConnection extends EventEmitter {
 
   commit() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(PromiseConnection.prototype.commit);
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.commit)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       const done = makeDoneCb(resolve, reject, stackHolder);
       c.commit(done);
@@ -102,9 +104,9 @@ class PromiseConnection extends EventEmitter {
 
   rollback() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(
-      PromiseConnection.prototype.rollback
-    );
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.rollback)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       const done = makeDoneCb(resolve, reject, stackHolder);
       c.rollback(done);
@@ -113,7 +115,9 @@ class PromiseConnection extends EventEmitter {
 
   ping() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(PromiseConnection.prototype.ping);
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.ping)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       c.ping((err) => {
         if (err) {
@@ -128,7 +132,9 @@ class PromiseConnection extends EventEmitter {
 
   reset() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(PromiseConnection.prototype.reset);
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.reset)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       c.reset((err) => {
         if (err) {
@@ -143,7 +149,9 @@ class PromiseConnection extends EventEmitter {
 
   connect() {
     const c = this.connection;
-    const stackHolder = captureStackHolder(PromiseConnection.prototype.connect);
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.connect)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       c.connect((err, param) => {
         if (err) {
@@ -159,7 +167,9 @@ class PromiseConnection extends EventEmitter {
   prepare(options) {
     const c = this.connection;
     const promiseImpl = this.Promise;
-    const stackHolder = captureStackHolder(PromiseConnection.prototype.prepare);
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.prepare)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       c.prepare(options, (err, statement) => {
         if (err) {
@@ -178,9 +188,9 @@ class PromiseConnection extends EventEmitter {
 
   changeUser(options) {
     const c = this.connection;
-    const stackHolder = captureStackHolder(
-      PromiseConnection.prototype.changeUser
-    );
+    const stackHolder = c.config.trace
+      ? captureStackHolder(PromiseConnection.prototype.changeUser)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       c.changeUser(options, (err) => {
         if (err) {

package/lib/promise/pool.js

@@ -77,7 +77,9 @@ class PromisePool extends EventEmitter {
 
   end() {
     const corePool = this.pool;
-    const stackHolder = captureStackHolder(PromisePool.prototype.end);
+    const stackHolder = corePool.config.connectionConfig.trace
+      ? captureStackHolder(PromisePool.prototype.end)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       corePool.end((err) => {
         if (err) {

package/lib/promise/pool_cluster.js

@@ -25,9 +25,9 @@ class PromisePoolNamespace {
 
   query(sql, values) {
     const corePoolNamespace = this.poolNamespace;
-    const stackHolder = captureStackHolder(
-      PromisePoolNamespace.prototype.query
-    );
+    const stackHolder = corePoolNamespace.trace
+      ? captureStackHolder(PromisePoolNamespace.prototype.query)
+      : undefined;
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
@@ -41,9 +41,9 @@ class PromisePoolNamespace {
 
   execute(sql, values) {
     const corePoolNamespace = this.poolNamespace;
-    const stackHolder = captureStackHolder(
-      PromisePoolNamespace.prototype.execute
-    );
+    const stackHolder = corePoolNamespace.trace
+      ? captureStackHolder(PromisePoolNamespace.prototype.execute)
+      : undefined;
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'

package/lib/promise/prepared_statement_info.js

@@ -11,9 +11,9 @@ class PromisePreparedStatementInfo {
 
   execute(parameters) {
     const s = this.statement;
-    const stackHolder = captureStackHolder(
-      PromisePreparedStatementInfo.prototype.execute
-    );
+    const stackHolder = s._connection.config.trace
+      ? captureStackHolder(PromisePreparedStatementInfo.prototype.execute)
+      : undefined;
     return new this.Promise((resolve, reject) => {
       const done = makeDoneCb(resolve, reject, stackHolder);
       if (parameters) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/mysql2",
-  "version": "3.24.0-depup.0",
+  "version": "3.24.2-depup.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS (with updated dependencies)",
   "main": "index.js",
   "typings": "typings/mysql/index",
@@ -95,8 +95,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "mysql2",
-    "originalVersion": "3.24.0",
-    "processedAt": "2026-08-24T00:15:48.665Z",
+    "originalVersion": "3.24.2",
+    "processedAt": "2026-08-24T16:12:32.885Z",
     "smokeTest": "passed"
   }
 }