We have just learned about Callback Hell and

how Promises can enable us to overcome this issue.

We know that the node Mongo DB driver natively supports Promises.

And so if you do not specify a callback,

the calls to their functions will return from lists.

So we're going to update our application to make use of Promises to

avoid the Callback Hell issue that we just learned about in the previous lecture.

Getting back to our application, again,

taking one more look at the reason the Callback Hell has developed in our code.

Note that, here, when we implemented the operations,

we have one operation and then inside the callback of that operation,

then we need to initiate the next operation.

Inside the callback of that operation,

we are initiating the next operation, and so on.

You are ending up with this pyramid-like structure here.

One operation inside the callback of another and inside the callback.

Now, this code will pretty soon get unwieldy and complicated to understand.

That is why we want to transform this code using

the Promise support that Mongo DB driver already provides for us,

so that we can instead use Promises rather

than using the callback functions as we did in this exercise.

Of course, I did the previous version just

to illustrate to you how we can line up with Callback Hell,

and how we can use Promises to overcome this issue.

Now, before we update the index.js file,

let me go into the operations.js file and then we will update this first.

In here, you'll notice that when we are calling this functions here,

we are passing in the second parameter,

which is a callback function here.

Because we are going to be using Promises here,

so I'm just going to delete that callback function.

And then since this call to the insert will anyway return Promises,

I'm just going to return the Promise from this function.

Note how that code got simplified.

Similarly, for that second one,

I will simply remove this callback function,

and then return the Promise that is being returned by this,

and then we'll handle that in the code in index.js.

Similarly, for the delete one also,

I'm going to remove the callback,

and then return that one and also for update.

For update, we're going to remove the callback that we have given here,

and then return the Promise.

This way, all these four functions are going

to be returning the Promise that is already returned

by these calls to the Mongo DB driver functions.

Now once we have completed that,

let's go back to index.js and index.js,

I'm going to again update this function here,

so we'll see using Promises,

we'll say Mongo.Client.connect(url), and then we will replace this

by saying "then" and this receives only the DB as the parameter.

And inside here, we'll handle the rest.

And also, we can begin notice that this particular function closes that "then" here.

And the Promise, the second part to the Promise,

we can handle the error.

We can see console log(err) here.

And also, we can add in a catch((err),

We can use the "then" catch of that Promise also to catch the errors.

That way, you have caught the errors.

Now, let's improve the code inside here.

Inside here, we are doing DB operation insertDocument,

and instead of calling this function here,

what I'm going to do is to turn this into "then" here.

I'm going to close off this and then say.then((result).

Inside this result, we're going to print out the console log and then,

so I'm going to close this off here and

then we'll close the "then" here.

And then this will be attached to,

again a "then" here.

You see that I am changing two "then"s,

one into the other here.

And then inside this "then",

we'll do a console log and then we'll do a return of that next operation.

But then, for this operation,

I'm going to close off this,

and close this "then",

and then this callback again,

now will be handled inside a "then" function here.

Note how you have that first function and then into "then",

we are calling the dboper.findDocuments,

and that will return, and doesn't return a Promise.

That Promise will be handled by this "then".

We are chaining two "then's" together and that again,

chaining one more "then" in here,

let me re-indent the code here,

and then we will return this here.

And, this again, will close

off and close that "then",

and then this gets enclosed inside the next "then",

and we will call

the next function here the db.dropCollection("dishes"),

and close off this "then",

and the next one here.

We'll handle the "then" of the result here,

return db.close,

and all of this here can be now removed because they are no longer needed.

And then finally, if there is an error,

we'll catch the error with this function.

I'm just going to copy this and then paste it here.

That is it.

With this change now,

your code is a lot more easier to handle here.

As you can see, you have the MongoClient.connect,

which returns a Promise,

and inside the handling of that promise,

you're calling these metrics.

And one after another,

they are each returning the Promise and then you are changing them using the "then".

This code structure is a lot more easier to follow than what we had implemented earlier.

Using Promises, we have literally turned it around and avoided

the Callback Hell that we saw in the earlier version of this application.

Let's save the changes to both the index.js

and operations.js and then take a look at this application.

Again, going to the terminal at the prompt,

type npm start, and you will see that your application runs exactly as before.

It inserts the document,

finds the document, updates the document,

and then finds updated document and then closes the database, the int.

Using Promises, we have restructured the code to be a lot more easier and avoided

the Callback Hell that we saw in the previous version of this application.

With this, we complete this exercise.

In this exercise, you have seen how we can make

use of Promises to avoid the Callback Hell.

This is a good time for you to do a git commit with the message,

Callback Hell and Promise.

Exercise (Video): Callback Hell and Promises

Server-side Development with NodeJS, Express and MongoDB

Rencontrer les enseignants