mysql2 3.3.4 → 3.4.0

package/index.d.ts

@@ -1,11 +1,11 @@
+import * as mysql from './typings/mysql/index.js';
 import {
   Connection as PromiseConnection,
   Pool as PromisePool,
   PoolConnection as PromisePoolConnection,
-} from './promise';
+} from './promise.js';
 
-import * as mysql from './typings/mysql';
-export * from './typings/mysql';
+export * from './typings/mysql/index.js';
 
 export interface Connection extends mysql.Connection {
   execute<
@@ -72,7 +72,13 @@ export interface Connection extends mysql.Connection {
   ): mysql.Query;
   ping(callback?: (err: mysql.QueryError | null) => any): void;
   unprepare(sql: string): mysql.PrepareStatementInfo;
-  prepare(sql: string, callback?: (err: mysql.QueryError | null, statement: mysql.PrepareStatementInfo) => any): mysql.Prepare;
+  prepare(
+    sql: string,
+    callback?: (
+      err: mysql.QueryError | null,
+      statement: mysql.PrepareStatementInfo
+    ) => any
+  ): mysql.Prepare;
   serverHandshake(args: any): any;
   writeOk(args?: mysql.OkPacketParams): void;
   writeError(args?: mysql.ErrorPacketParams): void;
@@ -154,12 +160,19 @@ export interface Pool extends mysql.Connection {
     callback: (err: NodeJS.ErrnoException, connection: PoolConnection) => any
   ): void;
   releaseConnection(connection: PoolConnection | PromisePoolConnection): void;
+  on(event: string, listener: (args: any[]) => void): this;
   on(event: 'connection', listener: (connection: PoolConnection) => any): this;
   on(event: 'acquire', listener: (connection: PoolConnection) => any): this;
   on(event: 'release', listener: (connection: PoolConnection) => any): this;
   on(event: 'enqueue', listener: () => any): this;
   unprepare(sql: string): mysql.PrepareStatementInfo;
-  prepare(sql: string, callback?: (err: mysql.QueryError | null, statement: mysql.PrepareStatementInfo) => any): mysql.Prepare;
+  prepare(
+    sql: string,
+    callback?: (
+      err: mysql.QueryError | null,
+      statement: mysql.PrepareStatementInfo
+    ) => any
+  ): mysql.Prepare;
   promise(promiseImpl?: PromiseConstructor): PromisePool;
   config: mysql.PoolOptions;
 }
@@ -195,7 +208,14 @@ export interface ConnectionConfig extends ConnectionOptions {
   getDefaultFlags(options?: ConnectionOptions): string[];
   getCharsetNumber(charset: string): number;
   getSSLProfile(name: string): { ca: string[] };
-  parseUrl(url: string): { host: string, port: number, database: string, user: string, password: string, [key: string]: any };
+  parseUrl(url: string): {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    [key: string]: any;
+  };
 }
 
 export interface PoolOptions extends mysql.PoolOptions, ConnectionOptions {}

package/lib/connection.js

@@ -54,7 +54,9 @@ class Connection extends EventEmitter {
 
         // Optionally enable keep-alive on the socket.
         if (this.config.enableKeepAlive) {
-          this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay);
+          this.stream.on('connect', () => {
+            this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay);
+          });
         }
 
         // Enable TCP_NODELAY flag. This is needed so that the network packets

package/lib/packets/resultset_header.js

@@ -50,6 +50,7 @@ class ResultSetHeader {
           stateChanges = {
             systemVariables: {},
             schema: null,
+            gtids: [],
             trackStateChange: null
           };
         }
