Express is referred to as a routing and middle way framework.

Routing lets our app do different things and display different information,

based on which you are at the browser requests, and how it requests it.

So sending a GET request to the slash login route leads to the login form.

While a PUT request to slash login, tells the app to authenticate the user

by comparing the form data against records in the database.

Middleware is software that sits in the middle of other parts of your application.

In other words, it's programming that runs after a request is received, but

before a response is sent back.

We've already seen a few examples of middleware.

For instance, most express apps ours included use the body parser module

to convert incoming requests into a format that's easy for

a JavaScript program to use.

The Express app gets a request.

Body parser takes the body of the request, makes it readable to our program

then hands it off to the next part of the Express application.

It sits in the middle of that request cycle.

Another example of middleware in our application is the Express session module

we used to track sessions for logged in users.

This is called application level middleware,

because it makes sessions available anywhere in our app.

You'll often use more than one piece of middleware.

In fact, you can chain together multiple middleware functions

that run one after the other.

In Express, middleware is a function that has access to the request and

response objects.

The entire process from request to response in Express

is called the request response cycle.

A typical piece of middleware is a function that accepts three arguments,

the request object, the response object and a third parameter named next.

Next is a function, and it represents the next piece of middleware,

the next function in the request response cycle.

In our app, we've added a bit of middleware to make sure that the user ID

property of the session is available to the application.

This middleware function assigns a user ID to the current user property.

When it's done,

it calls next, telling express to move on to the next piece of middleware.

When writing custom middleware, we must always include a call to next.

Let's take a closer look at the middleware we're already using in our app.

If you look in the app.js file, you can see multiple app.u statements.

These add middleware to the application.

Some are third party middleware, like session and body parser, and

some are built into Express like Express.static which lets a sort of

static files within a specific directory, like images and CSS files.

Also, towards the bottom of the file, there's error handling

middleware that defines middleware function in line as an anonymous function.

It accepts an error object and serves that to the user.

You can see that the error handling middleware takes four parameters,

the usual request, response, and next parameters but

the first argument is an error object.

There's also router middleware.

That's a function you add to particular routes.

You can find links to more information about Express middleware

in the teachers notes for this video.

Next, we'll write custom middleware for our user authentication system.

Specifically, we'll create router middleware to redirect visitors

based on their logon status.