FastAPI ਵਿੱਚ middleware ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**Middleware** FastAPI ਵਿੱਚ ਇਹ ਕੋਡ ਹੈ ਜੋ **ਹਰ ਇੱਕ request ਅਤੇ response** ਲਈ ਚਲਦਾ ਹੈ — ਤੁਹਾਡੇ endpoints ਨੂੰ wrap ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ logging, timing, CORS, ਅਤੇ headers ਸ਼ਾਮਲ ਕਰਨ ਵਰਗੀਆਂ cross-cutting concerns ਨੂੰ ਸੰਭਾਲਿਆ ਜਾ ਸਕੇ। FastAPI Starlette ਦੇ middleware system ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ (ਇਹ ASGI-ਆਧਾਰਿਤ ਹੈ)।

## Custom middleware ਲਿਖਣਾ

```python
import time

@app.middleware("http")
async def add_timing(request: Request, call_next):
    start = time.time()
    response = await call_next(request)        # call the endpoint (and any inner middleware)
    response.headers["X-Process-Time"] = str(time.time() - start)   # modify the response
    return response
```

ਇਹ pattern ਹੈ: `await call_next(request)` ਤੋਂ ਪਹਿਲਾਂ ਦਾ ਕੋਡ **ਅੰਦਰ ਆਉਂਦਿਆਂ** ਚਲਦਾ ਹੈ (endpoint ਤੋਂ ਪਹਿਲਾਂ), `call_next` endpoint ਨੂੰ invoke ਕਰਦਾ ਹੈ, ਅਤੇ ਪਿੱਛੋਂ ਦਾ ਕੋਡ **ਬਾਹਰ ਆਉਂਦਿਆਂ** ਚਲਦਾ ਹੈ (response ਨੂੰ modify ਕਰਦਿਆਂ)। ਇਹ ਹਰ ਇੱਕ request ਨੂੰ wrap ਕਰਦਾ ਹੈ — ਇੱਥੇ, ਸਾਰੇ responses ਵਿੱਚ ਇੱਕ timing header ਸ਼ਾਮਲ ਕਰ ਰਿਹਾ ਹੈ।

## Request/response ਦਾ ਵਹਾਅ

```text
Request  → MW1 → MW2 → endpoint
Response ← MW1 ← MW2 ← endpoint
Middleware wraps the endpoint; runs in order on the way in, reverse on the way out.
```

## Built-in / common middleware

```python
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.gzip import GZipMiddleware

app.add_middleware(CORSMiddleware, allow_origins=["https://app.example.com"], ...)  # CORS
app.add_middleware(GZipMiddleware, minimum_size=1000)                               # compression
```

Middleware ਆਮ ਤੌਰ 'ਤੇ `add_middleware` ਦੁਆਰਾ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ — CORS (cross-origin requests ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ), GZip (responses ਨੂੰ compress ਕਰੋ), ਅਤੇ trusted-host ਜਾਂਚ ਆਮ built-ins ਹਨ।

## Common middleware ਦੀਆਂ ਵਰਤੋਂ

```text
✓ Logging / request timing / metrics
✓ CORS (cross-origin request handling)
✓ Adding security or custom headers
✓ Response compression (GZip)
✓ Request ID / correlation ID injection
```

## Middleware ਬਨਾਮ dependencies

```text
Middleware   → runs for ALL requests; works at the raw request/response level (headers,
               timing, the whole response). Best for truly global concerns.
Dependencies → per-endpoint (or grouped) logic with access to parsed params, DI, and
               typed values. Best for auth, validation, shared parameters.
→ Use middleware for global cross-cutting concerns; dependencies for endpoint logic.
```

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

Middleware FastAPI ਵਿੱਚ **global, cross-cutting concerns** ਲਈ ਸਹੀ mechanism ਹੈ — ਤਰਕ ਜੋ ਹਰ ਇੱਕ request ਅਤੇ response ਲਈ apply ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਵੇਂ logging, request timing, CORS, compression, ਅਤੇ custom headers।

ਇਸ ਨੂੰ ਸਮਝਣਾ applications ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ structure ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ: middleware ਸਾਰੇ endpoints ਨੂੰ wrap ਕਰਦਾ ਹੈ (ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਚਲਦਾ ਹੈ, request ਅਤੇ response ਦੋਵਾਂ ਨੂੰ modify ਕਰਨ ਦੀ ਯੋਗਤਾ ਦੇ ਨਾਲ), ਜਿਸ ਨਾਲ ਇਹ app-ਤਰਫ਼ੀ ਵਿਵਹਾਰ ਲਈ ਆਦਰਸ਼ ਹੈ ਜੋ ਹਰ ਇੱਕ endpoint ਵਿੱਚ ਦੁਹਰਾਉਣ ਵਿੱਚ ਖਿਝ ਅਤੇ ਗਲਤੀ-ਸੰਭਾਵਨਾ ਵਾਲਾ ਹੋਵੇ।

**Middleware** (global, raw request/response level) ਅਤੇ **dependencies** (per-endpoint, parsed/typed values ਅਤੇ DI ਤੱਕ رسائی ਦੇ ਨਾਲ — auth ਅਤੇ validation ਲਈ ਬਿਹਤਰ) ਵਿਚਕਾਰ ਫ਼ਰਕ ਜਾਨਣਾ ਸਹੀ tool ਚੁਣਨ ਲਈ ਮੁੱਖ ਹੈ।

CORS ਅਤੇ compression ਵਰਗੀਆਂ ਆਮ ਲੋੜਾਂ built-in middleware ਦੁਆਰਾ ਸੰਭਾਲੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਦਕਿ custom middleware logging ਅਤੇ instrumentation ਨੂੰ cover ਕਰਦਾ ਹੈ — ਇਸ ਨੂੰ well-structured, observable APIs ਬਣਾਉਣ ਲਈ ਅਖ਼ਤਿਆਰੀ, ਅਕਸਰ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।