So now that we're storing a newsletter successfully,
let's also store and fetch our comments.
For this I'll go back to the comments API route,
and now here we also wanna connect with MongoDB,
and then simply insert a new comment or fetch all comments.
So either way, no matter what happens,
we wanna connect to MongoDB.
So before we dive into any if block here,
I wanna set up my connection.
Hence, we need to import
MongoClient
from mongodb here,
and then repeat the code from before.
And of course we definitely could also look
into creating some helper functions,
but I will just quickly repeat that.
MongoClient connect, and then grab my connection string
from the newsletter js file.
Paste it in here.
And again I'll use async await.
So add async in front of the handler function,
and await disconnection to get access to the client.
Now already after all these if checks, I will go down there
and already call client close to make sure
that we don't forget this.
That we close the connection once we're done with our logic
no matter what our logic was.
So now that's that.
Now inside of request method POST,
we wanna store our comment here in our database.
And for this I'll create my new comment,
but then thereafter, I will use the client
and the db method to get access to the database
to which we connected.
And for that actually,
I wanna adjust the connection string here,
and not connect to a newsletter database,
but instead to my comments database.
Or, overall, we connect to our events database
for the events application.
And then we have our emails collection
and we have our comments collection.
And I think that makes more sense.
So I'll connect to the events database
in the newsletter js file as well,
and connect to the same database here
in the comments API route, events.
So then it's this database which will work,
and on that database, I then use the emails collection
in the newsletter js file,
or maybe let's now name the collection newsletter.
But that's of course up to you.
And in the comments event id file here,
I'll connect or I'll work with a collection named comments.
And here I now wanna insert one new comment.
Now it is this comment,
but I wanna tweak that comment object.
I don't wanna create my dummy id anymore,
because MongoDB will create a unique id for me.
So I don't need to assign my own id.
But instead I wanna do something
which I haven't done up to this point.
I want to use this event id which we're getting,
which is encoded in the URL.
And I wanna make it clear
to which event my comment is related.
Because in reality,
we would probably manage our events with MongoDB as well.
We're not doing that here,
but in reality we would probably manage them
in the database as well.
So then, storing the id of the related document
in some other collection in this document here
would make a lot of sense.
And that's definitely what I'll do.
I'll store eventId as a extra property
in the new comment to have this reference to the event
to which this comment belongs.
And then it's this new comment which I wanna insert.
So here I'll insert one, and I'll insert this new comment.
And of course await this operation.
Now we do get back some response here by the way.
Some result of that insert one operation,
and I will console log that result for now.
In the effort that's now my code here in the post case
so that we add a new comment.
Before we work on the get case here, let's save that code
and let's see whether it works and makes sense.
For this I'll dive into an individual event,
show my comments, and add a new comment
with some dummy data.
This is a test with MongoDB.
Click Submit.
We still get no feedback here.
We could add it,
but we haven't done anything in that direction.
But if I go the back end, that looks good.
I got a output here.
That's this result which I'm logging.
Whoops.
This result which I'm logging, that's what we see here.
And we see that it's quite a long result.
Quite a detailed output because result in case of insert one
is actually containing full details
about the operation that was performed,
but then also the connection in general and much much more.
Now what we can see if we go to the cluster
is that here if we reload this page to refresh the data,
we got this events database now with a comments collection,
and in there we indeed see that comment which I just added.
So it was stored successfully in the database.
Now what's also interesting on the result
is that on the result we also get back that unique id
which was generated automatically.
That's interesting because that means that
on the new comment object, which we stored in the database,
we can now add a id field
and set this equal to result.insertedId.
So that the new comment which we sent back
to the front end also contains this unique id
that was generated.
I guess that's convenient to have in case we would work
with that inserted comment on the front end right away.
So that's now the post case.
Let's now work on the get method where we get our comments.