Hvordan legger du til caching i NestJS?

Question

Accepted Answer

NestJS tilbyr en innebygd **caching-modul** (`@nestjs/cache-manager`) med et enhetlig API som fungerer på tvers av ulike lagre — in-memory som standard, eller **Redis** for distribuert caching på tvers av flere instanser. Caching forbedrer ytelsen dramatisk ved å unngå gjentatt kostbart arbeid.

## Oppsett av cache-modulen

```ts
@Module({
  imports: [
    CacheModule.register({
      ttl: 60000,        // default time-to-live (ms) — entries expire after 60s
      max: 100,          // max items in memory (in-memory store)
      isGlobal: true,    // available app-wide
    }),
  ],
})
export class AppModule {}
```

## Auto-caching av endepunkter med interceptoren

```ts
@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` cacher automatisk svar fra `GET`-endepunkter (nøkkelet er URL-en) og serverer cachede resultater på gjentatte forespørsler — den enkleste måten å cache lesekrevende endepunkter på.

## Manuell caching med CacheManager (mer kontroll)

```ts
@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;
  }
}
```

Injeksjon av `CACHE_MANAGER` gir full kontroll — get-or-fetch-mønsteret (sjekk cache, gå tilbake til kilde, lagre resultat) for caching av spesifikke kostbare operasjoner.

## Distribuert caching med Redis (flere instanser)

```ts
CacheModule.registerAsync({
  useFactory: async () => ({
    store: await redisStore({ url: process.env.REDIS_URL }),   // use Redis as the store
    ttl: 60000,
  }),
});
```

Same API, støttet av **Redis**, gir et **delt** cache på tvers av alle app-instanser — essensielt når du kjører flere instanser (et in-memory cache blir ikke delt mellom dem).

## Den vanskelige delen: cache-invalidering

```ts
async updateProduct(id: string, data) {
  await this.db.update(id, data);
  await this.cache.del(`product:${id}`);   // INVALIDATE on change → avoid stale data
}
```

```text
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.
```

## Hvorfor det betyr noe

Caching er en av de høyeste-virkning ytelsesoptimaliseringene for back-end-applikasjoner, og NestJS's innebygde caching-modul gjør det rent og konsistent.

Det er viktig å forstå fordi lesekrevende API-er drar enormt fordel av caching av kostbare operasjoner (databasespørringer, eksterne API-kall, beregninger) — noe som dramatisk reduserer latens og belastning.

NestJS tilbyr både enkel auto-caching (`CacheInterceptor` for GET-endepunkter) og finkornet manuell kontroll (`CACHE_MANAGER` get-or-fetch-mønsteret for spesifikke operasjoner).

Krucielt er at det enhetlige API-et fungerer med ulike lagre, så samme kode kan bruke **in-memory caching** (raskt, enkelt-instans) eller **Redis** (et delt cache på tvers av flere instanser) — og vite at et in-memory cache *ikke deles* ved horisontalskalering (som krever Redis for distribuert caching) er et viktig arkitekturpoeng.

Like viktig er det å forstå cachings sentrale vanskelighet — **invalidering** (sletting eller oppdatering av cache når data endrer seg, via TTL eller eksplisitt sletting, for å unngå å servere foreldet data) — siden å få dette galt er den klassiske cache-feilen.

Å vite hvordan og når man skal bruke caching, velge riktig lager for implementeringen, og håndtere invalidering korrekt er verdifull senior-nivå-kunnskap for å bygge raske, skalerbare NestJS-tjenester.