Next.js middleware எதற்காக பயன்படுத்தப்படுகிறது?

Question

Accepted Answer

**Middleware** என்பது **ஒரு கோரிக்கை முடிவடைவதற்கு முன்** — Edge-ல், பக்கம் அல்லது route handler வரைய பிரதிபலிக்கும் முன் — இயங்கும் குறியீடு ஆகும். இது கோரிக்கைகளை ஆய்வு செய்ய மற்றும் மீண்டும் எழுத/வழிமாற்ற, தலைப்புகளை அமைக்க, அல்லது பல வழிகளுக்கான அங்கீகாரத்தை ஒரே இடத்தில் சரிபார்க்க உதவுகிறது.

## Middleware ஐ வரையறுத்தல்

```ts
// middleware.ts (at the project root)
import { NextRequest, NextResponse } from "next/server";

export function middleware(req: NextRequest) {
  const token = req.cookies.get("session")?.value;

// protect /dashboard — redirect unauthenticated users to login
  if (req.nextUrl.pathname.startsWith("/dashboard") && !token) {
    return NextResponse.redirect(new URL("/login", req.url));
  }
  return NextResponse.next(); // allow the request to proceed
}

// only run on these paths (performance — don't run on every asset)
export const config = { matcher: ["/dashboard/:path*", "/account/:path*"] };
```

## Middleware என்ன செய்ய முடியும்

```ts
NextResponse.redirect(url);          // send the user elsewhere (auth gates)
NextResponse.rewrite(url);           // serve different content, URL unchanged (A/B, i18n)
NextResponse.next();                  // continue, optionally with modified headers
// req.geo / req.cookies / req.headers — inspect location, auth, etc.
```

பொதுவான பயன்பாடுகள்: **அங்கீகார வாயில்**, **வழிமாற்றங்கள்** (மொழி/புவியியல்-அடிப்படை, www→apex), **A/B சோதனை** மீண்டும் எழுதுதலின் மூலம், **பாதுகாப்பு தலைப்புகள்** அமைத்தல் மற்றும் bot/feature கொடிகள்.

## முக்கிய கட்டுப்பாடுகள்

```text
⚠️ Runs on the EDGE runtime → no Node.js APIs (no fs, limited libraries)
⚠️ Must be FAST — it runs before every matched request; heavy work adds latency
⚠️ Can't access the database directly for complex auth — do lightweight checks
   (e.g. verify a JWT/cookie exists); do full auth in the page/handler
```

`matcher` கட்டமைப்பு முக்கியமானது: middleware ஐ தேவைப்படும் வழிகளுக்கு மட்டுமே வரம்பிக்க, இது நிலையான சম்பத்தங்களில் இயங்காது மற்றும் எல்லாவற்றையும் மெதுவாக்காது.

## இது ஏன் முக்கியமானது

Middleware என்பது குறுக்கு-வெட்டு கோரிக்கை தர்க்கத்தின் ஒரு ஆட்சேக்கம் — அங்கீகார வழிமாற்றங்கள், மொழி திசைவழங்கல், மீண்டும் எழுதுதல் மற்றும் தலைப்புகள் — பல வழிகளிலும் ஒரு குறியீடை மீண்டும் செய்யாமல் பயன்படுத்தப்படுகிறது।

தனது Edge கட்டுப்பாடுகள் (வேகம், Node APIs இல்லை, இலேசான சரிபார்ப்புகள் மட்டும்) மற்றும் `matcher` ஸ்கோபிங் பற்றி அறிந்திருப்பது, அதை வாயிலுக்கு மற்றும் திசைவழங்கல் சிக்கல்களுக்கு சரியாகப் பயன்படுத்த உதவுகிறது.