All language subtitles for 008 Working with The Native MongoDB Driver_en

All right.

So in the previous module we looked at how we would use MongoDB in the command line through the use

of the Mongo shell.

And that's pretty much MongoDB in its purest form in an isolated setting. But that's no use to us because

we want to build applications that have databases

right?

So we need to learn how to integrate all MongoDB database with on Node.js application.

And that is what this module is all about.

Now when you're creating a Node app that needs to connect to a MongoDB database

there's essentially two options for you to choose from.

One is to use the MongoDB native driver that we're going to talk about very quickly.

Another is to use a ODM or an Object Document Mapper that's called mongoose.

Now the most popular way of working with MongoDB and Node.js is through using this package called

mongoose.

And the reason is because it vastly simplifies and cuts down on the code that's required in order to

work with your MongoDB database.

But I want to show you first how the native MongoDB driver would work and then we'll go through how

to use mongoose just so that you can see for yourself just how much easier it is to incorporate mongoose

and it makes your life as a developer so much better.

But first let's get started and take a look at how we would use the MongoDB native driver.

Firstly I want to head over to the MongoDB documentation at docs.mongodb.com.

And here we're going to head over to the tab that's called drivers. And on the left hand pane here you can

see that there's a whole bunch of drivers for different languages.

Now the driver is what's going to enable our MongoDB to interact with our application and depending on

which language your application was developed with then you'll need to use a different driver.

Now in our case we're going to choose Node.js and we're going to view the latest documentation. And from

here we're going to head over to quick starts and it details pretty much step by step how you would

get started using the native MongoDB Node.js driver.

Well that's quite a long sentence.

So essentially what we're trying to do is we're trying to glue together our MongoDB database with

our Node.js application.

And this is going to be the syntax and the code and we're going to install the driver to enable us to

do that.

First things first, we're going to need a new project. For this project

I've decided that I'm going to make a database of fruits and I'm going to rate all the fruits that I've

tried.

And there's some really wacky ones out there that I've come across through my travels and I think it's

a pretty nice way of showing you how to work with MongoDB and Node. CD over to wherever you keep

all of your development files

and then we're going to create a new directory and that's going to be called FruitsProject. And then

we're going to head over to FruitsProject

and here we're going to create a new app.

So we're going to create a new file called app.js and as per usual we're going to initialize our npm.

But this time instead if you don't want to hit enter to insert the default values when you initialize

npm, you can just add a -y which basically says yes to everything.

And when you hit enter you can see that we've initialized our npm and accepted all of the defaults.

So now all we have to do is to install the MongoDB driver.

And to do that with npm we have to install something called mongodb.

And remember we don't need the --save anymore as of the latest versions of npm.

So we can simply say npm i short for install and then it's mongodb.

Hit enter

and that should install the driver in a couple of seconds.

So now all we have to do is open up our app.js inside Atom and get started developing on your Node

JS application that integrates with a MongoDB database.

I'm just going to show you how we can get started using this by just using some the code from the getting

started guide.

So I'm simply going to copy this part and add it to our aappp.js and again we've got a whole bunch

of warnings so let's just silence that from //jshint. And

now I want to walk you through this code. First

we are requiring a package called mongodb

and along with that package we also insert another one called assert.

Now everything that you see that is related to assert be it on

Node.js applications or iOS applications,

it's always to do with testing.

And so you'll see that when we add a lot of the MongoDB code into our application, there's a lot of

assert that just validates our data entry and our connection to the MongoDB database.

Now the next part is the connection URL. And you can see this looks a little bit similar to what

we've been using to develop websites on our local system.

The important thing to note here is that when you're working with MongoDB the port that they use is

pretty much always 27017

and this is just some sort of arbitrary number that they've decided upon.

This is the base URL for connecting to our database. And then we specify a database name

so let's change it to fruitsDB and then we create a new Mongo client which is going to connect to

