mysql2 3.7.1 → 3.9.0

package/lib/commands/query.js

@@ -279,7 +279,7 @@ class Query extends Command {
     });
     this.on('end', () => {
       stream.push(null); // pushing null, indicating EOF
-      stream.emit('close'); // notify readers that query has completed
+      setImmediate(() => stream.emit('close')); // notify readers that query has completed
     });
     this.on('fields', fields => {
       stream.emit('fields', fields); // replicate old emitter

package/lib/parsers/binary_parser.js

@@ -80,12 +80,35 @@ function readCodeFor(field, config, options, fieldNum) {
 
 function compile(fields, options, config) {
   const parserFn = genFunc();
-  let i = 0;
   const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
 
-  /* eslint-disable no-trailing-spaces */
-  /* eslint-disable no-spaced-func */
-  /* eslint-disable no-unexpected-multiline */
+  function wrap(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();
+      },
+    };
+  }
 
   parserFn('(function(){');
   parserFn('return class BinaryRow {');
@@ -96,24 +119,19 @@ function compile(fields, options, config) {
   if (options.rowsAsArray) {
     parserFn(`const result = new Array(${fields.length});`);
   } else {
-    parserFn("const result = {};");
+    parserFn('const result = {};');
   }
 
-  const resultTables = {};
-  let resultTablesArray = [];
-
-  if (options.nestTables === true) {
-    for (i = 0; i < fields.length; i++) {
-      resultTables[fields[i].table] = 1;
-    }
-    resultTablesArray = Object.keys(resultTables);
-    for (i = 0; i < resultTablesArray.length; i++) {
-      parserFn(`result[${helpers.srcEscape(resultTablesArray[i])}] = {};`);
-    }
+  // Global typeCast
+  if (
+    typeof config.typeCast === 'function' &&
+    typeof options.typeCast !== 'function'
+  ) {
+    options.typeCast = config.typeCast;
   }
 
   parserFn('packet.readInt8();'); // status byte
-  for (i = 0; i < nullBitmapLength; ++i) {
+  for (let i = 0; i < nullBitmapLength; ++i) {
     parserFn(`const nullBitmaskByte${i} = packet.readInt8();`);
   }
 
@@ -123,38 +141,44 @@ function compile(fields, options, config) {
   let fieldName = '';
   let tableName = '';
 
-  for (i = 0; i < fields.length; i++) {
+  for (let i = 0; i < fields.length; i++) {
     fieldName = helpers.srcEscape(fields[i].name);
     parserFn(`// ${fieldName}: ${typeNames[fields[i].columnType]}`);
 
     if (typeof options.nestTables === 'string') {
-      tableName = helpers.srcEscape(fields[i].table);
       lvalue = `result[${helpers.srcEscape(
-        fields[i].table + options.nestTables + fields[i].name
+        fields[i].table + options.nestTables + fields[i].name,
       )}]`;
     } else if (options.nestTables === true) {
       tableName = helpers.srcEscape(fields[i].table);
+      parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`);
       lvalue = `result[${tableName}][${fieldName}]`;
     } else if (options.rowsAsArray) {
       lvalue = `result[${i.toString(10)}]`;
     } else {
-      lvalue = `result[${helpers.srcEscape(fields[i].name)}]`;
+      lvalue = `result[${fieldName}]`;
+    }
+
+    if (options.typeCast === false) {
+      parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
+    } else {
+      const fieldWrapperVar = `fieldWrapper${i}`;
+      parserFn(`const ${fieldWrapperVar} = wrap(fields[${i}], packet);`);
+      const readCode = readCodeFor(fields[i], config, options, i);
+
+      parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit})`);
+      parserFn(`${lvalue} = null;`);
+      parserFn('else {');
+      if (typeof options.typeCast === 'function') {
+        parserFn(
+          `${lvalue} = options.typeCast(${fieldWrapperVar}, function() { return ${readCode} });`,
+        );
+      } else {
+        parserFn(`${lvalue} = ${readCode};`);
+      }
+      parserFn('}');
     }
 
-    // TODO: this used to be an optimisation ( if column marked as NOT_NULL don't include code to check null
-    // bitmap at all, but it seems that we can't rely on this flag, see #178
-    // TODO: benchmark performance difference
-    //
-    // if (fields[i].flags & FieldFlags.NOT_NULL) { // don't need to check null bitmap if field can't be null.
-    //  result.push(lvalue + ' = ' + readCodeFor(fields[i], config));
-    // } else if (fields[i].columnType == Types.NULL) {
-    //  result.push(lvalue + ' = null;');
-    // } else {
-    parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit})`);
-    parserFn(`${lvalue} = null;`);
-    parserFn('else');
-    parserFn(`${lvalue} = ${readCodeFor(fields[i], config, options, i)}`);
-    // }
     currentFieldNullBit *= 2;
     if (currentFieldNullBit === 0x100) {
       currentFieldNullBit = 1;
@@ -166,17 +190,13 @@ function compile(fields, options, config) {
   parserFn('}');
   parserFn('};')('})()');
 
-  /* eslint-enable no-trailing-spaces */
-  /* eslint-enable no-spaced-func */
-  /* eslint-enable no-unexpected-multiline */
-
   if (config.debug) {
     helpers.printDebugWithCode(
       'Compiled binary protocol row parser',
-      parserFn.toString()
+      parserFn.toString(),
     );
   }
-  return parserFn.toFunction();
+  return parserFn.toFunction({ wrap });
 }
 
 function getBinaryParser(fields, options, config) {

package/lib/parsers/string.js

@@ -1,13 +1,34 @@
 'use strict';
 
 const Iconv = require('iconv-lite');
+const LRU = require('lru-cache').default;
 
-exports.decode = function(buffer, encoding, start, end, options) {
+const decoderCache = new LRU({
+  max: 500,
+});
+
+exports.decode = function (buffer, encoding, start, end, options) {
   if (Buffer.isEncoding(encoding)) {
     return buffer.toString(encoding, start, end);
   }
 
-  const decoder = Iconv.getDecoder(encoding, options || {});
+  // Optimize for common case: encoding="short_string", options=undefined.
+  let decoder;
+  if (!options) {
+    decoder = decoderCache.get(encoding);
+    if (!decoder) {
+      decoder = Iconv.getDecoder(encoding);
+      decoderCache.set(encoding, decoder);
+    }
+  } else {
+    const decoderArgs = { encoding, options };
+    const decoderKey = JSON.stringify(decoderArgs);
+    decoder = decoderCache.get(decoderKey);
+    if (!decoder) {
+      decoder = Iconv.getDecoder(decoderArgs.encoding, decoderArgs.options);
+      decoderCache.set(decoderKey, decoder);
+    }
+  }
 
   const res = decoder.write(buffer.slice(start, end));
   const trail = decoder.end();
@@ -15,7 +36,7 @@ exports.decode = function(buffer, encoding, start, end, options) {
   return trail ? res + trail : res;
 };
 
-exports.encode = function(string, encoding, options) {
+exports.encode = function (string, encoding, options) {
   if (Buffer.isEncoding(encoding)) {
     return Buffer.from(string, encoding);
   }

package/lib/pool.js

@@ -100,6 +100,7 @@ class Pool extends EventEmitter {
 
   end(cb) {
     this._closed = true;
+    clearTimeout(this._removeIdleTimeoutConnectionsTimer);
     if (typeof cb !== 'function') {
       cb = function(err) {
         if (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",
@@ -76,7 +76,7 @@
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-async-await": "0.0.0",
     "eslint-plugin-markdown": "^3.0.0",
-    "husky": "^8.0.2",
+    "husky": "^9.0.2",
     "lint-staged": "^15.0.1",
     "portfinder": "^1.0.28",
     "prettier": "^3.0.0",

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

@@ -19,6 +19,7 @@ import { Connection as PromiseConnection } from '../../../promise.js';
 import { AuthPlugin } from './Auth.js';
 import { QueryableBase } from './protocol/sequences/QueryableBase.js';
 import { ExecutableBase } from './protocol/sequences/ExecutableBase.js';
+import { TypeCast } from './parsers/typeCast.js';
 
 export interface SslOptions {
   /**
@@ -172,26 +173,44 @@ export interface ConnectionOptions {
   infileStreamFactory?: (path: string) => Readable;
 
   /**
-   * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
-   * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
+   * Determines if column values should be converted to native JavaScript types.
    *
-   * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
+   * @default true
    *
-   * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
+   * It is not recommended (and may go away / change in the future) to disable type casting, but you can currently do so on either the connection or query level.
    *
-   * field.string()
-   * field.buffer()
-   * field.geometry()
+   * ---
    *
-   * are aliases for
+   * You can also specify a function to do the type casting yourself:
+   * ```ts
+   * (field: Field, next: () => void) => {
+   *   return next();
+   * }
+   * ```
    *
-   * parser.parseLengthCodedString()
-   * parser.parseLengthCodedBuffer()
-   * parser.parseGeometryValue()
+   * ---
    *
-   * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
+   * **WARNING:**
+   *
+   * YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once:
+   *
+   * ```js
+   * field.string();
+   * field.buffer();
+   * field.geometry();
+   * ```
+
+   * Which are aliases for:
+   *
+   * ```js
+   * parser.parseLengthCodedString();
+   * parser.parseLengthCodedBuffer();
+   * parser.parseGeometryValue();
+   * ```
+   *
+   * You can find which field function you need to use by looking at `RowDataPacket.prototype._typeCast`.
    */
-  typeCast?: boolean | ((field: any, next: () => void) => any);
+  typeCast?: TypeCast;
 
   /**
    * A custom query format function

package/typings/mysql/lib/parsers/typeCast.d.ts

@@ -0,0 +1,53 @@
+type Geometry = {
+  x: number;
+  y: number;
+};
+
+type Type = {
+  type:
+    | 'DECIMAL'
+    | 'TINY'
+    | 'SHORT'
+    | 'LONG'
+    | 'FLOAT'
+    | 'DOUBLE'
+    | 'NULL'
+    | 'TIMESTAMP'
+    | 'TIMESTAMP2'
+    | 'LONGLONG'
+    | 'INT24'
+    | 'DATE'
+    | 'TIME'
+    | 'TIME2'
+    | 'DATETIME'
+    | 'DATETIME2'
+    | 'YEAR'
+    | 'NEWDATE'
+    | 'VARCHAR'
+    | 'BIT'
+    | 'JSON'
+    | 'NEWDECIMAL'
+    | 'ENUM'
+    | 'SET'
+    | 'TINY_BLOB'
+    | 'MEDIUM_BLOB'
+    | 'LONG_BLOB'
+    | 'BLOB'
+    | 'VAR_STRING'
+    | 'STRING'
+    | 'GEOMETRY';
+};
+
+type Field = Type & {
+  length: number;
+  db: string;
+  table: string;
+  name: string;
+  string: () => string | null;
+  buffer: () => Buffer | null;
+  geometry: () => Geometry | Geometry[] | null;
+};
+
+type Next = () => void;
+
+export type TypeCast = ((field: Field, next: Next) => any) | boolean;

package/typings/mysql/lib/protocol/sequences/Query.d.ts

@@ -1,6 +1,7 @@
 import { Sequence } from './Sequence.js';
 import { OkPacket, RowDataPacket, FieldPacket } from '../packets/index.js';
 import { Readable } from 'stream';
+import { TypeCast } from '../../parsers/typeCast.js';
 
 export interface QueryOptions {
   /**
@@ -33,26 +34,44 @@ export interface QueryOptions {
   nestTables?: any;
 
   /**
-   * Determines if column values should be converted to native JavaScript types. It is not recommended (and may go away / change in the future)
-   * to disable type casting, but you can currently do so on either the connection or query level. (Default: true)
+   * Determines if column values should be converted to native JavaScript types.
    *
-   * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
+   * @default true
    *
-   * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
+   * It is not recommended (and may go away / change in the future) to disable type casting, but you can currently do so on either the connection or query level.
    *
-   * field.string()
-   * field.buffer()
-   * field.geometry()
+   * ---
    *
-   * are aliases for
+   * You can also specify a function to do the type casting yourself:
+   * ```ts
+   * (field: Field, next: () => void) => {
+   *   return next();
+   * }
+   * ```
    *
-   * parser.parseLengthCodedString()
-   * parser.parseLengthCodedBuffer()
-   * parser.parseGeometryValue()
+   * ---
    *
-   * You can find which field function you need to use by looking at: RowDataPacket.prototype._typeCast
+   * **WARNING:**
+   *
+   * YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once:
+   *
+   * ```js
+   * field.string();
+   * field.buffer();
+   * field.geometry();
+   * ```
+
+   * Which are aliases for:
+   *
+   * ```js
+   * parser.parseLengthCodedString();
+   * parser.parseLengthCodedBuffer();
+   * parser.parseGeometryValue();
+   * ```
+   *
+   * You can find which field function you need to use by looking at `RowDataPacket.prototype._typeCast`.
    */
-  typeCast?: any;
+  typeCast?: TypeCast;
 
   /**
    * This overrides the same option set at the connection level.
@@ -137,11 +156,11 @@ declare class Query extends Sequence {
   on(event: 'error', listener: (err: QueryError) => any): this;
   on(
     event: 'fields',
-    listener: (fields: FieldPacket, index: number) => any
+    listener: (fields: FieldPacket, index: number) => any,
   ): this;
   on(
     event: 'result',
-    listener: (result: RowDataPacket | OkPacket, index: number) => any
+    listener: (result: RowDataPacket | OkPacket, index: number) => any,
   ): this;
   on(event: 'end', listener: () => any): this;
 }