NestJS ఒక built-in caching module (@nestjs/cache-manager) ను అందిస్తుంది, ఇది unified API తో ఆ stores across పనిచేస్తుంది — default by in-memory, లేదా Redis distributed caching కోసం multiple instances across. Caching dramatic గా performance ని improve చేస్తుంది repeated expensive work ను avoid చేయడం ద్వారా.
({
: [
.({
: ,
: ,
: ,
}),
],
})
{}
@Controller("products")
@UseInterceptors(CacheInterceptor) // automatically caches GET responses
export class ProductsController {
@Get()
@CacheTTL(30000) // override TTL for this route
findAll() {
return this.productsService.findAll(); // result cached; subsequent GETs are instant
}
}
CacheInterceptor automatically cache చేస్తుంది GET endpoint responses (keyed by URL) ను మరియు serves చేస్తుంది cached results repeat requests పై — simplest way to cache read-heavy endpoints.
@Injectable()
export class ProductsService {
constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}
async getProduct(id: string) {
const cached = await this.cache.get(`product:${id}`); // check cache first
if (cached) return cached; // cache HIT
const product = await this.db.findProduct(id); // cache MISS — fetch
await this.cache.set(`product:${id}`, product, 3600000); // store (1h TTL)
return product;
}
}
CACHE_MANAGER injecting చేస్తే full control ఇస్తుంది — get-or-fetch pattern (check cache, fall back to source, store result) specific expensive operations ను caching కోసం.
CacheModule.registerAsync({
useFactory: async () => ({
store: await redisStore({ url: process.env.REDIS_URL }), // use Redis as the store
ttl: 60000,
}),
});
Same API, backed by Redis, ఇస్తుంది shared cache all app instances across — essential when running multiple instances (in-memory cache shared కాదు వాటి between).
async updateProduct(id: string, data) {
await this.db.update(id, data);
await this.cache.del(`product:${id}`); // INVALIDATE on change → avoid stale data
}
The biggest caching challenge: INVALIDATION. When data changes, the cache must be
cleared/updated, or users see stale data. Strategies: TTL (accept brief staleness),
explicit deletion on writes (cache.del), or cache tags.
Caching ఒకటి highest-impact performance optimizations back-end applications కోసం, మరియు NestJS యొక్క built-in caching module చేస్తుంది clean మరియు consistent.
వీలు చెందుకోవడం ముఖ్యమైనది because read-heavy APIs benefit చేస్తాయి enormously caching expensive operations నుండి (database queries, external API calls, computations) — dramatically reducing latency మరియు load.
NestJS అందిస్తుంది both simple auto-caching (CacheInterceptor GET endpoints కోసం) మరియు fine-grained manual control (CACHE_MANAGER get-or-fetch pattern specific operations కోసం).
Crucially, unified API works different stores తో, so same code use చేయగలదు in-memory caching (fast, single-instance) లేదా Redis (shared cache multiple instances across) — మరియు knowing that in-memory cache isn't shared when scaling horizontally (requiring Redis distributed caching కోసం) ఒక important architectural point.
Equally important ఉంది understanding caching యొక్క central difficulty — invalidation (clearing లేదా updating cache when data changes, via TTL లేదా explicit deletion, avoid serve చేయడానికి stale data) — since getting this wrong classic caching failure.
Knowing how మరియు when apply caching, choosing right store deployment కోసం, మరియు handling invalidation correctly valuable senior-level knowledge building fast, scalable NestJS services.