Hey that everyone that they sure and welcome to another section of this pro back end of course.
Now, before we move ahead into this section, it is very important to understand that where we have
reached so far, so that you can understand the beauty of the structure of this course, definitely
that is one thing.
But it will also help us to understand that where we have reached so far and what we have to do now.
Game Plan Action Plan is one of the most important things while learning, and that's where I will help
you.
So let's talk about the entirety of the things so far what we have learned, what we have done, what
we need to do further, and how we are going to proceed.
So, so far, now we know that how we can move things on to Heroku.
We have seen that.
How much important is the port variable and how much important of the line the process is?
And that we haven't talked much about it because there was no need of it so far.
But now obviously it is going to be in need of it.
So from the very first section, we are taking care that how things move into the production, we need
to take care of that and we will be doing that.
But nonetheless, we still know that how we can push things onto Heroku and we will now move on in a
similar direction that we have to push it on there.
So we need to use all those information.
Apart from this, we also know a whole lot about the request and response.
We have dedicated the entire section of the swagger, and the reason why that section comes first is
so that you can understand more about the request and the response, and you get enough time to study
more about the documentation of EXPRESS.
And now we are at this position that if the data comes up from the URL, from the query, from the body,
or maybe the images, you can handle all of them into your backend.
Not only that, you also now understand that how you will be sending some response, whether it's a
regular response as a string format or maybe a JSON response or a status code.
So you know all about this.
This is so much of a good progress, but we have seen that we fall into some of the problems.
In case you noticed in the last video, we were writing everything into the app.
JS So we need to understand a couple of things that files are getting really big and file, which needs
too much of the scrolling are really not the best thing.
Surely in some cases we need to keep things organized as well.
It's not really about getting the file too big, but it's more about the organization and you might
be asking why we need that organization.
This is already working great.
Yes, that's a good point.
But we are going to be working into a multi development environment.
There will be multiple development developers involved in the project.
Some will be handling controllers, some will be handling routes, some will be writing maybe middleware
and all that thing.
So we need to take care of that part.
So we will be working on that now.
We will be doing this a step by step.
It's not like you are going to learn the entirety of how to rip apart a project into multiple separate
file in just this section.
Eventually we'll do it.
We'll do some part in this section and the later on will come up into the next section.
Nothing is permanent so far.
This is also another of the problem that we have seen so far.
We created an array.
We were pushing into the array, but as soon as the server restarts, it just poof, everything is gone.
So this brings the need that we need to now inject a database.
Now what database?
You'll be choosing, what Aurum will be, we'll be choosing and what even Aurum is.
We need to take care of all these things, but one thing is absolutely sure that we need some kind of
database and we need to study a little bit about it.
So how we choose the database, how we make a study of the database, again, that comes up just almost
like EXPRESS.
But I will walk you through with that.
Now, one thing we need to absolutely make sure that happens in our back end is we need to hide our
secret.
Now, eventually are going to notice that that process, that EMV, we saw that in the Heroku, that
it's a very secretive file and it has a key value pairs.
That means some variables need to be declared and some value needs to be declared.
Your entirety of the back end is run through those secrets.
Those secret can be a direct link to your database URL, maybe some of the secrets that will help you
to generate some algorithms.
And by the time algorithms I mean to say edge mac algorithm or maybe SHA 52 or maybe SHA 256 not SHA
to 250, SHA two 5256.
So we'll be having a whole lot of such algorithms that are governed by the secret or some seed values.
And these are some secrets that we need to protect and for that we'll be studying all of that.
So just to give you a quick summary, we need to learn how to inject the database.
We need to make sure that files are being separated out into multiple components.
And we also need to take care how we can hide the secret.
So there is a lot more that we have to go through now and there is a lot that we have already learned.
So now you have the idea.
Now just one last thing.
There is also one issue that we need to address and we obviously will be addressing in this particular
section right now.
All of our routes are open, get post or whatever that out are creating.
Those all routes are open.
Anybody can access those routes and can just put any value into that.
We need to learn how we can authenticate those routes, maybe by username and password, or maybe there
are a couple of other ways as well, but we need to learn that now and that's exactly what we'll be
doing in this section.
So I hope this gives you a clear idea of what we have done so far and what we are going to do in the
next section.
Let's go ahead.
And walk into the next one.