એક્સપ્રેસ મિડલવેર કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**મિડલવેર** એ કાર્યો છે જે એક્સપ્રેસમાં વિનંતી-પ્રતિક્રિયા ચક્ર દરમિયાન **ક્રમમાં** ચલાય છે. પ્રત્યેક `(req, res, next)` પ્રાપ્ત કરે છે અને વિનંતી અને પ્રતિક્રિયાને ચકાસી/સંશોધિત કરી શકે છે, પ્રતિક્રિયા સમાપ્ત કરી શકે છે, અથવા `next()` કૉલ કરીને નિયંત્રણ આગામી મિડલવેરને પાસ કરી શકે છે. તે એક્સપ્રેસ એપ્લિકેશન્સ કેવી રીતે સંરચિત છે તેનો મૂળ છે.

## સહી અને સાંકળ

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

સમીક્ષણીય નિયમ: સાંકળ ચાલુ રાખવા માટે **`next()` કૉલ કરો**. તેને ભૂલી જાઓ (અને પ્રતિક્રિયા મોકલો નહીં), અને વિનંતી કાયમ માટે અટકી જાય છે.

## પ્રવાહ

```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.
```

## સામાન્ય મિડલવેર પ્રકારો

```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));
```

મિડલવેર **ટૂંકો પાથ** (પ્રતિક્રિયા મોકલો અને `next()` કૉલ ન કરો, દા.ત. અનધિકૃત વિનંતીઓને અવરોધિત કરો) અથવા વિનંતીને **સમૃદ્ધ** કરી શકે છે (ડાઉનસ્ટ્રીમ હેન્ડલર્સ માટે `req.user` જોડતા).

## ભૂલ-સંભાળી મિડલવેર (ચાર દલીલો)

```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
```

ભૂલ હેન્ડલર પાસે **ચાર** પરિમાણ છે (`err` પ્રથમ). તમે તેને `next(err)` કૉલ કરીને પહોંચો છો; તેને છેલ્લે નોંધણી કરવી જોઈએ.

## ક્રમ મહત્વપૂર્ણ છે

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

## શા માટે તે મહત્વપૂર્ણ છે

મિડલવેર એક્સપ્રેસ (અને સમાન ફ્રેમવર્ક્સ)નું આર્કિટેક્ચરલ બેકબોન છે — પ્રમાણીકરણ, લૉગીંગ, બોડી પર્સીંગ, CORS, માન્યતા, અને ભૂલ સંભાળ બધી મિડલવેર છે.

`(req, res, next)` કોન્ટ્રાક્ટને સમજવું (ખાસ કરીને તમે `next()` કૉલ કરવો જોઈએ અથવા પ્રતિક્રિયા મોકલવી જોઈએ), મિડલવેર વિનંતીને કેવી રીતે ટૂંકો પાથ કરી શકે અથવા સમૃદ્ધ કરી શકે, ચાર-દલીલ ભૂલ હેન્ડલર, અને તે **ક્રમ મહત્વપૂર્ણ છે**, કોઈપણ એક્સપ્રેસ એપ્લિકેશન બનાવવા, સંરચિત કરવા અને ડીબગ કરવા માટે આવશ્યક છે.