Exercise (Video): Mongoose ODM Part 1

Loading...

Del curso dictado por The Hong Kong University of Science and Technology

Server-side Development with NodeJS, Express and MongoDB

267 calificaciones

The Hong Kong University of Science and Technology

Server-side Development with NodeJS, Express and MongoDB

267 calificaciones

Curso 4 de 4 en SpecializationFull-Stack Web Development with React

This course deals with all things server-side. We base the entire course around the NodeJS platform. We start with a brief overview of the Web protocols: HTTP and HTTPS. We examine NodeJS and NodeJS modules: Express for building web servers. On the database side, we review basic CRUD operations, NoSQL databases, in particular MongoDB and Mongoose for accessing MongoDB from NodeJS. We examine the REST concepts and building a RESTful API. We touch upon authentication and security. Finally we review backend as a service (BaaS) approaches, including mobile BaaS, both open-source and commercial BaaS services. At the end of this course, you will be able to: - Demonstrate an understanding of server-side concepts, CRUD and REST - Build and configure a backend server using NodeJS framework - Build a RESTful API for the front-end to access backend services

De la lección

Data, Data, Where art Thou Data?

This module looks in detail at data storage with MongoDB, the popular NoSQL database. You will learn first about Express generator for scaffolding an Express application. Then you will learn about MongoDB. You will learn how to interact with MongoDB from a Node application. Then you will learn the Mongoose ODM to create schemas and models, and interact with MongoDB server.

Mongoose ODM21:58

Exercise (Video): Mongoose ODM Part 118:15

Exercise (Video): Mongoose ODM Part 214:18

Conoce a los instructores

Jogesh K. Muppala
Associate Professor
Department of Computer Science and Engineering

[MUSIC]

Now, that we have had a quick overview of Mongoose ODM and how Mongoose brings

schemas to structure the documents that we stored in our MongoDB.

Let's look at how we make use of the Mongoose node module,

and then incorporate it into our node application.

And then use Mongoose to communicate with our MongoDB server,

and then store and retrieve documents with structured information in the documents.

To get started on this exercise, go to a convenient location on your computer.

So here I am in the NodeJS folder.

Where I have been storing all the examples from this course,

and then I'm going to create a new folder named node-mongoose.

And this is where we will create the node application using Mongoose next.

In the terminal or the command window, move to the node mongoose folder,

and then initialize a node application there.

So let me type npm init and then initialize the node application.

And I will name the application as node-mongoose,

and the entry point is index.js, git repository, keywords.

Author and license, and we'll say okay.

And once your node package.json file is created,

open the project in the text editor of your choice.

So here, I have my project opened in Visual Studio.

Let me go into the packet.json file and then add in the start

script, and then will say start node index, as usual,

whenever we start out with a new node application.

Then going to that terminal or the commandment node,

let's install mongoose and bluebird into our application.

As we have learned, bluebird is the third party support for

promises that we're going to use in our node application here.

So at the prompt,

type npm install mongoose --save.

Which at the moment is mongoose 4.11.12,

and then do an npm install bluebird --save,

which at the moment is version 3.5.0.

So these are the versions that I'm going to be using in this course.

Then going to my application in the editor,

let me create a subfolder in the project called as models.

So this is where I'm going to be restoring all the models for my application.

And in the models folder, let me create a new file named dishes.js.

So this is where I'm going to create the schema and the model for

my dishes document that I'm going to store,

the dishes collection which stores the documents for each dishes.

So right there, let me first import mongoose.

So we'll require mongoose in this file,

and then say const schema

is mongoose.schema.

And then we'll create the schema here,

so we'll say const dishSchema = new Schema.

So this is where I define the schema for my dish.

All right. Inside this schema,

let me define the various values.

So I'll say name, Which is the type string.

So this is the schema type, and

then this I will declare as required, so I'll say true.

So every document will have the name

as a required field there, and then I will also declare this as unique,

meaning that no true documents should have the same name field in there,

so that is the first field in my document.

Then, we will also include another field called as description.

The description is of the type, String and

required true.

Also, we can have mongoose automatically

insert timestamps into our model.

So right there, we can just sit up that flag timestamps true.

So this will automatically add the created at and updated at.

Two timestamps into each document that is stored in our application.

And it'll automatically update these values whenever we update the document.

And the created at will be automatically initialized when the document is first

cleared or off this top.

After this, we will see wash dishes, so

given the schema, now,

we will to construct the model from this schema.

