mysql2 2.2.2 → 2.3.0

package/lib/pool_cluster.js

@@ -4,6 +4,7 @@ const process = require('process');
 
 const Pool = require('./pool.js');
 const PoolConfig = require('./pool_config.js');
+const Connection = require('./connection.js');
 const EventEmitter = require('events').EventEmitter;
 
 /**
@@ -46,6 +47,62 @@ class PoolNamespace {
     });
   }
 
+  /**
+   * pool cluster query
+   * @param {*} sql
+   * @param {*} values
+   * @param {*} cb
+   * @returns query
+   */
+  query(sql, values, cb) {
+    const query = Connection.createQuery(sql, values, cb, {});
+    this.getConnection((err, conn) => {
+      if (err) {
+        if (typeof query.onResult === 'function') {
+          query.onResult(err);
+        } else {
+          query.emit('error', err);
+        }
+        return;
+      }
+      try {
+        conn.query(query).once('end', () => {
+          conn.release();
+        });
+      } catch (e) {
+        conn.release();
+        throw e;
+      }
+    });
+    return query;
+  }
+
+  /**
+   * pool cluster execute
+   * @param {*} sql 
+   * @param {*} values 
+   * @param {*} cb 
+   */
+  execute(sql, values, cb) {
+    if (typeof values === 'function') {
+      cb = values;
+      values = [];
+    }
+    this.getConnection((err, conn) => {
+      if (err) {
+        return cb(err);
+      }
+      try {
+        conn.execute(sql, values, cb).once('end', () => {
+          conn.release();
+        });
+      } catch (e) {
+        conn.release();
+        throw e;
+      }
+    });
+  }
+
   _getClusterNode() {
     const foundNodeIds = this._cluster._findNodeIds(this._pattern);
     if (foundNodeIds.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "directories": {
@@ -36,6 +36,7 @@
   ],
   "files": [
     "lib",
+    "typings",
     "index.js",
     "index.d.ts",
     "promise.js",
@@ -43,7 +44,8 @@
   ],
   "exports": {
     ".": "./index.js",
-    "./promise": "./promise.js"
+    "./promise": "./promise.js",
+    "./promise.js": "./promise.js"
   },
   "engines": {
     "node": ">= 8.0"
@@ -51,7 +53,6 @@
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",
   "dependencies": {
-    "@types/mysql": "^2.15.7",
     "denque": "^1.4.1",
     "generate-function": "^2.3.1",
     "iconv-lite": "^0.6.2",

package/promise.d.ts

@@ -1,6 +1,7 @@
 import {
   RowDataPacket,
   OkPacket,
+  ResultSetHeader,
   FieldPacket,
   QueryOptions,
   ConnectionOptions,
@@ -23,39 +24,39 @@ export interface Connection extends EventEmitter {
 
   changeUser(options: ConnectionOptions): Promise<void>;
 
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  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[]>(
+  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  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[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]
+    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[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }
@@ -84,39 +85,39 @@ export interface PoolConnection extends Connection {
 }
 
 export interface Pool extends EventEmitter {
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  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[]>(
+  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
-  query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]>(
+  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[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     sql: string
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]
+    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[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     options: QueryOptions
   ): Promise<[T, FieldPacket[]]>;
   execute<
-    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[]
+    T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader
   >(
     options: QueryOptions,
     values: any | any[] | { [param: string]: any }

package/promise.js

@@ -9,6 +9,7 @@ function makeDoneCb(resolve, reject, localErr) {
       localErr.message = err.message;
       localErr.code = err.code;
       localErr.errno = err.errno;
+      localErr.sql = err.sql;
       localErr.sqlState = err.sqlState;
       localErr.sqlMessage = err.sqlMessage;
       reject(localErr);
@@ -427,8 +428,120 @@ function createPool(opts) {
   'format'
 ]);
 
+class PromisePoolCluster extends EventEmitter {
+  constructor(poolCluster, thePromise) {
+    super();
+    this.poolCluster = poolCluster;
+    this.Promise = thePromise || Promise;
+    inheritEvents(poolCluster, this, ['acquire', 'connection', 'enqueue', 'release']);
+  }
+
+  getConnection() {
+    const corePoolCluster = this.poolCluster;
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.getConnection((err, coreConnection) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(new PromisePoolConnection(coreConnection, this.Promise));
+        }
+      });
+    });
+  }
+
+  query(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    const localErr = new Error();
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, localErr);
+      corePoolCluster.query(sql, args, done);
+    });
+  }
+
+  execute(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    const localErr = new Error();
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, localErr);
+      corePoolCluster.execute(sql, args, done);
+    });
+  }
+
+  of(pattern, selector) {
+    return new PromisePoolCluster(
+      this.poolCluster.of(pattern, selector),
+      this.Promise
+    );
+  }
+
+  end() {
+    const corePoolCluster = this.poolCluster;
+    const localErr = new Error();
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.end(err => {
+        if (err) {
+          localErr.message = err.message;
+          localErr.code = err.code;
+          localErr.errno = err.errno;
+          localErr.sqlState = err.sqlState;
+          localErr.sqlMessage = err.sqlMessage;
+          reject(localErr);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+/**
+ * proxy poolCluster synchronous functions
+ */
+(function (functionsToWrap) {
+  for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) {
+    const func = functionsToWrap[i];
+
+    if (
+      typeof core.PoolCluster.prototype[func] === 'function' &&
+      PromisePoolCluster.prototype[func] === undefined
+    ) {
+      PromisePoolCluster.prototype[func] = (function factory(funcName) {
+        return function () {
+          return core.PoolCluster.prototype[funcName].apply(this.poolCluster, arguments);
+        };
+      })(func);
+    }
+  }
+})([
+  'add'
+]);
+
+function createPoolCluster(opts) {
+  const corePoolCluster = core.createPoolCluster(opts);
+  const thePromise = (opts && opts.Promise) || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+      'Use promise-enabled node version or pass userland Promise' +
+      " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+  return new PromisePoolCluster(corePoolCluster, thePromise);
+}
+
 exports.createConnection = createConnection;
 exports.createPool = createPool;
+exports.createPoolCluster = createPoolCluster;
 exports.escape = core.escape;
 exports.escapeId = core.escapeId;
 exports.format = core.format;

package/typings/mysql/LICENSE.txt

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2016, Felix Frederick Becker
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/typings/mysql/index.d.ts

@@ -0,0 +1,36 @@
+
+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 {QueryOptions, StreamOptions, QueryError} from './lib/protocol/sequences/Query';
+
+export function createConnection(connectionUri: string): Connection;
+export function createConnection(config: BaseConnection.ConnectionOptions): Connection;
+export function createPool(config: BasePool.PoolOptions): Pool;
+export function createPoolCluster(config?: BasePoolCluster.PoolClusterOptions): PoolCluster;
+export function escape(value: any): string;
+export function format(sql: string): string;
+export function format(sql: string, values: any[]): string;
+export function format(sql: string, values: any): string;
+
+export {
+    ConnectionOptions,
+    SslOptions,
+    PoolOptions,
+    PoolClusterOptions,
+    QueryOptions,
+    QueryError
+};
+export * from './lib/protocol/packets/index';
+
+// Expose class interfaces
+export interface Connection extends BaseConnection {}
+export interface PoolConnection extends BasePoolConnection {}
+export interface Pool extends BasePool {}
+export interface PoolCluster extends BasePoolCluster {}
+export interface Query extends BaseQuery {}

package/typings/mysql/info.txt

@@ -0,0 +1 @@
+temporary workaround, see https://github.com/sidorares/node-mysql2/issues/1210

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

@@ -0,0 +1,246 @@
+
+import Query = require('./protocol/sequences/Query');
+import {OkPacket, FieldPacket, RowDataPacket, ResultSetHeader} from './protocol/packets/index';
+import {EventEmitter} from 'events';
+
+declare namespace Connection {
+
+    export interface ConnectionOptions {
+        /**
+         * The MySQL user to authenticate as
+         */
+        user?: string;
+
+        /**
+         * The password of that MySQL user
+         */
+        password?: string;
+
+        /**
+         * Name of the database to use for this connection
+         */
+        database?: string;
+
+        /**
+         * The charset for the connection. This is called 'collation' in the SQL-level of MySQL (like utf8_general_ci).
+         * If a SQL-level charset is specified (like utf8mb4) then the default collation for that charset is used.
+         * (Default: 'UTF8_GENERAL_CI')
+         */
+        charset?: string;
+
+        /**
+         * The hostname of the database you are connecting to. (Default: localhost)
+         */
+        host?: string;
+
+        /**
+         * The port number to connect to. (Default: 3306)
+         */
+        port?: number;
+
+        /**
+         * The source IP address to use for TCP connection
+         */
+        localAddress?: string;
+
+        /**
+         * The path to a unix domain socket to connect to. When used host and port are ignored
+         */
+        socketPath?: string;
+
+        /**
+         * The timezone used to store local dates. (Default: 'local')
+         */
+        timezone?: string | 'local';
+
+        /**
+         * The milliseconds before a timeout occurs during the initial connection to the MySQL server. (Default: 10 seconds)
+         */
+        connectTimeout?: number;
+
+        /**
+         * Stringify objects instead of converting to values. (Default: 'false')
+         */
+        stringifyObjects?: boolean;
+
+        /**
+         * Allow connecting to MySQL instances that ask for the old (insecure) authentication method. (Default: false)
+         */
+        insecureAuth?: boolean;
+
+        /**
+         * 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)
+         *
+         * You can also specify a function (field: any, next: () => void) => {} to do the type casting yourself.
+         *
+         * WARNING: YOU MUST INVOKE the parser using one of these three field functions in your custom typeCast callback. They can only be called once.
+         *
+         * field.string()
+         * field.buffer()
+         * field.geometry()
+         *
+         * are aliases for
+         *
+         * 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);
+
+        /**
+         * A custom query format function
+         */
+        queryFormat?: (query: string, values: any) => void;
+
+        /**
+         * When dealing with big numbers (BIGINT and DECIMAL columns) in the database, you should enable this option
+         * (Default: false)
+         */
+        supportBigNumbers?: boolean;
+
+        /**
+         * Enabling both supportBigNumbers and bigNumberStrings forces big numbers (BIGINT and DECIMAL columns) to be
+         * always returned as JavaScript String objects (Default: false). Enabling supportBigNumbers but leaving
+         * bigNumberStrings disabled will return big numbers as String objects only when they cannot be accurately
+         * represented with [JavaScript Number objects] (http://ecma262-5.com/ELS5_HTML.htm#Section_8.5)
+         * (which happens when they exceed the [-2^53, +2^53] range), otherwise they will be returned as Number objects.
+         * This option is ignored if supportBigNumbers is disabled.
+         */
+        bigNumberStrings?: boolean;
+
+        /**
+         * Force date types (TIMESTAMP, DATETIME, DATE) to be returned as strings rather then inflated into JavaScript Date
+         * objects. Can be true/false or an array of type names to keep as strings.
+         *
+         * (Default: false)
+         */
+        dateStrings?: boolean | Array<'TIMESTAMP' | 'DATETIME' | 'DATE'>;
+
+        /**
+         * This will print all incoming and outgoing packets on stdout.
+         * You can also restrict debugging to packet types by passing an array of types (strings) to debug;
+         *
+         * (Default: false)
+         */
+        debug?: any;
+
+        /**
+         * Generates stack traces on Error to include call site of library entrance ('long stack traces'). Slight
+         * performance penalty for most calls. (Default: true)
+         */
+        trace?: boolean;
+
+        /**
+         * Allow multiple mysql statements per query. Be careful with this, it exposes you to SQL injection attacks. (Default: false)
+         */
+        multipleStatements?: boolean;
+
+        /**
+         * List of connection flags to use other than the default ones. It is also possible to blacklist default ones
+         */
+        flags?: Array<string>;
+
+        /**
+         * object with ssl parameters or a string containing name of ssl profile
+         */
+        ssl?: string | SslOptions;
+
+
+        /**
+         * Return each row as an array, not as an object.
+         * This is useful when you have duplicate column names.
+         * This can also be set in the `QueryOption` object to be applied per-query.
+         */
+        rowsAsArray?: boolean
+    }
+
+    export interface SslOptions {
+        /**
+         * A string or buffer holding the PFX or PKCS12 encoded private key, certificate and CA certificates
+         */
+        pfx?: string;
+
+        /**
+         * A string holding the PEM encoded private key
+         */
+        key?: string;
+
+        /**
+         * A string of passphrase for the private key or pfx
+         */
+        passphrase?: string;
+
+        /**
+         * A string holding the PEM encoded certificate
+         */
+        cert?: string;
+
+        /**
+         * Either a string or list of strings of PEM encoded CA certificates to trust.
+         */
+        ca?: string | string[];
+
+        /**
+         * Either a string or list of strings of PEM encoded CRLs (Certificate Revocation List)
+         */
+        crl?: string | string[];
+
+        /**
+         * A string describing the ciphers to use or exclude
+         */
+        ciphers?: string;
+
+        /**
+         * You can also connect to a MySQL server without properly providing the appropriate CA to trust. You should not do this.
+         */
+        rejectUnauthorized?: boolean;
+    }
+}
+
+declare class Connection extends EventEmitter {
+
+    config: Connection.ConnectionOptions;
+    threadId: number;
+    authorized: boolean;
+
+    static createQuery<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(sql: string, callback?: (err: Query.QueryError | null, result: T, fields: FieldPacket[]) => any): Query;
+    static createQuery<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(sql: string, values: any | any[] | { [param: string]: any }, callback?: (err: Query.QueryError | null, result: T, fields: FieldPacket[]) => any): Query;
+
+    beginTransaction(callback: (err: Query.QueryError | null) => void): void;
+
+    connect(callback?: (err: Query.QueryError | null) => void): void;
+
+    commit(callback?: (err: Query.QueryError | null) => void): void;
+
+    changeUser(options: Connection.ConnectionOptions, callback?: (err: Query.QueryError | null) => void): void;
+
+    query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(sql: string, callback?: (err: Query.QueryError | null, result: T, fields: FieldPacket[]) => any): Query;
+    query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(sql: string, values: any | any[] | { [param: string]: any }, callback?: (err: Query.QueryError | null, result: T, fields: FieldPacket[]) => any): Query;
+    query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(options: Query.QueryOptions, callback?: (err: Query.QueryError | null, result: T, fields?: FieldPacket[]) => any): Query;
+    query<T extends RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader>(options: Query.QueryOptions, values: any | any[] | { [param: string]: any }, callback?: (err: Query.QueryError | null, result: T, fields: FieldPacket[]) => any): Query;
+
+    end(callback?: (err: Query.QueryError | null) => void): void;
+    end(options: any, callback?: (err: Query.QueryError | null) => void): void;
+
+    destroy(): void;
+
+    pause(): void;
+
+    resume(): void;
+
+    escape(value: any): string;
+
+    escapeId(value: string): string;
+    escapeId(values: string[]): string;
+
+    format(sql: string, values?: any | any[] | { [param: string]: any }): string;
+
+    on(event: string, listener: Function): this;
+
+    rollback(callback: () => void): void;
+}
+
+export = Connection;