Middleware એક ફંક્શન છે જે રુટ હેન્ડલર પહેલાં ચાલે છે, request અને response ઑબ્જેક્ટ્સ તરફ પ્રવેશાધિકાર સાથે — Express middleware જેવો જ ખ્યાલ. NestJS પાસે guards, interceptors, pipes અને filters પણ છે, પ્રત્યેક request lifecycle માં ચોક્કસ બિંદુએ અલગ હેતુ સાથે ચાલે છે. કયો ઉપયોગ કરવો તે જાણવું મહત્વપૂર્ણ છે.
()
{
() {
.();
();
}
}
{
() {
consumer.().();
}
}
Middleware સૌથી પહેલાં ચાલે છે, guards/interceptors/pipes પહેલાં, અને raw req/res સાથે કામ કરે છે — logging, request modification, CORS અને Express-compatible concerns માટે સારું.
Request →
1. Middleware (req/res; runs first, Express-style)
2. Guards (return true/false → AUTHORIZE or block the request)
3. Interceptors (BEFORE the handler)
4. Pipes (validate/transform the handler's arguments)
5. → Route Handler ←
6. Interceptors (AFTER the handler — transform the response)
7. Exception Filters (if an error was thrown anywhere)
→ Response
Middleware → general pre-processing with req/res (logging, CORS, raw request work)
Guards → AUTHORIZATION — decide if a request may proceed (auth, roles)
(return true = allow, false/throw = block)
Interceptors→ wrap the handler — transform request/response, add logging/caching/timing
(can run logic BEFORE and AFTER the handler)
Pipes → VALIDATE/TRANSFORM the handler's input arguments (DTO validation)
Filters → catch and format EXCEPTIONS into responses
મુખ્ય તફાવતો: middleware એક સામાન્ય Express-style પ્રી-પ્રોસેસિંગ છે; guards વિશેષરૂપે authorization સંભાળે છે (auth માટે એક સ્વચ્છ, dedicated જગ્યા, તેને middleware માં મૂકતા વિપરીત); interceptors handler ને wrap કરે છે responses રૂપાંતરિત કરવા અથવા cross-cutting behavior ઉમેરવા માટે; pipes input validate કરે છે; filters errors સંભાળે છે.
Auth check? → Guard (dedicated, has execution context, returns boolean)
Logging requests? → Middleware OR an interceptor (interceptor sees the response too)
Transform responses? → Interceptor (runs after the handler)
Validate a DTO? → Pipe
Modify raw req early? → Middleware
Middleware સમજવું અને તે guards, interceptors, pipes અને filters થી કેવી રીતે અલગ છે તે NestJS applications ને યોગ્ય રીતે structure કરવા માટે આવશ્યક છે — પ્રત્યેકનો ચોક્કસ ભૂમિકા અને request lifecycle માં ચોક્કસ બિંદુ છે, અને યોગ્ય એક ઉપયોગ કરવું clean, idiomatic code તરફ દોરી જાય છે.
Middleware raw req/res સાથે સામાન્ય Express-style પ્રી-પ્રોસેસિંગ સંભાળે છે.
નિર્ણાયક તફાવતો એ છે કે guards authorization (auth/roles) માટે dedicated, યોગ્ય જગ્યા છે — તે હેતુ માટે middleware કરતા ગણતરીશીલ રીતે સ્વચ્છ છે — અને interceptors handler ને wrap કરે છે responses રૂપાંતરિત કરવા અને cross-cutting concerns ઉમેરવા માટે (logging, caching, timing) જે middleware સહજતાથી કરી શકતું નથી (કારણ કે તે handler પહેલાં ચાલે છે અને naturally response નથી જોતું).
સંપૂર્ણ lifecycle order જાણવું (middleware → guards → interceptors → pipes → handler → interceptors → filters) અને કયું tool દરેક concern માટે બંધબેસે છે (auth → guard, response transformation → interceptor, validation → pipe, errors → filter) તે NestJS competence નું નિશાન છે અને middleware ને બધા વસ્તુ માટે ગलત ઉપયોગ કરવાની સામાન્ય ભૂલ રોકે છે.
તે framework માં વારંવાર-tested, architecturally-important topic છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો