mysql2 3.12.0 → 3.12.1-canary.51da6534

package/lib/commands/execute.js

@@ -5,6 +5,7 @@ const Query = require('./query.js');
 const Packets = require('../packets/index.js');
 
 const getBinaryParser = require('../parsers/binary_parser.js');
+const getStaticBinaryParser = require('../parsers/static_binary_parser.js');
 
 class Execute extends Command {
   constructor(options, callback) {
@@ -25,12 +26,16 @@ class Execute extends Command {
     this._executeOptions = options;
     this._resultIndex = 0;
     this._localStream = null;
-    this._unpipeStream = function() {};
+    this._unpipeStream = function () {};
     this._streamFactory = options.infileStreamFactory;
     this._connection = null;
   }
 
   buildParserFromFields(fields, connection) {
+    if (this.options.disableEval) {
+      return getStaticBinaryParser(fields, this.options, connection.config);
+    }
+
     return getBinaryParser(fields, this.options, connection.config);
   }
 
@@ -42,7 +47,7 @@ class Execute extends Command {
       this.statement.id,
       this.parameters,
       connection.config.charsetNumber,
-      connection.config.timezone
+      connection.config.timezone,
     );
     //For reasons why this try-catch is here, please see
     // https://github.com/sidorares/node-mysql2/pull/689
@@ -68,7 +73,7 @@ class Execute extends Command {
     //  this.statement.columns[this._receivedFieldsCount] : new Packets.ColumnDefinition(packet);
     const field = new Packets.ColumnDefinition(
       packet,
-      connection.clientEncoding
+      connection.clientEncoding,
     );
     this._receivedFieldsCount++;
     this._fields[this._resultIndex].push(field);
@@ -87,7 +92,7 @@ class Execute extends Command {
     }
     this._rowParser = new (this.buildParserFromFields(
       this._fields[this._resultIndex],
-      connection
+      connection,
     ))();
     return Execute.prototype.row;
   }

package/lib/commands/query.js

@@ -8,6 +8,7 @@ const Readable = require('stream').Readable;
 const Command = require('./command.js');
 const Packets = require('../packets/index.js');
 const getTextParser = require('../parsers/text_parser.js');
+const staticParser = require('../parsers/static_text_parser.js');
 const ServerStatus = require('../constants/server_status.js');
 
 const EmptyPacket = new Packets.Packet(0, Buffer.allocUnsafe(4), 0, 4);
@@ -30,7 +31,7 @@ class Query extends Command {
     this._receivedFieldsCount = 0;
     this._resultIndex = 0;
     this._localStream = null;
-    this._unpipeStream = function () { };
+    this._unpipeStream = function () {};
     this._streamFactory = options.infileStreamFactory;
     this._connection = null;
   }
@@ -55,7 +56,7 @@ class Query extends Command {
 
     const cmdPacket = new Packets.Query(
       this.sql,
-      connection.config.charsetNumber
+      connection.config.charsetNumber,
     );
     connection.writePacket(cmdPacket.toPacket(1));
     return Query.prototype.resultsetHeader;
@@ -120,7 +121,7 @@ class Query extends Command {
     if (connection.config.debug) {
       // eslint-disable-next-line
       console.log(
-        `        Resultset header received, expecting ${rs.fieldCount} column definition packets`
+        `        Resultset header received, expecting ${rs.fieldCount} column definition packets`,
       );
     }
     if (this._fieldCount === 0) {
@@ -140,7 +141,7 @@ class Query extends Command {
       this._localStream = this._streamFactory(path);
     } else {
       this._localStreamError = new Error(
-        `As a result of LOCAL INFILE command server wants to read ${path} file, but as of v2.0 you must provide streamFactory option returning ReadStream.`
+        `As a result of LOCAL INFILE command server wants to read ${path} file, but as of v2.0 you must provide streamFactory option returning ReadStream.`,
       );
       connection.writePacket(EmptyPacket);
       return this.infileOk;
@@ -159,14 +160,14 @@ class Query extends Command {
       const dataWithHeader = Buffer.allocUnsafe(data.length + 4);
       data.copy(dataWithHeader, 4);
       connection.writePacket(
-        new Packets.Packet(0, dataWithHeader, 0, dataWithHeader.length)
+        new Packets.Packet(0, dataWithHeader, 0, dataWithHeader.length),
       );
     };
     const onEnd = () => {
       connection.removeListener('error', onConnectionError);
       connection.writePacket(EmptyPacket);
     };
-    const onError = err => {
+    const onError = (err) => {
       this._localStreamError = err;
       connection.removeListener('error', onConnectionError);
       connection.writePacket(EmptyPacket);
@@ -196,7 +197,7 @@ class Query extends Command {
     if (this._fields[this._resultIndex].length !== this._fieldCount) {
       const field = new Packets.ColumnDefinition(
         packet,
-        connection.clientEncoding
+        connection.clientEncoding,
       );
       this._fields[this._resultIndex].push(field);
       if (connection.config.debug) {
@@ -212,7 +213,15 @@ class Query extends Command {
     if (this._receivedFieldsCount === this._fieldCount) {
       const fields = this._fields[this._resultIndex];
       this.emit('fields', fields);
-      this._rowParser = new (getTextParser(fields, this.options, connection.config))(fields);
+      if (this.options.disableEval) {
+        this._rowParser = staticParser(fields, this.options, connection.config);
+      } else {
+        this._rowParser = new (getTextParser(
+          fields,
+          this.options,
+          connection.config,
+        ))(fields);
+      }
       return Query.prototype.fieldsEOF;
     }
     return Query.prototype.readField;
@@ -242,7 +251,7 @@ class Query extends Command {
       row = this._rowParser.next(
         packet,
         this._fields[this._resultIndex],
-        this.options
+        this.options,
       );
     } catch (err) {
       this._localStreamError = err;
@@ -274,13 +283,13 @@ class Query extends Command {
       }
       stream.emit('result', row, resultSetIndex); // replicate old emitter
     });
-    this.on('error', err => {
+    this.on('error', (err) => {
       stream.emit('error', err); // Pass on any errors
     });
     this.on('end', () => {
       stream.push(null); // pushing null, indicating EOF
     });
-    this.on('fields', fields => {
+    this.on('fields', (fields) => {
       stream.emit('fields', fields); // replicate old emitter
     });
     stream.on('end', () => {
@@ -292,10 +301,7 @@ class Query extends Command {
   _setTimeout() {
     if (this.timeout) {
       const timeoutHandler = this._handleTimeoutError.bind(this);
-      this.queryTimeout = Timers.setTimeout(
-        timeoutHandler,
-        this.timeout
-      );
+      this.queryTimeout = Timers.setTimeout(timeoutHandler, this.timeout);
     }
   }
 

package/lib/connection_config.js

@@ -10,7 +10,7 @@
 const { URL } = require('url');
 const ClientConstants = require('./constants/client');
 const Charsets = require('./constants/charsets');
-const { version } = require('../package.json')
+const { version } = require('../package.json');
 let SSLProfiles = null;
 
 const validOptions = {
@@ -59,6 +59,7 @@ const validOptions = {
   typeCast: 1,
   uri: 1,
   user: 1,
+  disableEval: 1,
   // These options are used for Pool
   connectionLimit: 1,
   maxIdle: 1,
@@ -66,7 +67,7 @@ const validOptions = {
   Promise: 1,
   queueLimit: 1,
   waitForConnections: 1,
-  jsonStrings: 1
+  jsonStrings: 1,
 };
 
 class ConnectionConfig {
@@ -87,14 +88,17 @@ class ConnectionConfig {
         // REVIEW: Should this be emitted somehow?
         // eslint-disable-next-line no-console
         console.error(
-          `Ignoring invalid configuration option passed to Connection: ${key}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`
+          `Ignoring invalid configuration option passed to Connection: ${key}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`,
         );
       }
     }
     this.isServer = options.isServer;
     this.stream = options.stream;
     this.host = options.host || 'localhost';
-    this.port = (typeof options.port === 'string' ? parseInt(options.port, 10) : 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;
@@ -128,7 +132,7 @@ class ConnectionConfig {
       // https://github.com/mysqljs/mysql#user-content-connection-options
       // eslint-disable-next-line no-console
       console.error(
-        `Ignoring invalid timezone passed to Connection: ${options.timezone}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`
+        `Ignoring invalid timezone passed to Connection: ${options.timezone}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`,
       );
       // SqlStrings falls back to UTC on invalid timezone
       this.timezone = 'Z';
@@ -147,6 +151,7 @@ class ConnectionConfig {
     this.nestTables =
       options.nestTables === undefined ? undefined : options.nestTables;
     this.typeCast = options.typeCast === undefined ? true : options.typeCast;
+    this.disableEval = Boolean(options.disableEval);
     if (this.timezone[0] === ' ') {
       // "+" is a url encoded char for space so it
       // gets translated to space when giving a
@@ -156,7 +161,7 @@ class ConnectionConfig {
     if (this.ssl) {
       if (typeof this.ssl !== 'object') {
         throw new TypeError(
-          `SSL profile must be an object, instead it's a ${typeof this.ssl}`
+          `SSL profile must be an object, instead it's a ${typeof this.ssl}`,
         );
       }
       // Default rejectUnauthorized to true
@@ -171,15 +176,18 @@ class ConnectionConfig {
     this.authSwitchHandler = options.authSwitchHandler;
     this.clientFlags = ConnectionConfig.mergeFlags(
       ConnectionConfig.getDefaultFlags(options),
-      options.flags || ''
+      options.flags || '',
     );
     // Default connection attributes
     // https://dev.mysql.com/doc/refman/8.0/en/performance-schema-connection-attribute-tables.html
-    const defaultConnectAttributes =  {
+    const defaultConnectAttributes = {
       _client_name: 'Node-MySQL-2',
-      _client_version: version
+      _client_version: version,
+    };
+    this.connectAttributes = {
+      ...defaultConnectAttributes,
+      ...(options.connectAttributes || {}),
     };
-    this.connectAttributes = { ...defaultConnectAttributes, ...(options.connectAttributes || {})};
     this.maxPreparedStatements = options.maxPreparedStatements || 16000;
     this.jsonStrings = options.jsonStrings || false;
   }
@@ -229,7 +237,7 @@ class ConnectionConfig {
       'MULTI_RESULTS',
       'TRANSACTIONS',
       'SESSION_TRACK',
-      'CONNECT_ATTRS'
+      'CONNECT_ATTRS',
     ];
     if (options && options.multipleStatements) {
       defaultFlags.push('MULTI_STATEMENTS');

package/lib/helpers.js

@@ -74,14 +74,13 @@ const privateObjectProps = new Set([
 
 exports.privateObjectProps = privateObjectProps;
 
-const fieldEscape = (field) => {
+const fieldEscape = (field, isEval = true) => {
   if (privateObjectProps.has(field)) {
     throw new Error(
       `The field name (${field}) can't be the same as an object's private property.`,
     );
   }
 
-  return srcEscape(field);
+  return isEval ? srcEscape(field) : field;
 };
-
 exports.fieldEscape = fieldEscape;

package/lib/parsers/static_binary_parser.js

@@ -0,0 +1,211 @@
+'use strict';
+
+const FieldFlags = require('../constants/field_flags.js');
+const Charsets = require('../constants/charsets.js');
+const Types = require('../constants/types.js');
+const helpers = require('../helpers');
+
+const typeNames = [];
+for (const t in Types) {
+  typeNames[Types[t]] = t;
+}
+
+function getBinaryParser(fields, _options, config) {
+  function readCode(field, config, options, fieldNum, packet) {
+    const supportBigNumbers = Boolean(
+      options.supportBigNumbers || config.supportBigNumbers,
+    );
+    const bigNumberStrings = Boolean(
+      options.bigNumberStrings || config.bigNumberStrings,
+    );
+    const timezone = options.timezone || config.timezone;
+    const dateStrings = options.dateStrings || config.dateStrings;
+    const unsigned = field.flags & FieldFlags.UNSIGNED;
+
+    switch (field.columnType) {
+      case Types.TINY:
+        return unsigned ? packet.readInt8() : packet.readSInt8();
+      case Types.SHORT:
+        return unsigned ? packet.readInt16() : packet.readSInt16();
+      case Types.LONG:
+      case Types.INT24: // in binary protocol int24 is encoded in 4 bytes int32
+        return unsigned ? packet.readInt32() : packet.readSInt32();
+      case Types.YEAR:
+        return packet.readInt16();
+      case Types.FLOAT:
+        return packet.readFloat();
+      case Types.DOUBLE:
+        return packet.readDouble();
+      case Types.NULL:
+        return null;
+      case Types.DATE:
+      case Types.DATETIME:
+      case Types.TIMESTAMP:
+      case Types.NEWDATE:
+        return helpers.typeMatch(field.columnType, dateStrings, Types)
+          ? packet.readDateTimeString(
+            parseInt(field.decimals, 10),
+            null,
+            field.columnType,
+          )
+          : packet.readDateTime(timezone);
+      case Types.TIME:
+        return packet.readTimeString();
+      case Types.DECIMAL:
+      case Types.NEWDECIMAL:
+        return config.decimalNumbers
+          ? packet.parseLengthCodedFloat()
+          : packet.readLengthCodedString('ascii');
+      case Types.GEOMETRY:
+        return packet.parseGeometryValue();
+      case Types.VECTOR:
+        return packet.parseVector();
+      case Types.JSON:
+        // Since for JSON columns mysql always returns charset 63 (BINARY),
+        // we have to handle it according to JSON specs and use "utf8",
+        // see https://github.com/sidorares/node-mysql2/issues/409
+        return config.jsonStrings
+          ? packet.readLengthCodedString('utf8')
+          : JSON.parse(packet.readLengthCodedString('utf8'));
+      case Types.LONGLONG:
+        if (!supportBigNumbers)
+          return unsigned
+            ? packet.readInt64JSNumber()
+            : packet.readSInt64JSNumber();
+        return bigNumberStrings
+          ? unsigned
+            ? packet.readInt64String()
+            : packet.readSInt64String()
+          : unsigned
+            ? packet.readInt64()
+            : packet.readSInt64();
+      default:
+        return field.characterSet === Charsets.BINARY
+          ? packet.readLengthCodedBuffer()
+          : packet.readLengthCodedString(fields[fieldNum].encoding);
+    }
+  }
+
+  return class BinaryRow {
+    constructor() {}
+
+    next(packet, fields, options) {
+      packet.readInt8(); // status byte
+
+      const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
+      const nullBitmaskBytes = new Array(nullBitmapLength);
+
+      for (let i = 0; i < nullBitmapLength; i++) {
+        nullBitmaskBytes[i] = packet.readInt8();
+      }
+
+      const result = options.rowsAsArray ? new Array(fields.length) : {};
+      let currentFieldNullBit = 4;
+      let nullByteIndex = 0;
+
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const typeCast =
+          options.typeCast !== undefined ? options.typeCast : config.typeCast;
+
+        let value;
+        if (nullBitmaskBytes[nullByteIndex] & currentFieldNullBit) {
+          value = null;
+        } else if (options.typeCast === false) {
+          value = packet.readLengthCodedBuffer();
+        } else {
+          const next = () => readCode(field, config, options, i, packet);
+          value =
+            typeof typeCast === 'function'
+              ? typeCast(
+                {
+                  type: typeNames[field.columnType],
+                  length: field.columnLength,
+                  db: field.schema,
+                  table: field.table,
+                  name: field.name,
+                  string: function (encoding = field.encoding) {
+                    if (
+                      field.columnType === Types.JSON &&
+                        encoding === field.encoding
+                    ) {
+                      // Since for JSON columns mysql always returns charset 63 (BINARY),
+                      // we have to handle it according to JSON specs and use "utf8",
+                      // see https://github.com/sidorares/node-mysql2/issues/1661
+                      console.warn(
+                        `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``,
+                      );
+                    }
+
+                    if (
+                      [
+                        Types.DATETIME,
+                        Types.NEWDATE,
+                        Types.TIMESTAMP,
+                        Types.DATE,
+                      ].includes(field.columnType)
+                    ) {
+                      return packet.readDateTimeString(
+                        parseInt(field.decimals, 10),
+                      );
+                    }
+
+                    if (field.columnType === Types.TINY) {
+                      const unsigned = field.flags & FieldFlags.UNSIGNED;
+
+                      return String(
+                        unsigned ? packet.readInt8() : packet.readSInt8(),
+                      );
+                    }
+
+                    if (field.columnType === Types.TIME) {
+                      return packet.readTimeString();
+                    }
+
+                    return packet.readLengthCodedString(encoding);
+                  },
+                  buffer: function () {
+                    return packet.readLengthCodedBuffer();
+                  },
+                  geometry: function () {
+                    return packet.parseGeometryValue();
+                  },
+                },
+                next,
+              )
+              : next();
+        }
+
+        if (options.rowsAsArray) {
+          result[i] = value;
+        } else if (typeof options.nestTables === 'string') {
+          const key = helpers.fieldEscape(
+            field.table + options.nestTables + field.name,
+            false,
+          );
+          result[key] = value;
+        } else if (options.nestTables === true) {
+          const tableName = helpers.fieldEscape(field.table, false);
+          if (!result[tableName]) {
+            result[tableName] = {};
+          }
+          const fieldName = helpers.fieldEscape(field.name, false);
+          result[tableName][fieldName] = value;
+        } else {
+          const key = helpers.fieldEscape(field.name, false);
+          result[key] = value;
+        }
+
+        currentFieldNullBit *= 2;
+        if (currentFieldNullBit === 0x100) {
+          currentFieldNullBit = 1;
+          nullByteIndex++;
+        }
+      }
+
+      return result;
+    }
+  };
+}
+
+module.exports = getBinaryParser;

package/lib/parsers/static_text_parser.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const Types = require('../constants/types.js');
+const Charsets = require('../constants/charsets.js');
+const helpers = require('../helpers');
+
+const typeNames = [];
+for (const t in Types) {
+  typeNames[Types[t]] = t;
+}
+
+function readField({ packet, type, charset, encoding, config, options }) {
+  const supportBigNumbers = Boolean(
+    options.supportBigNumbers || config.supportBigNumbers,
+  );
+  const bigNumberStrings = Boolean(
+    options.bigNumberStrings || config.bigNumberStrings,
+  );
+  const timezone = options.timezone || config.timezone;
+  const dateStrings = options.dateStrings || config.dateStrings;
+
+  switch (type) {
+    case Types.TINY:
+    case Types.SHORT:
+    case Types.LONG:
+    case Types.INT24:
+    case Types.YEAR:
+      return packet.parseLengthCodedIntNoBigCheck();
+    case Types.LONGLONG:
+      if (supportBigNumbers && bigNumberStrings) {
+        return packet.parseLengthCodedIntString();
+      }
+      return packet.parseLengthCodedInt(supportBigNumbers);
+    case Types.FLOAT:
+    case Types.DOUBLE:
+      return packet.parseLengthCodedFloat();
+    case Types.NULL:
+    case Types.DECIMAL:
+    case Types.NEWDECIMAL:
+      if (config.decimalNumbers) {
+        return packet.parseLengthCodedFloat();
+      }
+      return packet.readLengthCodedString('ascii');
+    case Types.DATE:
+      if (helpers.typeMatch(type, dateStrings, Types)) {
+        return packet.readLengthCodedString('ascii');
+      }
+      return packet.parseDate(timezone);
+    case Types.DATETIME:
+    case Types.TIMESTAMP:
+      if (helpers.typeMatch(type, dateStrings, Types)) {
+        return packet.readLengthCodedString('ascii');
+      }
+      return packet.parseDateTime(timezone);
+    case Types.TIME:
+      return packet.readLengthCodedString('ascii');
+    case Types.GEOMETRY:
+      return packet.parseGeometryValue();
+    case Types.JSON:
+      // Since for JSON columns mysql always returns charset 63 (BINARY),
+      // we have to handle it according to JSON specs and use "utf8",
+      // see https://github.com/sidorares/node-mysql2/issues/409
+      return config.jsonStrings
+        ? packet.readLengthCodedString('utf8')
+        : JSON.parse(packet.readLengthCodedString('utf8'));
+    default:
+      if (charset === Charsets.BINARY) {
+        return packet.readLengthCodedBuffer();
+      }
+      return packet.readLengthCodedString(encoding);
+  }
+}
+
+function createTypecastField(field, packet) {
+  return {
+    type: typeNames[field.columnType],
+    length: field.columnLength,
+    db: field.schema,
+    table: field.table,
+    name: field.name,
+    string: function (encoding = field.encoding) {
+      if (field.columnType === Types.JSON && encoding === field.encoding) {
+        // Since for JSON columns mysql always returns charset 63 (BINARY),
+        // we have to handle it according to JSON specs and use "utf8",
+        // see https://github.com/sidorares/node-mysql2/issues/1661
+        console.warn(
+          `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``,
+        );
+      }
+      return packet.readLengthCodedString(encoding);
+    },
+    buffer: function () {
+      return packet.readLengthCodedBuffer();
+    },
+    geometry: function () {
+      return packet.parseGeometryValue();
+    },
+  };
+}
+
+function getTextParser(_fields, _options, config) {
+  return {
+    next(packet, fields, options) {
+      const result = options.rowsAsArray ? [] : {};
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const typeCast = options.typeCast ? options.typeCast : config.typeCast;
+        const next = () =>
+          readField({
+            packet,
+            type: field.columnType,
+            encoding: field.encoding,
+            charset: field.characterSet,
+            config,
+            options,
+          });
+
+        let value;
+
+        if (options.typeCast === false) {
+          value = packet.readLengthCodedBuffer();
+        } else if (typeof typeCast === 'function') {
+          value = typeCast(createTypecastField(field, packet), next);
+        } else {
+          value = next();
+        }
+
+        if (options.rowsAsArray) {
+          result.push(value);
+        } else if (typeof options.nestTables === 'string') {
+          result[
+            `${helpers.fieldEscape(field.table, false)}${options.nestTables}${helpers.fieldEscape(field.name, false)}`
+          ] = value;
+        } else if (options.nestTables) {
+          const tableName = helpers.fieldEscape(field.table, false);
+          if (!result[tableName]) {
+            result[tableName] = {};
+          }
+          result[tableName][helpers.fieldEscape(field.name, false)] = value;
+        } else {
+          result[helpers.fieldEscape(field.name, false)] = value;
+        }
+      }
+
+      return result;
+    },
+  };
+}
+
+module.exports = getTextParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.12.0",
+  "version": "3.12.1-canary.51da6534",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",
@@ -8,12 +8,13 @@
   "scripts": {
     "lint": "npm run lint:docs && npm run lint:code",
     "lint:code": "eslint index.js promise.js index.d.ts promise.d.ts \"typings/**/*.ts\" \"lib/**/*.js\" \"test/**/*.{js,cjs,mjs,ts}\" \"benchmarks/**/*.js\"",
+    "lint:fix": "npm run lint:docs -- --fix &&npm run lint:code -- --fix",
     "lint:docs": "eslint Contributing.md README.md",
     "lint:typings": "npx prettier --check ./typings",
     "lint:tests": "npx prettier --check ./test",
-    "test": "poku -d test/esm test/unit test/integration",
-    "test:bun": "poku -d --bun test/esm test/unit test/integration",
-    "test:deno": "deno run --allow-read --allow-env --allow-run npm:poku -d --deno --denoAllow=\"read,env,net,sys\" test/esm test/unit test/integration",
+    "test": "poku -d -r=verbose --sequential test/esm test/unit test/integration",
+    "test:bun": "bun poku -d --sequential test/esm test/unit test/integration",
+    "test:deno": "deno run --allow-read --allow-env --allow-run npm:poku -d --sequential --denoAllow=\"read,env,net,sys\" test/esm test/unit test/integration",
     "test:tsc-build": "cd \"test/tsc-build\" && npx tsc -p \"tsconfig.json\"",
     "coverage-test": "c8 npm run test",
     "benchmark": "node ./benchmarks/benchmark.js",
@@ -78,11 +79,11 @@
     "c8": "^10.1.1",
     "error-stack-parser": "^2.0.3",
     "eslint": "^8.27.0",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-async-await": "0.0.0",
     "eslint-plugin-markdown": "^5.0.0",
     "lint-staged": "^15.0.1",
-    "poku": "^2.0.0",
+    "poku": "^3.0.0",
     "portfinder": "^1.0.28",
     "prettier": "^3.0.0",
     "progress": "^2.0.3",

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

@@ -323,6 +323,8 @@ export interface ConnectionOptions {
 
   waitForConnections?: boolean;
 
+  disableEval?: boolean;
+
   authPlugins?: {
     [key: string]: AuthPlugin;
   };