1---
2title: Use Caching Strategically
3impact: HIGH
4impactDescription: Dramatically reduces database load and response times
5tags: performance, caching, redis, optimization
6---
7 
8## Use Caching Strategically
9 
10Implement caching for expensive operations, frequently accessed data, and external API calls. Use NestJS CacheModule with appropriate TTLs and cache invalidation strategies. Don't cache everything - focus on high-impact areas.
11 
12**Incorrect (no caching or caching everything):**
13 
14```typescript
15// No caching for expensive, repeated queries
16@Injectable()
17export class ProductsService {
18  async getPopular(): Promise<Product[]> {
19    // Runs complex aggregation query EVERY request
20    return this.productsRepo
21      .createQueryBuilder('p')
22      .leftJoin('p.orders', 'o')
23      .select('p.*, COUNT(o.id) as orderCount')
24      .groupBy('p.id')
25      .orderBy('orderCount', 'DESC')
26      .limit(20)
27      .getMany();
28  }
29}
30 
31// Cache everything without thought
32@Injectable()
33export class UsersService {
34  @CacheKey('users')
35  @CacheTTL(3600)
36  @UseInterceptors(CacheInterceptor)
37  async findAll(): Promise<User[]> {
38    // Caching user list for 1 hour is wrong if data changes frequently
39    return this.usersRepo.find();
40  }
41}
42```
43 
44**Correct (strategic caching with proper invalidation):**
45 
46```typescript
47// Setup caching module
48@Module({
49  imports: [
50    CacheModule.registerAsync({
51      imports: [ConfigModule],
52      inject: [ConfigService],
53      useFactory: (config: ConfigService) => ({
54        stores: [
55          new KeyvRedis(config.get('REDIS_URL')),
56        ],
57        ttl: 60 * 1000, // Default 60s
58      }),
59    }),
60  ],
61})
62export class AppModule {}
63 
64// Manual caching for granular control
65@Injectable()
66export class ProductsService {
67  constructor(
68    @Inject(CACHE_MANAGER) private cache: Cache,
69    private productsRepo: ProductRepository,
70  ) {}
71 
72  async getPopular(): Promise<Product[]> {
73    const cacheKey = 'products:popular';
74 
75    // Try cache first
76    const cached = await this.cache.get<Product[]>(cacheKey);
77    if (cached) return cached;
78 
79    // Cache miss - fetch and cache
80    const products = await this.fetchPopularProducts();
81    await this.cache.set(cacheKey, products, 5 * 60 * 1000); // 5 min TTL
82    return products;
83  }
84 
85  // Invalidate cache on changes
86  async updateProduct(id: string, dto: UpdateProductDto): Promise<Product> {
87    const product = await this.productsRepo.save({ id, ...dto });
88    await this.cache.del('products:popular'); // Invalidate
89    return product;
90  }
91}
92 
93// Decorator-based caching with auto-interceptor
94@Controller('categories')
95@UseInterceptors(CacheInterceptor)
96export class CategoriesController {
97  @Get()
98  @CacheTTL(30 * 60 * 1000) // 30 minutes - categories rarely change
99  findAll(): Promise<Category[]> {
100    return this.categoriesService.findAll();
101  }
102 
103  @Get(':id')
104  @CacheTTL(60 * 1000) // 1 minute
105  @CacheKey('category')
106  findOne(@Param('id') id: string): Promise<Category> {
107    return this.categoriesService.findOne(id);
108  }
109}
110 
111// Event-based cache invalidation
112@Injectable()
113export class CacheInvalidationService {
114  constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}
115 
116  @OnEvent('product.created')
117  @OnEvent('product.updated')
118  @OnEvent('product.deleted')
119  async invalidateProductCaches(event: ProductEvent) {
120    await Promise.all([
121      this.cache.del('products:popular'),
122      this.cache.del(`product:${event.productId}`),
123    ]);
124  }
125}
126```
127 
128Reference: [NestJS Caching](https://docs.nestjs.com/techniques/caching)
129