Promise chain with an asynchronous operation not executing in order

Question

I have found other people asking about this topic but I haven't been able to get my promise chain to execute in order.

Here is a basic reproduction of what is happening:

function firstMethod(){

    dbHelper.executeQuery(queryParameters).then(result => {

        if (result === whatIAmExpecting) {

            return dbHelper.doDbOperation(secondQueryParameters)}

        else {

            throw new Error('An error occurred')

        }})

        .then(doFinalOperation())
        .catch(error => {

        })
}

In the above code doFinalOperation() is called before the then function after executeQuery() is called.

Here is the implementation of executeQuery():

function executeQuery(parameter) {

    return new Promise((resolve, reject) => {

        const queryToExecute = `SELECT * FROM parameter`

        return mySqlConnection.query(queryToExecute).then((result) => {

            resolve(result)

        }).catch(error => {

            reject(error)
        })
    })

And here is the implementation of of the mySqlConnection.query method:

function query(queryString){

 return new Promise((resolve, reject) =>
    {

  initConnection()

  connection.connect()

    require('bluebird').promisifyAll(connection)

     return connection.queryAsync(queryString).then(function(results) {

        connection.end();

        resolve(results)

        }).catch(error => {

                reject(error)
            })
      })

It seems like I have incorrectly implemented the executeQuery() method. The database operation in the mySqlConnection.query is asychronous and I can see that's where the chain of promises stops happening in the expected order.

My question in a nutshell: How do I make the my chain of promises execute in order, and how I do stop a then() method from being executed before the previous Promise has called resolve() or reject()?

Thanks in advance.

Answer 1

then expects a function, but you have accidentally executed it, instead of passing it. Change:

 then(doFinalOperation())

with:

 then(doFinalOperation)

Now it will be the promise implementation that invokes it (at the proper time), not "you".

If your function needs arguments to be passed, then you can either

(1) Use bind:

 then(doFinalOperation.bind(null, parameterOne, parameterTwo, parameterThree))

(2) Use a function expression

 then(_ => doFinalOperation(parameterOne, parameterTwo, parameterThree))