Original subtitles

So, Mongoose offers us developers

very powerful ways of validating data

that's coming into our model.

And so, in this video you're gonna learn

all about data validation with Mongoose.

Now, what exactly does validation actually mean?

Well, validation is basically checking if the entered

values are in the right format for each field

in our document schema, and also that values

have actually been entered for all of the required fields.

Now, on the other hand, we also have sanitization,

which is to ensure that the inputted data is

basically clean, so that there is no malicious code

being injected into our database,

or into the application itself.

So, in that step we remove unwanted characters,

or even code, from the input data, all right?

And this is actually a crucial step, like,

a golden standard in back-end development.

To never, ever accept input data

coming from a user as it is.

So, we always need to sanitize that incoming data.

But, anyway, I will leave data sanitization

for the security section of the course,

so that in this lecture

we can focus entirely on data validation.

And we are doing this data validation

right here on the model.

And that, again, is because of the fat model

and thin controller philosophy,

which makes the model the perfect place

to perform validation, right?

And, in fact, Mongoose already comes with a bunch

of validation tools out of the box.

And so, let's now actually do some data validation here.

And actually, we already did.

So, when we used this require here, that is actually

already a built in data validator, all right?

So you see that we use a validator like required

right here in the schema type options.

And required is actually available for all the data types.

So, not just strings, but really everything.

Numbers, Booleans, dates, or really,

whatever type you're using.

Then we also have unique here, but please note,

that this is actually, technically, not a validator.

It will still produce an error

when we have a duplicate name,

but again, this is not really a validator, all right?

But, required is a validator,

and so I'm going to show you now another one

which is specifically just for strings,

which is called max length and also min length.

So, we have max length

and as the name says, we use this to specify

the maximum length that a string can have.

And if it's longer than that, well then,

it's going to produce an error, all right?

So, let's do that just like we did before with required,

where we specified an array, and then set the value.

So, let's say we want 40 as the maximum string length,

and then, we add the error after that.

So, basically, the error message that we get.

So, a tour name must have

less or equal then 40 characters.

Okay, so, that is max length,

and then we also have min length.

All right, and so let's set that one to 10,

so a tour name must have more or equal then 10 characters.

Okay, and so just like this we have these two validators

that are actually only available on strings, okay?

And, so let's now actually go ahead and try that.

So, I'm going to create a new tour here.

And, this is not a secret tour,

but then here the rest does not matter.

I will just call this one Test Tour,

and let's see how many characters we have,

so four plus one, plus four,

so we only have nine characters.

And so, we should now expect to actually get an error.

So, let's try that out.

And, indeed, a tour name must have

more or equal then 10 characters.

Great, but now what about updating tours?

So, let's get one of these here.

So, we have this test tour two here,

so let's try to update this one.

So, we go to our update tour route.

And now let's here, change the name to Test,

send the request, and, we get the same error.

Now, this only works because of a setting

that we set way back,

when we implemented this updating handler.

So, let me quickly show that to you in the tour controller.

Delete and update, and so it's because of this option

here runValidators, set to true

that the validators are run again.

If I set it now to false,

then Mongoose should happily accept this name.

And indeed, it does, all right.

So, let's set it back to something longer,

it doesn't matter,

okay, and if I set it back to true,

then it should not accept it,

and indeed, we get our error back, all right?

So, just wanted to quickly

show you the fact of that setting.

All right, and so, yeah, these are now working.

Let's try a couple of more validators here.

For example, now on numbers.

So, let's go here to the ratings average.

And we know that the rating must always

be between one and zero, and we know that a rating

must always be between one and five, okay?

And so, very similar to the min and max length,

on numbers we simply have min and max.

So, the minimum that we want is one,

and then again our error message.

So, rating must be above 1.0, let's say.

And then the max is five.

Must be below 5.0, okay,

and let's quickly test this one as well.

So, creating a new tour, let's call it the Test Tour Amazing

because it has an average rating of six.

Okay, so let's see what happens then,

and indeed, the rating must be below five.

Okay, and so, that again is not going to work,

and of course it cannot be zero, either.

So, it must be above one, and of course,

with four, it is gonna work, and indeed, here is our tour.

Next up, I want to restrict this difficulty value here

to only three difficulties.

So, easy, medium, and difficult.

And if the user puts in something else,

then it's not going to work.

So, let's try that out.

So, the validator that we use for that is called enum,

okay, and so, here we can pass an array

of the values, basically, that are allowed.

So, we have easy, we have medium, and we have difficult.

All right, now we also want to specify our error message

here, but right now that's not really possible, right?

I mean, if we added another argument here,

then that would not be for the error message,

it would of course be for yet another possible value, okay?

And so, the solution that we need to do here,

is to create yet another object here,

and then, actually specify that these here are the values.

And then, our message, all right?

And so, this is actually how it really works.

This notation here is really just a shorthand for

this complete object here, all right?

So, difficulty is either: easy, medium, or difficult.

Okay, and so, that is a very nice, very handy validator

that is automatically available on all strings, okay,

so, don't try to use this one here on numbers, for example.

This is only for strings.

And, by the way this min and max here

is actually not only for numbers,

but it's also gonna work with dates, all right?

Anyway, let's now finally test this out as well.

So, we need to change the name,

and in here let's put something else,

all right, and so indeed, we get our error.

If we now put easy, then it works.

Okay, and that's actually all I wanted to show you

here in this lecture,

but there are actually a bunch of other validators.

For example, on strings you have a match validator

in order to check if the input

matches a given regular expression.

But, I believe that these ones that I just showed you here

are the most important built in validators.

And, for a complete list of all of them,

of course, you can always check out the documentation.

Now we can also specify our own validators,

and so, that is exactly what we will do

right in the next video.