1---
2title: Use Interceptors for Cross-Cutting Concerns
3impact: MEDIUM-HIGH
4impactDescription: Interceptors provide clean separation for cross-cutting logic
5tags: api, interceptors, logging, caching
6---
7 
8## Use Interceptors for Cross-Cutting Concerns
9 
10Interceptors can transform responses, add logging, handle caching, and measure performance without polluting your business logic. They wrap the route handler execution, giving you access to both the request and response streams.
11 
12**Incorrect (logging and transformation in every method):**
13 
14```typescript
15// Logging in every controller method
16@Controller('users')
17export class UsersController {
18  @Get()
19  async findAll(): Promise<User[]> {
20    const start = Date.now();
21    this.logger.log('findAll called');
22 
23    const users = await this.usersService.findAll();
24 
25    this.logger.log(`findAll completed in ${Date.now() - start}ms`);
26    return users;
27  }
28 
29  @Get(':id')
30  async findOne(@Param('id') id: string): Promise<User> {
31    const start = Date.now();
32    this.logger.log(`findOne called with id: ${id}`);
33 
34    const user = await this.usersService.findOne(id);
35 
36    this.logger.log(`findOne completed in ${Date.now() - start}ms`);
37    return user;
38  }
39  // Repeated in every method!
40}
41 
42// Manual response wrapping
43@Get()
44async findAll(): Promise<{ data: User[]; meta: Meta }> {
45  const users = await this.usersService.findAll();
46  return {
47    data: users,
48    meta: { timestamp: new Date(), count: users.length },
49  };
50}
51```
52 
53**Correct (use interceptors for cross-cutting concerns):**
54 
55```typescript
56// Logging interceptor
57@Injectable()
58export class LoggingInterceptor implements NestInterceptor {
59  private readonly logger = new Logger('HTTP');
60 
61  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
62    const request = context.switchToHttp().getRequest();
63    const { method, url, body } = request;
64    const now = Date.now();
65 
66    return next.handle().pipe(
67      tap({
68        next: (data) => {
69          const response = context.switchToHttp().getResponse();
70          this.logger.log(
71            `${method} ${url} ${response.statusCode} - ${Date.now() - now}ms`,
72          );
73        },
74        error: (error) => {
75          this.logger.error(
76            `${method} ${url} ${error.status || 500} - ${Date.now() - now}ms`,
77            error.stack,
78          );
79        },
80      }),
81    );
82  }
83}
84 
85// Response transformation interceptor
86@Injectable()
87export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
88  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
89    return next.handle().pipe(
90      map((data) => ({
91        data,
92        meta: {
93          timestamp: new Date().toISOString(),
94          path: context.switchToHttp().getRequest().url,
95        },
96      })),
97    );
98  }
99}
100 
101// Timeout interceptor
102@Injectable()
103export class TimeoutInterceptor implements NestInterceptor {
104  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
105    return next.handle().pipe(
106      timeout(5000),
107      catchError((err) => {
108        if (err instanceof TimeoutError) {
109          throw new RequestTimeoutException('Request timed out');
110        }
111        throw err;
112      }),
113    );
114  }
115}
116 
117// Apply globally or per-controller
118@Module({
119  providers: [
120    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
121    { provide: APP_INTERCEPTOR, useClass: TransformInterceptor },
122  ],
123})
124export class AppModule {}
125 
126// Or per-controller
127@Controller('users')
128@UseInterceptors(LoggingInterceptor)
129export class UsersController {
130  @Get()
131  async findAll(): Promise<User[]> {
132    // Clean business logic only
133    return this.usersService.findAll();
134  }
135}
136 
137// Custom cache interceptor with TTL
138@Injectable()
139export class HttpCacheInterceptor implements NestInterceptor {
140  constructor(
141    private cacheManager: Cache,
142    private reflector: Reflector,
143  ) {}
144 
145  async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
146    const request = context.switchToHttp().getRequest();
147 
148    // Only cache GET requests
149    if (request.method !== 'GET') {
150      return next.handle();
151    }
152 
153    const cacheKey = this.generateKey(request);
154    const ttl = this.reflector.get<number>('cacheTTL', context.getHandler()) || 300;
155 
156    const cached = await this.cacheManager.get(cacheKey);
157    if (cached) {
158      return of(cached);
159    }
160 
161    return next.handle().pipe(
162      tap((response) => {
163        this.cacheManager.set(cacheKey, response, ttl);
164      }),
165    );
166  }
167 
168  private generateKey(request: Request): string {
169    return `cache:${request.url}:${JSON.stringify(request.query)}`;
170  }
171}
172 
173// Usage with custom TTL
174@Get()
175@SetMetadata('cacheTTL', 600)
176@UseInterceptors(HttpCacheInterceptor)
177async findAll(): Promise<User[]> {
178  return this.usersService.findAll();
179}
180 
181// Error mapping interceptor
182@Injectable()
183export class ErrorMappingInterceptor implements NestInterceptor {
184  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
185    return next.handle().pipe(
186      catchError((error) => {
187        if (error instanceof EntityNotFoundError) {
188          throw new NotFoundException(error.message);
189        }
190        if (error instanceof QueryFailedError) {
191          if (error.message.includes('duplicate')) {
192            throw new ConflictException('Resource already exists');
193          }
194        }
195        throw error;
196      }),
197    );
198  }
199}
200```
201 
202Reference: [NestJS Interceptors](https://docs.nestjs.com/interceptors)
203