Hur fungerar Express middleware?

Question

Accepted Answer

**Middleware** är funktioner som körs **i sekvens** under request-response-cykeln i Express. Var och en tar emot `(req, res, next)` och kan inspektera/modifiera requesten och responsen, avsluta responsen eller anropa `next()` för att överlämna kontrollen till nästa middleware. De är kärnan i hur Express-appar är strukturerade.

## Signaturen och kedjan

```js
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`); // do something
  next();                                   // ⬅ pass control to the next middleware
});
```

Den kritiska regeln: **anrop `next()`** för att fortsätta kedjan. Glöm det (och skicka ingen respons), och requesten hänger fast för alltid.

## Flödet

```text
Request → [logger] → [auth] → [body parser] → [route handler] → Response
            next()    next()     next()         res.send()
Each middleware runs in order; any can short-circuit by sending a response.
```

## Vanliga middleware-typer

```js
// 1. Application-level — runs for all (or path-matched) requests
app.use(express.json());                       // built-in: parse JSON bodies
app.use(cors());                                // third-party

// 2. Custom — e.g. authentication that can SHORT-CIRCUIT
function requireAuth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).json({ error: "Unauthorized" }); // STOP — don't call next()
  }
  req.user = decodeToken(req.headers.authorization);  // attach data for later handlers
  next();                                              // authorized → continue
}

// 3. Route-specific
app.get("/profile", requireAuth, (req, res) => res.json(req.user));
```

Middleware kan **kortslutas** (skicka en respons och inte anropa `next()`, t.ex. blockera obehöriga requests) eller **berika** requesten (bifoga `req.user` för nedströmande hanterare).

## Error-handling middleware (fyra argument)

```js
// special signature with 4 params → Express treats it as an error handler
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Server error" });
});
// triggered by next(err) or a thrown error; place it LAST
```

En error handler har **fyra** parametrar (`err` först). Du når den genom att anropa `next(err)`; den bör registreras sist.

## Ordning är viktigt

```text
Middleware runs in the ORDER you register it. Body parser before routes that
read the body; auth before protected routes; error handler last.
```

## Varför det spelar roll

Middleware är den arkitektoniska ryggraden i Express (och liknande ramverk) — autentisering, loggning, body-parsning, CORS, validering och error handling är allt middleware.

Att förstå `(req, res, next)`-kontraktet (speciellt att du måste anropa `next()` eller skicka en respons), hur middleware kan kortslutas eller berika requests, fyra-argument error handlern, och att **ordning spelar roll**, är essentiellt för att bygga, strukturera och felsöka vilken Express-applikation som helst.