mysql2 3.3.5 → 3.4.1

package/index.d.ts

@@ -1,205 +1 @@
-import {
-  Connection as PromiseConnection,
-  Pool as PromisePool,
-  PoolConnection as PromisePoolConnection,
-} from './promise';
-
-import * as mysql from './typings/mysql';
-export * from './typings/mysql';
-
-export interface Connection extends mysql.Connection {
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    sql: string,
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    sql: string,
-    values: any | any[] | { [param: string]: any },
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    options: mysql.QueryOptions,
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields?: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    options: mysql.QueryOptions,
-    values: any | any[] | { [param: string]: any },
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): 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;
-  serverHandshake(args: any): any;
-  writeOk(args?: mysql.OkPacketParams): void;
-  writeError(args?: mysql.ErrorPacketParams): void;
-  writeEof(warnings?: number, statusFlags?: number): void;
-  writeTextResult(rows?: Array<any>, columns?: Array<any>): void;
-  writePacket(packet: any): void;
-  promise(promiseImpl?: PromiseConstructor): PromiseConnection;
-  sequenceId: number;
-}
-
-export interface PoolConnection extends mysql.PoolConnection {
-  promise(promiseImpl?: PromiseConstructor): PromisePool;
-}
-
-export interface Pool extends mysql.Connection {
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    sql: string,
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    sql: string,
-    values: any | any[] | { [param: string]: any },
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    options: mysql.QueryOptions,
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields?: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  execute<
-    T extends
-      | mysql.RowDataPacket[][]
-      | mysql.RowDataPacket[]
-      | mysql.OkPacket
-      | mysql.OkPacket[]
-      | mysql.ResultSetHeader
-  >(
-    options: mysql.QueryOptions,
-    values: any | any[] | { [param: string]: any },
-    callback?: (
-      err: mysql.QueryError | null,
-      result: T,
-      fields: mysql.FieldPacket[]
-    ) => any
-  ): mysql.Query;
-  getConnection(
-    callback: (err: NodeJS.ErrnoException, connection: PoolConnection) => any
-  ): void;
-  releaseConnection(connection: PoolConnection | PromisePoolConnection): 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;
-  unprepare(sql: string): mysql.PrepareStatementInfo;
-  prepare(sql: string, callback?: (err: mysql.QueryError | null, statement: mysql.PrepareStatementInfo) => any): mysql.Prepare;
-  promise(promiseImpl?: PromiseConstructor): PromisePool;
-  config: mysql.PoolOptions;
-}
-
-export interface ConnectionOptions extends mysql.ConnectionOptions {
-  charsetNumber?: number;
-  compress?: boolean;
-  authSwitchHandler?: (data: any, callback: () => void) => any;
-  connectAttributes?: { [param: string]: any };
-  decimalNumbers?: boolean;
-  isServer?: boolean;
-  maxPreparedStatements?: number;
-  namedPlaceholders?: boolean;
-  nestTables?: boolean | string;
-  passwordSha1?: string;
-  pool?: any;
-  rowsAsArray?: boolean;
-  stream?: any;
-  uri?: string;
-  connectionLimit?: number;
-  maxIdle?: number;
-  idleTimeout?: number;
-  Promise?: any;
-  queueLimit?: number;
-  waitForConnections?: boolean;
-  authPlugins?: {
-    [key: string]: mysql.AuthPlugin;
-  };
-}
-
-export interface ConnectionConfig extends ConnectionOptions {
-  mergeFlags(defaultFlags: string[], userFlags: string[] | string): number;
-  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 };
-}
-
-export interface PoolOptions extends mysql.PoolOptions, ConnectionOptions {}
-
-export function createConnection(connectionUri: string): Connection;
-export function createConnection(config: ConnectionOptions): Connection;
-export function createPool(config: PoolOptions): Pool;
+export * from './typings/mysql/index.js';

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.5",
+  "version": "3.4.1",
   "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,56 @@ import {
   QueryOptions,
   ConnectionOptions,
   PoolOptions,
-  Pool as CorePool
-} from './index';
+  PoolClusterOptions,
+  Pool as CorePool,
+} from './index.js';
+import { ExecutableBase as ExecutableBaseClass } from './typings/mysql/lib/protocol/sequences/promise/ExecutableBase.js';
+import { QueryableBase as QueryableBaseClass } from './typings/mysql/lib/protocol/sequences/promise/QueryableBase.js';
 
-import { EventEmitter } from 'events';
-export * from './index';
+export * from './index.js';
+
+// Expose class interfaces
+declare class QueryableAndExecutableBase extends QueryableBaseClass(
+  ExecutableBaseClass(EventEmitter)
+) {}
+
+export interface PreparedStatementInfo {
+  close(): Promise<void>;
+  execute(
+    paramaters: any | any[] | { [param: string]: any }
+  ): Promise<
+    [
+      (
+        | RowDataPacket[][]
+        | RowDataPacket[]
+        | OkPacket
+        | OkPacket[]
+        | ResultSetHeader
+      ),
+      FieldPacket[]
+    ]
+  >;
+}
 
