All language subtitles for 004 Creating a Simple Tour Model_Downloadly.ir_en

So in the last lecture, we learned about

Mongoose schemas and models,

and so let's now implement a very simple

schema and model for our application.

And for now, let's do that right here

in our server.js file.

Later, of course, we're gonna move

that into a different file.

So, Mongoose is all about models,

and a model is like a blueprint

that we use to create documents.

So it's a bit like classes in JavaScript,

which we also kind of use as blueprints

in order to create objects out of them, right?

So again, we create a model in Mongoose

in order to create documents using it,

and also to query update and delete these documents.

So basically, to perform each of the CRUD operation,

so create, read, update, and delete,

we need a Mongoose model, and in order to

create a model, we actually need a schema.

So, we actually create models out of

Mongoose schema just like we learned

in the last video, and we use the schema

to describe our data, to set default values,

to validate the data, and all kinds of stuff like that.

So just as you will see right now,

because now we're actually gonna start creating

a very simple schema for our tours.

So, let's say tourSchema

is a new mongoose.Schema.

Add that in here we actually pass our schema as an object.

All right, we can then also pass in some options

into the schema, but I'm leaving that to a future video

where we actually need that feature.

So, remember the tour documents that we used

to create in the last section when

we started exploring Mongoose DB?

So we always gave them a name,

a rating and a price, right,

and so let's now replicate that here

by saying name, and then describing

what type of data we want after name,

and we want it to be a string.

So Mongoose actually uses the native

JavaScript data types, and so here we can say string,

or after rating we can say that we want a number

and the same as the price.

It should also be a number, right?

So this is the most basic way of describing our data.

So we have a name, a rating, and a price,

and we specified the data type

that we expect for each of these fields.

So again, this is the most basic way

of describing a schema, but we can take it

one step further by defining something called

schema type options for each field,

or only for some specific field.

So let's start here with the name,

and instead of just specifying it

as a string, let's actually pass in another object.

And so now, we say that we want the type

to be string but we can now

define a couple more options, okay?

For example, we can say that this field is required,

and so we simply set

the required property here to true, all right?

So again, this object here are the schema type options,

and they can be different for different types,

for example the number type has some different

schema options than the string here,

but many of them are also similar.

So for example, the required, we can use it

on number as well, and so let's do that here.

So the type, we still want it to be a number,

and we also want it to be required, okay?

Now, here in the required we can actually

specify the error that we want to be displayed

when we're missing this field.

So, in order to do that we just have to

pass in an array, and the first one is true.

So the first element is true, and the second one

is the error string.

Let's say, a tour must have a name,

and then here let's do the same.

The tour must have a price, okay?

Then we can also set default values

and let's do that here for the rating.

So again, I'm gonna specify some

schema type options here, which is not mandatory,

so it's enough to simply define

the type here like we did, but if you want

some more features, then we need to to at least

specify the schema type options object.

Okay, and then we need to specify the type again,

which is number, and as a default, I want it to be 4.5.

And so if we'd now create a new tour document

using this schema and not specifying the rating,

it would then automatically be set to 4.5, all right?

And just to finish, let's try another one here,

which is to say that the name should be unique.

So, unique and set it to true,

and so like this, we can now have two

tour documents with the same name, all right?

So, this is our very basic schema,

let's now go ahead and actually

create a model out of it, all right?

And that's very simple,

we simply create a variable called Tour,

and then mongoose.model,

then the name of the model, which is Tour with an uppercase

T here, all right.

And so that's just kind of a convention

in programming to always use uppercase

on model names and variables.

So here it's the same, so I also created

this tour variable here with a capital T

just so we know that we're dealing with a model here.

All right, so the name of the model

and then the schema, and that's it.

So just like this, we created a tour

out of the schema that we created here in the beginning.

All right, and so in the next video

we're gonna then use this model here

in order to create our very first tour document, all right?

So just a recap here, we used new mongoose.Schema here

to specify a schema for our data.

So, basically describing it and also doing some validation.

For example, this required here,

this is actually something called a validator

because it is used to validate our data.

In this case, simply to validate

if the name is actually there.

And there are a lot of validators in Mongoose,

and we can actually also create our own,

and so of course we're gonna talk about that

a bit later, again, once we actually need these features.

Anyway, let's now quickly move on

in order to finally start using

the model that we just created.