@@ -72,6 +73,12 @@ class ResultSetHeader {
             stateChanges.trackStateChange = packet.readLengthCodedString(
               encoding
             );
+          } else if (type === sessionInfoTypes.STATE_GTIDS) {
+            // TODO: find if the first length coded string means anything. Usually comes as empty
+            // eslint-disable-next-line no-unused-vars
+            const _unknownString = packet.readLengthCodedString(encoding);
+            const gtid = packet.readLengthCodedString(encoding);
+            stateChanges.gtids = gtid.split(',');
           } else {
             // unsupported session track type. For now just ignore
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.3.4",
+  "version": "3.4.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "directories": {
@@ -9,7 +9,7 @@
   "typings": "typings/mysql/index",
   "scripts": {
     "lint": "npm run lint:docs && npm run lint:code",
-    "lint:code": "eslint index.js promise.js \"lib/**/*.js\" \"test/**/*.js\" \"benchmarks/**/*.js\"",
+    "lint:code": "eslint index.js promise.js index.d.ts promise.d.ts \"typings/**/*.ts\" \"lib/**/*.js\" \"test/**/*.{js,ts}\" \"benchmarks/**/*.js\"",
     "lint:docs": "eslint Contributing.md README.md \"documentation/**/*.md\" \"examples/*.js\"",
     "test": "node ./test/run.js",
     "test:tsc-build": "cd \"test/tsc-build\" && npx tsc -p \"tsconfig.json\"",
@@ -19,8 +19,7 @@
     "prettier:docs": "prettier --single-quote --trailing-comma none --write README.md documentation/*",
     "precommit": "lint-staged",
     "eslint-check": "eslint --print-config .eslintrc | eslint-config-prettier-check",
-    "wait-port": "wait-on",
-    "type-test": "node ./node_modules/typescript/bin/tsc -p tests.json && mocha typings/test --timeout 10000"
+    "wait-port": "wait-on"
   },
   "lint-staged": {
     "*.js": [
@@ -67,15 +66,12 @@
     "sqlstring": "^2.3.2"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.4",
-    "@types/mocha": "^10.0.0",
     "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^5.42.1",
     "@typescript-eslint/parser": "^5.42.1",
     "assert-diff": "^3.0.2",
     "benchmark": "^2.1.4",
-    "c8": "^7.10.0",
-    "chai": "^4.3.7",
+    "c8": "^8.0.0",
     "error-stack-parser": "^2.0.3",
     "eslint": "^8.27.0",
     "eslint-config-prettier": "^8.5.0",
@@ -83,7 +79,6 @@
     "eslint-plugin-markdown": "^3.0.0",
     "husky": "^8.0.2",
     "lint-staged": "^13.0.3",
-    "mocha": "^10.0.0",
     "portfinder": "^1.0.28",
     "prettier": "^2.4.1",
     "progress": "^2.0.3",

package/promise.d.ts

@@ -1,3 +1,5 @@
+import { EventEmitter } from 'events';
+
 import {
   RowDataPacket,
   OkPacket,
@@ -6,64 +8,134 @@ import {
   QueryOptions,
   ConnectionOptions,
   PoolOptions,
-  Pool as CorePool
-} from './index';
-
-import { EventEmitter } from 'events';
-export * from './index';
-
-export interface Connection extends EventEmitter {
-  config: ConnectionOptions;
-  threadId: number;
-
-  connect(): Promise<void>;
-  ping(): Promise<void>;
+  Pool as CorePool,
+} from './index.js';
 
-  beginTransaction(): Promise<void>;
-  commit(): Promise<void>;
-  rollback(): Promise<void>;
+export * from './index.js';
 
-  changeUser(options: ConnectionOptions): Promise<void>;
+export interface PreparedStatementInfo {
+  close(): Promise<void>;
+  execute(
+    parameters: any[]
+  ): Promise<
+    [
+      (
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+      ),
+      FieldPacket[]
+    ]
+  >;
+}
 
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+export interface Connection extends EventEmitter {
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     sql: string,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
 
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     sql: string,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
 
+  config: ConnectionOptions;
+
+  threadId: number;
+
+  connect(): Promise<void>;
+
+  ping(): Promise<void>;
+
+  beginTransaction(): Promise<void>;
+
+  commit(): Promise<void>;
+
+  rollback(): Promise<void>;
+
+  changeUser(options: ConnectionOptions): Promise<void>;
+
   prepare(options: string | QueryOptions): Promise<PreparedStatementInfo>;
+
   unprepare(sql: string | QueryOptions): void;
 
   end(options?: any): Promise<void>;
@@ -88,57 +160,110 @@ export interface PoolConnection extends Connection {
 }
 
 export interface Pool extends EventEmitter, Connection {
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     sql: string,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
+  query<
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
+  >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
 
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     sql: string,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
+    T extends
+      | RowDataPacket[][]
+      | RowDataPacket[]
+      | OkPacket
+      | OkPacket[]
+      | ResultSetHeader
   >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }
   ): Promise<[T, FieldPacket[]]>;
 
   getConnection(): Promise<PoolConnection>;
+
   releaseConnection(connection: PoolConnection): void;
+
   on(event: 'connection', listener: (connection: PoolConnection) => any): this;
   on(event: 'acquire', listener: (connection: PoolConnection) => any): this;
   on(event: 'release', listener: (connection: PoolConnection) => any): this;
   on(event: 'enqueue', listener: () => any): this;
+
   end(): Promise<void>;
 
   escape(value: any): string;
+
   escapeId(value: string): string;
   escapeId(values: string[]): string;
+
   format(sql: string, values?: any | any[] | { [param: string]: any }): string;
-  
+
   pool: CorePool;
 }
 
@@ -146,10 +271,6 @@ export function createConnection(connectionUri: string): Promise<Connection>;
 export function createConnection(
   config: ConnectionOptions
 ): Promise<Connection>;
+
 export function createPool(connectionUri: string): Pool;
 export function createPool(config: PoolOptions): Pool;
-
-export interface PreparedStatementInfo {
-  close(): Promise<void>;
-  execute(parameters: any[]): Promise<[RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader, FieldPacket[]]>;
-}

package/typings/mysql/index.d.ts

@@ -1,50 +1,45 @@
-import * as crypto from 'crypto';
-
-import BaseConnection = require('./lib/Connection');
-import {ConnectionOptions, SslOptions} from './lib/Connection';
-import BasePoolConnection = require('./lib/PoolConnection');
-import BasePool = require('./lib/Pool');
-import {PoolOptions} from './lib/Pool';
-import BasePoolCluster = require('./lib/PoolCluster');
-import {PoolClusterOptions} from './lib/PoolCluster';
-import BaseQuery = require('./lib/protocol/sequences/Query');
-import BasePrepare = require('./lib/protocol/sequences/Prepare');
-import {QueryOptions, StreamOptions, QueryError} from './lib/protocol/sequences/Query';
-import {PrepareStatementInfo} from './lib/protocol/sequences/Prepare';
-import Server = require('./lib/Server');
-import { Pool as PromisePool, Connection as PromiseConnection } from '../../promise';
-
-export function createConnection(connectionUri: string): Connection;
-export function createConnection(config: BaseConnection.ConnectionOptions): Connection;
-export function createPool(config: BasePool.PoolOptions): BasePool;
-export function createPoolCluster(config?: BasePoolCluster.PoolClusterOptions): PoolCluster;
-export function escape(value: any): string;
-export function escapeId(value: any): string;
-export function format(sql: string): string;
-export function format(sql: string, values: any[], stringifyObjects?: boolean, timeZone?: string): string;
-export function format(sql: string, values: any, stringifyObjects?: boolean, timeZone?: string): string;
-export function raw(sql: string): {
-    toSqlString: () => string
-};
-export function createServer(handler: (conn: BaseConnection) => any): Server;
+import { RsaPublicKey, RsaPrivateKey, KeyLike } from 'crypto';
+import { Pool as BasePool, PoolOptions } from './lib/Pool.js';
+import {
+  Connection as BaseConnection,
+  ConnectionOptions,
+  SslOptions,
+} from './lib/Connection.js';
+import {
+  Query as BaseQuery,
+  QueryOptions,
+  QueryError,
+} from './lib/protocol/sequences/Query.js';
+import {
+  PoolCluster as BasePoolCluster,
+  PoolClusterOptions,
+} from './lib/PoolCluster.js';
+import { PoolConnection as BasePoolConnection } from './lib/PoolConnection.js';
+import {
+  Prepare as BasePrepare,
+  PrepareStatementInfo,
+} from './lib/protocol/sequences/Prepare.js';
+import { Server } from './lib/Server.js';
+import { Connection as PromiseConnection } from '../../promise.js';
 
 export {
-    ConnectionOptions,
-    SslOptions,
-    PoolOptions,
-    PoolClusterOptions,
-    QueryOptions,
-    QueryError,
-    PrepareStatementInfo
+  ConnectionOptions,
+  SslOptions,
+  PoolOptions,
+  PoolClusterOptions,
+  QueryOptions,
+  QueryError,
+  PrepareStatementInfo,
 };
-export * from './lib/protocol/packets/index';
+
+export * from './lib/protocol/packets/index.js';
 
 // Expose class interfaces
 export interface Connection extends BaseConnection {
   promise(promiseImpl?: PromiseConstructor): PromiseConnection;
 }
-export interface PoolConnection extends BasePoolConnection {}
 export interface Pool extends BasePool {}
+export interface PoolConnection extends BasePoolConnection {}
 export interface PoolCluster extends BasePoolCluster {}
 export interface Query extends BaseQuery {}
 export interface Prepare extends BasePrepare {}
@@ -56,23 +51,55 @@ export type AuthPlugin = (pluginMetadata: {
   pluginData: Buffer
 ) => Promise<string> | string | Buffer | Promise<Buffer> | null;
 
-type AuthPluginDefinition<T> = (pluginOptions?: T) => AuthPlugin
+type AuthPluginDefinition<T> = (pluginOptions?: T) => AuthPlugin;
 
 export const authPlugins: {
   caching_sha2_password: AuthPluginDefinition<{
-    overrideIsSecure?: boolean,
-    serverPublicKey?: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike,
+    overrideIsSecure?: boolean;
+    serverPublicKey?: RsaPublicKey | RsaPrivateKey | KeyLike;
     jonServerPublicKey?: (data: Buffer) => void;
-  }>,
+  }>;
   mysql_clear_password: AuthPluginDefinition<{
     password?: string;
-  }>,
+  }>;
   mysql_native_password: AuthPluginDefinition<{
     password?: string;
     passwordSha1?: string;
-  }>,
+  }>;
   sha256_password: AuthPluginDefinition<{
-    serverPublicKey?: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike,
+    serverPublicKey?: RsaPublicKey | RsaPrivateKey | KeyLike;
     joinServerPublicKey?: (data: Buffer) => void;
-  }>,
-}
+  }>;
+};
+
+export function createConnection(connectionUri: string): Connection;
+export function createConnection(config: ConnectionOptions): Connection;
+
+export function createPool(config: PoolOptions): BasePool;
+
+export function createPoolCluster(config?: PoolClusterOptions): PoolCluster;
+
+export function escape(value: any): string;
+
+export function escapeId(value: any): string;
+
+export function format(sql: string): string;
+export function format(
+  sql: string,
+  values: any[],
+  stringifyObjects?: boolean,
+  timeZone?: string
+): string;
+
+export function format(
+  sql: string,
+  values: any,
+  stringifyObjects?: boolean,
+  timeZone?: string
+): string;
+
+export function raw(sql: string): {
+  toSqlString: () => string;
+};
+
+export function createServer(handler: (conn: BaseConnection) => any): Server;