NestJS inatoa caching module iliyojengwa ndani (@nestjs/cache-manager) yenye API iliyounganishwa inayofanya kazi katika stores mbalimbali — in-memory kwa chaguo-msingi, au Redis kwa distributed caching katika instances nyingi. Caching inaboresha performance kwa kiasi kikubwa kwa kuepuka kazi ghali zinazorudiwa.
({
: [
.({
: ,
: ,
: ,
}),
],
})
{}
@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 inafanya cache kiotomatiki kwa majibu ya GET endpoint (yakiwekwa key kwa URL) na inatoa matokeo yaliyowekwa cache kwenye maombi yanayorudiwa — njia rahisi zaidi ya kufanya cache kwa endpoints zenye usomaji mwingi.
@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;
}
}
Kuingiza CACHE_MANAGER kunatoa udhibiti kamili — mtindo wa get-or-fetch (angalia cache, rejea chanzo, hifadhi matokeo) kwa ajili ya kufanya cache operesheni mahususi za ghali.
CacheModule.registerAsync({
useFactory: async () => ({
store: await redisStore({ url: process.env.REDIS_URL }), // use Redis as the store
ttl: 60000,
}),
});
API ileile, ikiungwa mkono na Redis, inatoa cache iliyoshirikiwa katika instances zote za app — muhimu unapoendesha instances nyingi (in-memory cache haishirikiwi kati yao).
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 ni mojawapo ya uboreshaji wa performance wenye athari kubwa zaidi kwa programu za back-end, na caching module iliyojengwa ndani ya NestJS inaifanya kuwa safi na thabiti.
Kuielewa ni muhimu kwa sababu API zenye usomaji mwingi zinanufaika sana kutokana na caching ya operesheni za ghali (database queries, external API calls, computations) — zikipunguza kwa kiasi kikubwa latency na load.
NestJS inatoa auto-caching rahisi (CacheInterceptor kwa GET endpoints) na udhibiti wa manual wa kina (mtindo wa get-or-fetch wa CACHE_MANAGER kwa operesheni mahususi).
Muhimu zaidi, API iliyounganishwa inafanya kazi na stores tofauti, kwa hivyo code ileile inaweza kutumia in-memory caching (haraka, instance moja) au Redis (cache iliyoshirikiwa katika instances nyingi) — na kujua kwamba in-memory cache haishirikiwi unapo-scale horizontally (ikihitaji Redis kwa distributed caching) ni jambo muhimu la kiarchitectural.
Muhimu vivyo hivyo ni kuelewa ugumu mkuu wa caching — invalidation (kufuta au kusasisha cache wakati data inabadilika, kupitia TTL au ufutaji wa wazi, ili kuepuka kutoa data iliyopitwa na wakati) — kwa kuwa kukosea hili ni kushindwa kwa kawaida kwa caching.
Kujua jinsi na lini ya kutumia caching, kuchagua store sahihi kwa deployment, na kushughulikia invalidation kwa usahihi ni maarifa muhimu ya kiwango cha senior kwa kujenga NestJS services za haraka na zinazoweza ku-scale.