our MongoDB database and if a fruitsDB doesn't exist then it will create it.

And if all of that happened without any errors then we are going to log that we have connected successfully

to the server. Once we're done

we're going to close the connection to our database

and this is all that this code does so far, the majority of it down here is just to create a new connection

to a new database.

And this is equivalent to when we saw in the Mongos shell previously where we just said use fruits

DB that use fruitsDB if we wanted to use it in our Node.js application using the MongoDB native driver

is basically all of this code.

So it's a bit crazy.

And the reason why I'm walking you through this and explaining the code is that in reality most developers

who are working with Node and MongoDB will rarely use the native MongoDB driver.

Now it's not because it's no good,

it works and allows a lot of personalization and you can drill down to the specifics and you can set

up and use your MongoDB database with a high level of control.

All right so now that we have created this, let's go ahead and run our app.js using again node app

.js and you can see we get a error. And it says MongoNetworkError failed to connect to server.

And whenever you get this, you always have to remind yourself

do you still have the Mongo server up and running?

So create a new tab and remember whenever we're using MongoDB we always have to first run our server

using the command mongod. And only once it's done running and it's waiting for connections on again

that port 27017

it's going to come up in a lot of places.

Well now we're ready to actually connect to our database and we can run node ap.js again

and now we are successfully connected to the server.

If at some point you get a deprecation warning as you see here then just read what the message says

because MongoDB, because it's relatively new,

they will add new syntax and new code and new APIs, new ways of doing things, on a regular basis.

So in this case it says deprecation warning current URL string parser is deprecated and will

be removed in a future version. To use the new parser, pass option

this to the MongoClient.connect.

If you didn't know what to do with this deprecation warning, then what do you do?

Well you just copy it in its entirety and then you paste it into Google and see what does Google say.

So first link is a link to Stack Overflow and it already tells you this is how you would work around

it.

So you can either change to a local version of Mongo which is not what we want to do, we want to work with

the latest version.

So if you do indeed want to use latest version, then you will have to make your connection using this

use

NewUrlParser key value pair.

And here they've got some example code of how you would add it.

So they've added it to MongoClient.connect.

You can see that even though we're taking the code from MongoDB using the latest version of their

documentation stuff gets out of date and it's really important that you don't get fazed by every little

thing that you see in the console and simply just Google for an answer.

Let's go back to Atom and let's go ahead and fix this.

We're going to change our Mongo client to use the URL that we specified for our MongoDB server

but then we're going to add a comma and we're going to paste in that option that they wanted us to add.

So there we go.

Now let's hit save and let's rerun our app.

You can see now we get connected successfully to server and we don't get any deprecation warnings.

Even though the last time we did get this warning our app is still running and connected successfully

so it didn't actually affect our app.

But it's important that whenever you see a deprecation warning to just copy and paste it into Google

and see what the existing solutions are.

It's very very rare that you will be coming across a problem for the first time and you're the only

person with that problem.

It almost never happens.

OK so now that we have it connected successfully to our Mongo server the next part is adding some

data to our database.

So how do we do that?

Well it's back to the documentation and the next part is of course insert a document.

So let's copy all of this code from the documentation and let's paste it below the last line that we

have.

So this code what it does is it will create a new collection and the collection that we're going to

create is going to be called fruits.

We've got a collection called fruits inside our fruitsDB

And this is equivalent to when we used our new database and then we said db.fruits.insert.

And then we get to insert some data in here. The data is in the same format as we saw before.

It's a bunch of key value pairs and here they're inserting three items into a field called a

and then they've added the values 1,2 ,3.

So as we saw before in the Mono shell whenever you see a pair of curly brackets that's going to be

an individual document or an individual record.

And in our case we're going to insert three fruits.

So I'm going to just paste in some code that I wrote a little bit earlier on and we'll just format this

or that you can see it more clearly.

So here I'm inserting three documents and each document is a fruit.

So the first one has a name of apple, a score of 8

