Promise wrapper on createConnection is problematic in top-level code

The non-promise version of createConnection is not asynchronous. Unlike the database calls, no callback is required here.

var connection = mysql.createConnection({host:'localhost', user: 'root', database: 'test'});

However, the promise wrapper version comes back as a promise.

let connection = await mysql.createConnection({host:'localhost', user: 'root', database: 'test'});

This wouldn’t be a problem, except that Node/V8 don’t currently allow await outside of an async function, including at the top level of an app. This means that the example code doesn’t work when you drop it into a simple Node app. The easy solution that I’ve come up for this, is to wrap createConnection in an IIFE.

let connection

(async function() {
  try {
    connection = await mysql.createConnection(dbconfig)
  } catch(err){
    console.error(err)
  }
})()

This seems unnecessarily complex, since this isn’t a method that needs to be async. I would propose that createConnection remains a synchronous function, the same way it is in the non-promise version. I’m also having difficulty finding an easy way to stick my DB stuff into a module with this pattern.

[dougwilson]

Yea, in fact was just pulling out the AWS certs to share right now :waves:

[sidorares]

hi @jdhiro

I see your point, I wish 7+ node had repl and top level module wrapper async functions

Here are my thoughts: the only correct way of using connection, even in simple script is like this:

   const conn = mysql.createConnection(opts);
   conn.on('error', (err) => { /* 
      handle non-query errors: connection time, network etc
      connection time errors usually can be handled without 
      dedicated conn.on('error') handler because usually there 
      is a command in the queue and fatal errors are reported 
      down to all commands. However, when there is no 
      command in the queue, or command with no callback
      and there is connection error, error must be handled by
      conn error handler, otherwise it'll be re-thrown and 
      crash process
     */ })
    conn.query('do some sql', (err, res) => {
      if (err) {
         return err;
      }
    })

async .createConnection() helps a little with this, in a way that if there is connection error and no command error can be caught. Unfortunately it’s still possible for ‘error’ connection event to crash process so you must attach listener. My advise is to always use pool, even in scripts - pool handles this error logic automatically.

I’ll think about changing .createConnection() to be sync. Maybe it’s possible to make this backwards compatible

as a work around - if you prefer async wrappers but want to have .createConnection() in top lewel of script without extra wrapping - just don’t use await:

const myAsyncFunc = async (conn, x) =>  {
   const [rows, fields] = conn.query('select 1+?', x)
   console.log(rows);
}

const mysql = require('mysql2/promise');
mysql.createConnection({}).then( (conn) => {
   myAsyncFunc(conn, 1);
   myAsyncFunc(conn, 2);
}).catch((e) => {
  console.log('error!!!', e);
})