Jonas: So we learned about Document
and query middleware, and now the last middleware
that we're gonna talk about is aggregation middleware,
and as you can probably guess,
aggregation middleware allows us to add hooks
before or after an aggregation happens,
and so let's now actually continue with
our previous example where we did hide the secret tours
from the queries, now in an aggregation the secret tours
are still being used, right?
So let's quickly confirm that actually,
for example here in our gets tour stats,
so that's where we used the first aggregation
and so you see we have four tours here,
four in easy, and three in medium
and so that makes 11 but we already know
that we actually only want 10 tours.
So there are 10 tours that are not secret,
and one that is secret, and so now we get all these
11 tours here and so basically we also want
to exclude the secret tour in the aggregation.
So how could we do that?
Well let's take a look at where our aggregation
is actually happening so it's down here in yeah,
so in get tour steps, and so what we could do is to here
in this match state simply exclude the secret tours
that are true right?
So that would be quite easy to add here,
but then we would have to add the same thing
down here in the other aggregation that we have,
and if we had even more aggregations we would then
have to add that in all of them and that's of course
not a good idea, because for example we could forget
to do it and it's also just repetitive code
and so let's simply exclude it right at the model level,
alright so let's add aggregation middleware here
starting with a comment.
So aggregation middleware and so just like before
we have tourSchema.pre so we want this to happen before
the aggregation is actually executed
and so here we use the aggregate hook.
Alright and then our function which again accepts
the next function so calling the next middleware.
Alright, so let's start by taking a look
at this, so remember that up here in query middleware
that this object points to the current query.
Then here in document middleware the this object
points to the current document,
and so down here in aggregation middleware
this is going to point to the current aggregation object.
Okay and so let's take a look at that in the console
but before that let me just remove this log here.
Alright give it a save, run this aggregation here
and that's taking a lot of time and so let's cancel it
and go back and that's probably because
we're not calling next here, and so like we already know
we get stuck in the middleware function
and so that's not good.
So let's try that again now send,
and yeah so now we're back and now let's take a look
at the aggregation object.
Okay so there's a lot of stuff in here
so it's not really interesting here
and I cannot really find what I'm trying to show you here
and so let's simply add this.pipeline okay because what
I really wanted to show you is just the pipeline object.
Okay, and actually it's pipeline like this
so it's actually a function, a method.
So let's clear the console here.
Try this again, and so here we get the aggregation pipeline,
and so that's simply the array that we passed into
the aggregate function before.
Right, so let's take a look and so here we have
that array, this one not this one.
So we have the match to group
and then the sort so if we take a look here
at the console we have indeed our match with the ratings
average we have group and then sort.
So that is exactly the pipeline we specified before,
and so now in order to filter out the secret tours
all we have to do is to add another match stage
right at the beginning of this pipeline array,
right and so let's do just that.
So let's do that here before this log,
so this.pipeline and remember that this is an array
and how do we add an element at the beginning
of an array?
We use unshift and so that is a standard JavaScript
method for arrays okay, we have also shift to add
at the end of the array and unshift at the beginning
of the array, and so again what we want to add here now
is to add just another stage, so very similar
to what we have down here.
So match and then secretTour, not equal to true.
Give it a save, and so this piece of code here basically
is exactly what we have up here right?
Basically removing from the output all the documents
that have secretTour set to true, right?
So if you give it a save now, then let's check this out,
and remember we have now 11 tours, four, four,
and three so let's check the result afterwards
and so now indeed one of the difficult yours is gone
so we only now have three difficult tours meaning
that we are back to just having 10.
Okay and actually we can confirm that our super secret tour
was a difficult tour, alright and so that is now gone
and so our results are now only about the regular
non-secret tours alright?
And we can again take a look at our aggregation pipeline now
and here you see that now we have these two matched stages.
Great and as I mentioned before it's no problem
to repeat these stages, we can have as many match stages
as we want, okay and that's it for aggregation middleware.
I'm not gonna include any post code here for middleware
that's not really necessary alright,
and I'm also not gonna talk about model middleware here
because it's really not that important.
Alright, so middleware is some really cool
and important stuff that we can add to our models,
and there is indeed other cool stuff
that we can do with models, for example implementing
instance methods which are methods that will be available
on ever document after being queried,
and that again can be quite handy,
and we will do that later
in the authentication section as well okay.
So I'm gonna leave that for a bit later,
now what we are gonna do in this section
just to finish is to actually add some validation, alright
and so in the next two videos we're gonna talk about that.