Original subtitles

So, after all the talk about middleware,

let's now actually go ahead and

create our own middleware functions.

And again, remember that we actually

already used middleware before.

So let's take a look at that.

And, somewhere up here.

And so, you see that in order

to use middleware, we used app dot use, okay?

So, the use method is the one that we use in order to,

yeah, actually use middleware.

So, add middleware to our middleware stack, okay?

So this express dot json here calling this json method

basically returns a function, okay?

And so that function is then added to the middleware stack.

And so, similar to that,

we can create our own middleware function.

So, let's do that now.

And so, of course, we still need to use app dot use.

Okay, and so now, in here, all we have to do is to path

in our function that we want to add to the middleware stack.

So, remember from the last video that,

of course, in each middleware function,

we have access to the request and the response, okay?

But also, we have the next function.

And so, just like this, we edit as a third argument

to this middleware function, okay?

And like this, express then knows

that we are actually defining a middleware here.

Alright.

Now, just like before, actually,

we could have called this argument here something else,

like X, or N, or, it doesn't really matter.

What matters is that it's the

third argument to this function.

So express basically passes the next function

as the third argument into this middleware function.

And we can then call it whatever we want.

But again, next is really the convention in express,

and in order to avoid confusion,

we always use this name, okay?

And the same for request and response,

as I mentioned before, we could call them something else.

But the convention is to call them like this.

Anyway, let's just log something to the console,

here in this middleware function,

just so that we have some code to actually run

each time there is a new request.

Let's say hello

from the middleware.

And add some emoji here, again, to make it pop a little bit.

I really like that.

And what happens here?

Ah, right.

So that is the code that we want to execute here.

And now, just as we talked in the last video,

we actually need to call the next function, okay?

And if we didn't call next here,

well, then the request/response cycle

would really be stuck at this point.

We wouldn't be able to move on,

and we would never ever send back a response to the client.

So I can't stress enough how important it is

to never forget to use next in all of your middleware.

Okay, and it's as simple as that.

All we have to do is to specify next.

So, this argument here.

And then actually call that function like this.

Okay.

And with that, we are actually ready to test it out.

And all we have to do is

to send a simple request to our API.

So, here is the API.

Let's close up this one here.

And so, it doesn't really matter, because this,

of course, applies to every single request.

So, let's go back.

And indeed, we have hello from the middleware

logged to our console, okay?

So, great.

And I wanted to quickly touch on what I just said before,

which is that this middleware here applies

to each and every single request, okay?

And that's because we didn't specify any route.

So, remember that before I said that all route handlers

here are actually kind of middleware themselves.

They are simply middleware functions

that only apply for a certain URL.

So a certain route, okay.

But these more simple middleware functions

that we define up here,

well, they are going to apply to every single request.

At least, if the route handler comes

before this middleware.

So let me actually show you something.

And I'm going to cut it from here and

now actually put it here

after this route handler.

So what do you think is going to happen now

when I make a call to this route?

So let's see what happens.

So this exact route, so the one that I just showed you,

let me send the request to that.

And now let's go back and now we don't have

hello from the middleware.

So, why is that?

Well, simply because this middleware,

so this route handler here,

it comes before this middleware function that we have here.

And this route handler, which in this case,

is get all tours, actually ends the request response cycle.

So lets take a look at that.

So we have get all tours.

So, where is that?

Yeah, so here is the function and by sending a result

with res dot json, we actually

end the request response cycle.

And so the next middleware in the stack,

which in this case, is

is this one, so our custom one will then not be called.

Again, because the cycle has already finished, okay.

So make sure to understand that this order

really matters a lot in express, okay.

It's fundamental to understand

that this is how express apps work, okay.

So, in order to kind of test that,

let's try to see what happens when

we do a request to this route.

So to get tour update tour or delete tour.

So lets do this one, send the request here,

and let's go back and now we have

hello from the middleware.

So that is actually what we expected, right?

So that is because of course, this middleware here

now is before the route handler.

And so it is, of course, part of the middleware stack

that get executed before the request response cycle ends.

Alright, make sense?

So, let's take that back and so usually

we define this kind of global middleware

here before all our route handlers.

Alright, so this is one very simple

middleware function that we just defined to run some code.

But lets actually do another one.

And of course, we can have as many

middleware functions as we like.

And this time we actually want to

manipulate the request object.

So the signature here is always the same,

always request, response, and next.

And now let's actually manipulate the request.

All we want to do in this case,

is to add the current time to the request.

So we can simply define a property on the

request object called request time.

And then set it to a

new date,

which basically translates to right now.

And then we can use a very handy date function,

which is called to ISO string,

which will then convert it into a nice,

readable string for us.

So, let's pretend we have some route handler

that really needs the information about

when exactly the request happens.

And so the very simple solution is to simply add

something like this to a request using middleware.

Alright?

Now, don't forget, of course,

to call the next middleware in the stack, okay.

So right now, we have request, time on all requests.

So we can now use some route handler here,

for example, (mumbles) for getting all the tours

to simply log that for us to the console.

So console dot log, and its actually request time.

Okay, or we could even sent this in the response as well.

Let me just test that.

And let's just call this one requested at

and req dot request time.

That's the one.

And so, yeah, let's go ahead and figure this one out.

So our middleware is correct, right?

Yeah, so we call next, when we're done,

and so let's test this now.

Remember it's on get all tours.

And when we go back now, or when we go up,

well, it should actually be here.

So, what is wrong here?

You see that down here,

we actually just logged a function and yeah,

of course, we didn't actually call the two ISO strings.

So it's a method we have to call it.

So give it a save, try it again.

And now we have requested at and then today's date.

So, perfect.

That came from our middleware.

So simply because we added that property to our request.

Great.

So I hope that with that, you made a great step forward

in order to really understand how Node app work,

how middleware works,

how the entire request response cycle works,

because that really is going to make all the difference

when you're writing your own applications.