Narrator: So, our API is now basically finished.
And so in this final video of the section,
we're gonna quickly create documentation
for API directly in Postman.
And that's right, we can easily create
some quick documentation right in Postman.
And it's really important to have API documentation
in place because this is how we communicate to team members,
or even our final users of the API,
how they can actually use it in practice.
So let me now show you how it works.
Now before we can actually create the documentation,
let's just do some clean up here.
For example, get rid of this request, all right?
Another thing that I want to do is here in the logging in
point, we actually expose our password here.
And so that's not a good idea, and so what I'm gonna do
is to create an environment variable
which is going to hold this password.
Since it's always the same that should be no problem.
So, remember how we do that.
Well we come here to managing the environment
and so here we simply add another one.
So password, test1234.
And here this is not correct, so password, updated,
and now, let's do the same here
in the production one as well.
So password, test1234.
And so, not add, but let's close that
and so here I can now then go add and use that,
not in a string, but like this.
So password.
So let's try that.
And this gives us this weird error,
but our password is actually here so probably what
we need to do is to actually really put the quotes here.
So let's try that.
And so now indeed we're successfully logged in.
So save that now, okay?
And so now what we should do is to actually create
a description for each and every request
that we have in our collection.
Now of course I'm not going to do that,
I will just exemplify it here with the first one.
Okay?
So let's actually close these other ones
and so now here we can add a description.
And so let's just say, use this endpoint
to create a new tour.
Okay, and so again, you should now do this exact same thing
for all of your requests if your goal is to really publish
and share your API, okay?
Then the same thing applies to folders,
and to not rename, but to edit.
And so in each of these folders
we can actually also add a description.
So let's just say, something random like,
you can get all tours,
create new ones,
and edit and delete tours.
There are also special endpoints
for some special requirements.
Okay, so and again this is totally random
and I would publish something like this for my own API,
but here we really just want to test how it works, okay?
As you can see down here,
you can also use Mark down here, okay?
So for example, to make text bold,
you can think it works like this,
yeah it looks like it does,
and so yeah you can do all kinds of stuff here, okay?
You can also probably create a description
on Natours itself, so let's say,
the Natours API contains endpoints
for tours, users, and reviews.
And then again a bunch of stuff,
like you could describe your authentication process,
or your permissions and really everything the user needs
to know in order to use this API, okay?
So you should always add description
to all the requests, to all the folders
and also to, of course, the collection itself.
Oh, and we can actually describe the query parameters
in a query string, so let's do that here.
And we can also say it supports greater than,
less than equal, greater than and less than operators.
So again, just an example here
and let's save it now to the request.
And so with this I think we should be ready
to actually publish our API documentation.
And so for doing that, let's just go here
to the collections option, and then down here,
publish documentations.
And so that should then open up a browser window,
and for me it did outside of my screen
so let me just get that here.
And so now you can choose the environment.
So here we should have a list of our environments,
which for some reason we do not have, that's weird,
but anyway, we didn't want to use any environment anyway,
because that would then replace
our environment variables with their real values,
and we don't want that.
For example, we used the environment variable
on the password, so that then later
in the documentation it's not really visible, okay?
So we really want to use no environment.
Now we could also use a custom domain,
but that's only for paid users, okay?
Then we could also change all of the styling
of the API so to match it with your brand colors,
but again, that's not necessary in this case,
and so, let's actually go ahead and publish it.
And so now, this is actually public,
so everyone can view your documentation now on this URL.
Now for some reason it didn't really update all
the changes that we just did before, so that's a bit weird.
So let's actually go back to Postman
and see what's going on.
Maybe it has to do with this rotating thing here,
so I will just quit Postman and open it again.
And let's hope that fixes it.
So if we now reload here,
ahh then we get all our changes actually here.
So you see, the description that we added
for the Natours collection, okay?
Then also the description for this folder,
and the description for this request.
And finally, as the first description,
also for this parameter, okay?
Here we do then get the URL environment variable
instead of the actual URL.
Now of course, you might want to actually give
the real URL here and for that
you could simply use another environment.
So up here you can actually see all the environments
but they are private, so right now no one can use them,
but remember how in the first step,
we could have actually created this documentation
using one of the environments, and so probably we would have
used the production environment for that and so with that
we would then have the final production URL
here in our API URL's, okay?
Anyway, this is how the documentation looks like,
so here is the example request
and we can change that also to our own language.
So in this case, Node JS, but if the user is
for example doing a request using jQuery,
then they can just use jQuery, okay.
So just to see this example request here, so with Node,
it looks something like this.
So, here we have all our endpoints
and you can see that the ones that require authentication,
they actually have this lock icon here.
And so in your description you could now then add that
saying you need to log in, in order to access this endpoint,
and also how you can actually log in, okay.
Or you can also describe that here
in the authentication section, right?
So ideally, you would have descriptions for all of this.
Oh, and here I see that we actually forgot
to replace the real password but nevermind
as this is really just some example, okay?
But of course, you get all the requests
that we had in our Postman also right here.
Now another nice feature here is this run in Postman button,
and so if someone has Postman installed on their computer,
all they need to do is to click here
and then open with their Postman application.
Now I'm not going to do that right now because of course,
I already have it in my Postman, but otherwise
this is a really nice feature for the users to then go ahead
and right away start experimenting with your API.
Okay, and I think that's it actually
so this wraps up our section
and our API is now finally really completed.
So again, congratulations for making it this far
into the course, we've already covered
so much ground here together.
Now next up, there is a very, very exiting section
ahead where we will finally build
the user face for the Natours website.
So basically, we're going to use templates
to create a completely dynamic website based
on all the data that we already have in our database.
And that's really cool.
And so I can't wait to show that to you.