So we'll say mongoose.model('Dish') and

this is going to be using the dishSchema that we have just declared earlier.

And then we will Export this

module from this file here.

So we will say module.export = Dishes.

So now, we have constructed that mangoose.Schema and

the corresponding model and the model is now exported from here.

So this can be imported in our application and used.

So within our project folder, let me create a new file named,

index.js.

And in the index.js file,

let me first require('mongoose').

And then we will set up the,

Promise that mongoose uses, that third party library that mongoose uses for

Promise support, as require('bluebird').

So by doing this, now, mongoose in its,

Newer versions allows you to use party libraries for supporting mongoose.

So this is for supporting promises.

So this is where the promise property on mongoose

will allow you to specify which mongoose or

which Promise library you want to use for supporting promises.

By specifying this, we are indicating that mongoose will use bluebird

as a third party library for promises within our application.

And then after this, we can say const Dishes

require, ./models/dishes,

because we have already created the dishes model in

the ./models/dishes file there, and then we are requiring it here.

Now, to establish the connection to the mongoose

server that will say const url mongodb

localhost 27017 conFusion, so this

database is the one that we will connect to from application.

And then after that we establish the connection,

By saying const connect = mongoose, mongoose supports this

connect method, which takes the url as the first parameter.

And then the second parameter is where we specify

this option saying use MongoClient true.

So we can specify other options if they're required but in this

Exercise I'm going to use only the standard options and use MogoClient: true.

So this is what will encourage Mongo to use the MongoDB driver.

But the standard MongoDB driver to connect to the server.

So once we have established this, then we simply say connect then.

Note that since we are already using parameters, we can just say connect.then,

and then this will take a, Function as the parameter.

And inside here, we can now connect to the database.

So now, once this connection is established, let me

do a console log saying connected

correctly to server.

And here, I can create a new dish by

saying var newDish and then Dishes.

And inside here, I can specify a document.

So I'm creating a new dish of this kind.

And then so in here, I will specify that two

fields that are required, so I'll say name,

Description and so, this is how you would create a newDish.

And then once we create a newDish from the model, we'll simply say

newDish, .save().

The save method will cause this dish value to be saved,

and then as you expect will return a promise,

and then in here, we will get the dish value as the call back in there.

And then I can simply log the dish value here.

And then after that,

they'll see dishes, find and

so, we'll find all the dishes,

and then, We'll say exec.

The exec will ensure that this is executed, and that will return a promise.

And so, that promise will be returned, so

that it can then chain that method to that remaining one.

So you see how I am using promises, and then I am invoking the previous method.

So this one finds all that Dishes within

my database in the Dishes collection, and then makes it available to me.

So when I get the Dishes, then I can just console

log the dishes just to see what is returned.

And this obviously at this stage should

return this one single dish that I've

inserted into my dishes collection, and

then we will say return db.collection Dishes.

Drop, and that will drop the dishes

collection that has been created and then,

We will close the database,

and catch any error at this point.

So we'll use that catch,

And then console log

the errors, that's it.

So what we're doing here is we are creating the new, this dish.

And then we are saving the dish.

Then we are finding all the dishes from the collection.

Then we are dropping the collection and then closing the data base, that's it.

And we are using promises here, so we have changed all the events in here, that's it.

Let's save the changes, and then see this application executing.

Going to the terminal, add the prompt, type npm start and

you will see that my node application runs and that it shows first

that it has created this particular dish.

Note in particular that these two fields, updatedAt and createdAt,

these two timestamps have automatically been added into the dish here.

And so, you can see that createdAt and

updatedAt timestamp are exactly the same at the moment.

And then, the ID is also automatically added in.

And in the next step,we're printing out all the dishes that

have been retrieved, and so, you can see that this one single

dish is in that collection, dishes collection there.

And that is what is printed out on the screen here.

Let's now initialize the git repository,

and then let's setup the .gitignore file.

So going to the editor, let me create .gitignore file, and

then add node_modules to the gitignore file and save the changes.

And then going back to the prompt.

Let me type git status, and

we see that we have these files that have not been checked in.

So we'll say git add, and then git commit

with the message *Mongoose Part 1,

with this, we complete this exercise.

In this exercise, we have seen how easy it is to step up a note application

with Mongoose and to connect to our MongoDB server, and then interact with it.

Now, since Mongoose based upon the MongoDB server, Mongoose can access

all the various methods that are supported by the MongoDB driver also.

[MUSIC]

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play