and a review of 'great fruit'. And the rest of them are for orange and banana.

So we're now creating this array of fruits and we're using the method insertMany which comes from MongoDB

to insert all of these three documents into a collection called fruits inside a database called

fruitsDB.

And down here you can see that the next few lines are dedicated to validation.

So they've added a whole bunch of asserts.

And if we go through them line by line, this one says validate to make sure that there are no errors

when we inserted our document.

And the next ones ensure that we have three results that are inserted into our collection.

And if that is so then we're going to log inserted three documents into the collection. And the next

part is to simply run that function inside our insert documents function and they show you that client.

connect should now look like this

with this additional part. Up here inside client.connect instead of calling client.close we're

going to paste that new code which calls insertDocuments and only once it's done inserting the documents

do we close the connection to our database.

So now let's hit save and let's again run our code with node app.js and you can see we've successfully

connected to the server and we've inserted three documents into the collection.

And you can actually test out the validation quite easily. Say if we were only to add 2 records to

our database, then you will get an assertion error saying that 3 doesn't equal 2.

Well you only inserted 2 items but I was expecting 3.

So you're ready beginning to see the validation that we can place inside our app.js using the Mongo

DB driver in order to validate the data that we're inserting.

And you can see just how very flexible all of these asserts are. If I head into my command line and I

create a new terminal and then I tap into the Mongo shell and I say show dbs, you can see now in

addition to our shopDB which we created inside the Mongo shell we've also got this new database

called fruitsDB and that one was not created using the Mongo shell but instead from Node.js

using the MongoDB driver.

And that's where the fruitsDB got created.

And now if I say use fruitsDB then we can say show collections inside this db

so we have this collection called fruits and that of course comes from this part

when we created our new collection using the db.collection method. And then we inserted a whole

bunch of data

if you're a member so we should be able to say db.fruits.find.

And we're going to leave the parentheses empty to show us all the data that we currently have. The keen

eyed amongst you will spot that we have 5 records instead of what you might expect to be 3 because

the first time we added apple, orange, banana and the second time we deleted the banana record and we

got an assertion failure.

Now assertion is quite a complex topic but in this case this is a nonfatal assertion.

So one actually prevent the insertion of these records but it simply alerts you to the fact that the

assertion has failed.

So the next step is how do we get our app.

js to find all of these records? How do we read our data inside our Node.js app?

Well it's only a short scroll away.

So the next part is find all documents and let's just go ahead and add this into our code

right at the bottom again and this section we have to specify the collection where we want to find something

from which if you remember earlier on was called fruits,

so let's change that to fruits. And then it's going to look through the collection and it's going to

find all.

And then it's going to save it into an array

and for that array we need to have some fruits. And in the callback

we're going to get back the object that we got from the find function and we're going to log those fruits

into the console.

Now if we hit save and call that find function inside again the client.connect,

in this case we're not going to insert any more documents.

We're simply just going to find our documents.

So I'm just going to copy that part of the code and we're going to update this method

client.connect to delete the insertion method call and just find those records inside our database.

Let's head back to our terminal connection where we've got our prompt and let's call node app.

js again.

So now you can see that we've found the following records and this printed in here is an array of Javascript

objects and you can see it looks very similar to what we've got in the Mongo shell but what's logged

here are actually the documents from our MongoDB

but here we've actually got our Javascript objects.

So if we now have access to these living Javascript objects inside an array in our app.js then we

can use our Javascript code and Node.js to do whatever it is that we wish with it.

As you can see this code is very very wordy and there's a lot of it that's just boilerplate code that

you have to add every single time you use the native MongoDB driver.

And for some people especially if you want to develop applications quickly it can be a bit of a pain.

So in the coming modules I want to show you what most Node developers will work with which is a module called

mongoose and it will vastly simplify the code that we have here and we will walk through how to use

mongoose to make your life developing Mongo and node apps so much easier.

So I'll see you there.