mysql2 3.22.1 → 3.22.2-canary.c79a3f32

package/lib/promise/capture_local_err.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/** @param {Function} constructorOpt Passed to Error.captureStackTrace (omit this frame from stacks). */
+function captureStackHolder(constructorOpt) {
+  const holder = {};
+  Error.captureStackTrace(holder, constructorOpt);
+  return holder;
+}
+
+/**
+ * Replace `err.stack` frames with the capture from `holder`, keeping the
+ * callback error instance and its MySQL fields.
+ *
+ * @param {Error} err
+ * @param {{ stack?: string }} holder
+ */
+function applyCapturedStack(err, holder) {
+  const stack = holder && holder.stack;
+  if (typeof stack !== 'string' || !stack) return;
+  const lines = stack.split('\n');
+  lines[0] = `${err.name}: ${err.message}`;
+  err.stack = lines.join('\n');
+}
+
+module.exports = { captureStackHolder, applyCapturedStack };

package/lib/promise/connection.js

@@ -2,6 +2,10 @@
 
 const EventEmitter = require('events').EventEmitter;
 const PromisePreparedStatementInfo = require('./prepared_statement_info.js');
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 const inheritEvents = require('./inherit_events.js');
 const BaseConnection = require('../base/connection.js');
@@ -26,14 +30,14 @@ class PromiseConnection extends EventEmitter {
 
   query(query, params) {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.query);
     if (typeof params === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (params !== undefined) {
         c.query(query, params, done);
       } else {
@@ -44,14 +48,14 @@ class PromiseConnection extends EventEmitter {
 
   execute(query, params) {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.execute);
     if (typeof params === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (params !== undefined) {
         c.execute(query, params, done);
       } else {
@@ -74,43 +78,43 @@ class PromiseConnection extends EventEmitter {
 
   beginTransaction() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.beginTransaction
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.beginTransaction(done);
     });
   }
 
   commit() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.commit);
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.commit(done);
     });
   }
 
   rollback() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.rollback
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       c.rollback(done);
     });
   }
 
   ping() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.ping);
     return new this.Promise((resolve, reject) => {
       c.ping((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);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve(true);
         }
@@ -120,16 +124,12 @@ class PromiseConnection extends EventEmitter {
 
   reset() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.reset);
     return new this.Promise((resolve, reject) => {
       c.reset((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);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }
@@ -139,16 +139,12 @@ class PromiseConnection extends EventEmitter {
 
   connect() {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.connect);
     return new this.Promise((resolve, reject) => {
       c.connect((err, param) => {
         if (err) {
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve(param);
         }
@@ -159,16 +155,12 @@ class PromiseConnection extends EventEmitter {
   prepare(options) {
     const c = this.connection;
     const promiseImpl = this.Promise;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromiseConnection.prototype.prepare);
     return new this.Promise((resolve, reject) => {
       c.prepare(options, (err, statement) => {
         if (err) {
-          localErr.message = err.message;
-          localErr.code = err.code;
-          localErr.errno = err.errno;
-          localErr.sqlState = err.sqlState;
-          localErr.sqlMessage = err.sqlMessage;
-          reject(localErr);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           const wrappedStatement = new PromisePreparedStatementInfo(
             statement,
@@ -182,16 +174,14 @@ class PromiseConnection extends EventEmitter {
 
   changeUser(options) {
     const c = this.connection;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromiseConnection.prototype.changeUser
+    );
     return new this.Promise((resolve, reject) => {
       c.changeUser(options, (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);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }

package/lib/promise/make_done_cb.js

@@ -1,15 +1,12 @@
 'use strict';
 
-function makeDoneCb(resolve, reject, localErr) {
+const { applyCapturedStack } = require('./capture_local_err.js');
+
+function makeDoneCb(resolve, reject, stackHolder) {
   return function (err, rows, fields) {
     if (err) {
-      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);
+      applyCapturedStack(err, stackHolder);
+      reject(err);
     } else {
       resolve([rows, fields]);
     }

package/lib/promise/pool.js

@@ -1,6 +1,10 @@
 'use strict';
 
 const EventEmitter = require('events').EventEmitter;
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 const PromisePoolConnection = require('./pool_connection.js');
 const inheritEvents = require('./inherit_events.js');
@@ -33,14 +37,14 @@ class PromisePool extends EventEmitter {
 
   query(sql, args) {
     const corePool = this.pool;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromisePool.prototype.query);
     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);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (args !== undefined) {
         corePool.query(sql, args, done);
       } else {
@@ -51,14 +55,14 @@ class PromisePool extends EventEmitter {
 
   execute(sql, args) {
     const corePool = this.pool;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromisePool.prototype.execute);
     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);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (args) {
         corePool.execute(sql, args, done);
       } else {
@@ -69,16 +73,12 @@ class PromisePool extends EventEmitter {
 
   end() {
     const corePool = this.pool;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromisePool.prototype.end);
     return new this.Promise((resolve, reject) => {
       corePool.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);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }

package/lib/promise/pool_cluster.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { captureStackHolder } = require('./capture_local_err.js');
 const PromisePoolConnection = require('./pool_connection');
 const makeDoneCb = require('./make_done_cb');
 
@@ -24,28 +25,32 @@ class PromisePoolNamespace {
 
   query(sql, values) {
     const corePoolNamespace = this.poolNamespace;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.query
+    );
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolNamespace.query(sql, values, done);
     });
   }
 
   execute(sql, values) {
     const corePoolNamespace = this.poolNamespace;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromisePoolNamespace.prototype.execute
+    );
     if (typeof values === 'function') {
       throw new Error(
         'Callback function is not available with promise clients.'
       );
     }
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolNamespace.execute(sql, values, done);
     });
   }

package/lib/promise/prepared_statement_info.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { captureStackHolder } = require('./capture_local_err.js');
 const makeDoneCb = require('./make_done_cb.js');
 
 class PromisePreparedStatementInfo {
@@ -10,9 +11,11 @@ class PromisePreparedStatementInfo {
 
   execute(parameters) {
     const s = this.statement;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromisePreparedStatementInfo.prototype.execute
+    );
     return new this.Promise((resolve, reject) => {
-      const done = makeDoneCb(resolve, reject, localErr);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       if (parameters) {
         s.execute(parameters, done);
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql2",
-  "version": "3.22.1",
+  "version": "3.22.2-canary.c79a3f32",
   "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
   "main": "index.js",
   "typings": "typings/mysql/index",

package/promise.js

@@ -9,6 +9,10 @@ const createPool = require('./lib/create_pool.js');
 const createPoolCluster = require('./lib/create_pool_cluster.js');
 const PromiseConnection = require('./lib/promise/connection.js');
 const PromisePool = require('./lib/promise/pool.js');
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./lib/promise/capture_local_err.js');
 const makeDoneCb = require('./lib/promise/make_done_cb.js');
 const PromisePoolConnection = require('./lib/promise/pool_connection.js');
 const inheritEvents = require('./lib/promise/inherit_events.js');
@@ -16,7 +20,7 @@ const PromisePoolNamespace = require('./lib/promise/pool_cluster');
 
 function createConnectionPromise(opts) {
   const coreConnection = createConnection(opts);
-  const createConnectionErr = new Error();
+  const stackHolder = captureStackHolder(createConnectionPromise);
   const thePromise = opts.Promise || Promise;
   if (!thePromise) {
     throw new Error(
@@ -30,11 +34,8 @@ function createConnectionPromise(opts) {
       resolve(new PromiseConnection(coreConnection, thePromise));
     });
     coreConnection.once('error', (err) => {
-      createConnectionErr.message = err.message;
-      createConnectionErr.code = err.code;
-      createConnectionErr.errno = err.errno;
-      createConnectionErr.sqlState = err.sqlState;
-      reject(createConnectionErr);
+      applyCapturedStack(err, stackHolder);
+      reject(err);
     });
   });
 }
@@ -83,28 +84,30 @@ class PromisePoolCluster extends EventEmitter {
 
   query(sql, args) {
     const corePoolCluster = this.poolCluster;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromisePoolCluster.prototype.query);
     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);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolCluster.query(sql, args, done);
     });
   }
 
   execute(sql, args) {
     const corePoolCluster = this.poolCluster;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(
+      PromisePoolCluster.prototype.execute
+    );
     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);
+      const done = makeDoneCb(resolve, reject, stackHolder);
       corePoolCluster.execute(sql, args, done);
     });
   }
@@ -118,16 +121,12 @@ class PromisePoolCluster extends EventEmitter {
 
   end() {
     const corePoolCluster = this.poolCluster;
-    const localErr = new Error();
+    const stackHolder = captureStackHolder(PromisePoolCluster.prototype.end);
     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);
+          applyCapturedStack(err, stackHolder);
+          reject(err);
         } else {
           resolve();
         }