-export interface Connection extends EventEmitter {
+export interface Connection extends QueryableAndExecutableBase {
   config: ConnectionOptions;
+
   threadId: number;
 
   connect(): Promise<void>;
+
   ping(): Promise<void>;
 
   beginTransaction(): Promise<void>;
+
   commit(): Promise<void>;
+
   rollback(): Promise<void>;
 
   changeUser(options: ConnectionOptions): Promise<void>;
 
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
-    sql: string
-  ): Promise<[T, FieldPacket[]]>;
-  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>(
-    options: QueryOptions
-  ): Promise<[T, FieldPacket[]]>;
-  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
-  >(
-    sql: string
-  ): Promise<[T, FieldPacket[]]>;
-  execute<
-    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
-  >(
-    options: QueryOptions
-  ): Promise<[T, FieldPacket[]]>;
-  execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
-  >(
-    options: QueryOptions,
-    values: any | any[] | { [param: string]: any }
-  ): Promise<[T, FieldPacket[]]>;
-
   prepare(options: string | QueryOptions): Promise<PreparedStatementInfo>;
+
   unprepare(sql: string | QueryOptions): void;
 
   end(options?: any): Promise<void>;
@@ -87,69 +81,51 @@ export interface PoolConnection extends Connection {
   connection: Connection;
 }
 
-export interface Pool extends EventEmitter, Connection {
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
-    sql: string
-  ): Promise<[T, FieldPacket[]]>;
-  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>(
-    options: QueryOptions
-  ): Promise<[T, FieldPacket[]]>;
-  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
-  >(
-    sql: string
-  ): Promise<[T, FieldPacket[]]>;
-  execute<
-    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
-  >(
-    options: QueryOptions
-  ): Promise<[T, FieldPacket[]]>;
-  execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
-  >(
-    options: QueryOptions,
-    values: any | any[] | { [param: string]: any }
-  ): Promise<[T, FieldPacket[]]>;
-
+export interface Pool extends Connection {
   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;
 }
 
+export interface PoolNamespace extends QueryableAndExecutableBase {
+  getConnection(): Promise<PoolConnection>;
+}
+
+export interface PoolCluster extends EventEmitter {
+  config: PoolClusterOptions;
+
+  add(config: PoolOptions): void;
+  add(group: string, connectionUri: string): void;
+  add(group: string, config: PoolOptions): void;
+
+  end(): Promise<void>;
+
+  getConnection(): Promise<PoolConnection>;
+  getConnection(group: string): Promise<PoolConnection>;
+  getConnection(group: string, selector: string): Promise<PoolConnection>;
+
+  of(pattern: string, selector?: string): PoolNamespace;
+
+  on(event: string, listener: (args: any[]) => void): this;
+  on(event: 'remove', listener: (nodeId: number) => void): this;
+  on(event: 'connection', listener: (connection: PoolConnection) => void): this;
+}
+
 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[]]>;
-}
+export function createPoolCluster(config?: PoolClusterOptions): PoolCluster;

package/promise.js

@@ -2,6 +2,7 @@
 
 const core = require('./index.js');
 const EventEmitter = require('events').EventEmitter;
+const parserCache = require('./lib/parsers/parser_cache.js');
 
 function makeDoneCb(resolve, reject, localErr) {
   return function (err, rows, fields) {
@@ -563,3 +564,21 @@ exports.raw = core.raw;
 exports.PromisePool = PromisePool;
 exports.PromiseConnection = PromiseConnection;
 exports.PromisePoolConnection = PromisePoolConnection;
+
+exports.__defineGetter__('Types', () => require('./lib/constants/types.js'));
+
+exports.__defineGetter__('Charsets', () =>
+  require('./lib/constants/charsets.js')
+);
+
+exports.__defineGetter__('CharsetToEncoding', () =>
+  require('./lib/constants/charset_encodings.js')
+);
+
+exports.setMaxParserCache = function(max) {
+  parserCache.setMaxCache(max);
+};
+
+exports.clearParserCache = function() {
+  parserCache.clearCache();
+};

package/typings/mysql/index.d.ts

@@ -1,78 +1,94 @@
-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 { 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,
+  PoolNamespace,
+} 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';
 
 export {
-    ConnectionOptions,
-    SslOptions,
-    PoolOptions,
-    PoolClusterOptions,
-    QueryOptions,
-    QueryError,
-    PrepareStatementInfo
+  ConnectionOptions,
+  SslOptions,
+  PoolOptions,
+  PoolClusterOptions,
+  PoolNamespace,
+  QueryOptions,
+  QueryError,
+  PrepareStatementInfo,
 };
-export * from './lib/protocol/packets/index';
+
+export * from './lib/protocol/packets/index.js';
+export * from './lib/Auth.js';
+export * from './lib/constants/index.js';
+export * from './lib/parsers/index.js';
 
 // Expose class interfaces
-export interface Connection extends BaseConnection {
-  promise(promiseImpl?: PromiseConstructor): PromiseConnection;
-}
-export interface PoolConnection extends BasePoolConnection {}
+export interface Connection extends BaseConnection {}
 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 {}
 
-export type AuthPlugin = (pluginMetadata: {
-  connection: Connection;
-  command: string;
-}) => (
-  pluginData: Buffer
-) => Promise<string> | string | Buffer | Promise<Buffer> | null;
+export function createConnection(connectionUri: string): BaseConnection;
+export function createConnection(config: ConnectionOptions): BaseConnection;
+
+export function createPool(connectionUri: string): BasePool;
+export function createPool(config: PoolOptions): BasePool;
 
-type AuthPluginDefinition<T> = (pluginOptions?: T) => AuthPlugin
+export function createPoolCluster(config?: PoolClusterOptions): PoolCluster;
 
-export const authPlugins: {
-  caching_sha2_password: AuthPluginDefinition<{
-    overrideIsSecure?: boolean,
-    serverPublicKey?: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.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,
-    joinServerPublicKey?: (data: Buffer) => void;
-  }>,
+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 interface ConnectionConfig extends ConnectionOptions {
+  mergeFlags(defaultFlags: string[], userFlags: string[] | string): number;
+  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;
+  };
 }
+
+export function createServer(handler: (conn: BaseConnection) => any): Server;