Pundi carane nambah caching ing NestJS?

Question

Accepted Answer

NestJS nyedhiyani **modul caching** tingkat bangunan (`@nestjs/cache-manager`) kanthi API terpadu sing bisa digunakake ing macem-macem store — in-memory kanthi bawaan, utawa **Redis** kanggo caching terdistribusi ing saindhenging instansi. Caching ngapus-apus njegreg kanthi ngindhari pakaryan larang-layak sing bola diulang.

## Nyetel modul cache

```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 endpoint kanthi interceptor

```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` kanthi otomatis nyimpan respons endpoint `GET` (dikunci kanthi URL) lan nyayani asil cache nalika pitakon diulang — cara paling gampang kanggo cache endpoint sing maca akeh.

## Caching manual kanthi CacheManager (kontrol luwih akeh)

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

Nyuntikake `CACHE_MANAGER` menehi kontrol penuh — pola oleh-utawa-mudhun (pariksa cache, mundur menyang sumber, simpen asil) kanggo caching operasi larang-layak tartamtu.

## Caching terdistribusi kanthi Redis (macem-macem instansi)

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

API sing sama, didukung dening **Redis**, menehi cache **bersama** ing saindhenging instansi app — penting nalika njalanake macem-macem instansi (cache in-memory ora disisir antarane)

## Bagean hard: invalidasi cache

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

## Kenapa penting

Caching minangka salah sawijining optimisasi ngurining pinunjul kanggo aplikasi back-end, lan modul caching tingkat bangunan NestJS nggawe iku resik lan konsisten.

Sawang-sawingan penting amarga API maca-akeh entuk manfaat gedhe saka caching operasi larang-layak (pitakon database, pitakon API eksternal, komputasi) — ngapus-apus latency lan beban kanthi drastis.

NestJS nawakake tembung auto-caching (CacheInterceptor kanggo endpoint GET) lan kontrol anut-anut (pola mudhun-oleh `CACHE_MANAGER` kanggo operasi tartamtu).

Kadospundi penting, API terpadu bisa digunakake ing sawijining store, dadi kode sing sama bisa nggunakake caching in-memory (cepet, instansi-tunggal) utawa **Redis** (cache bersama antarane macem-macem instansi) — lan ngerti manawa cache in-memory *ora disisir* nalika scaling horisontal (merlokake Redis kanggo caching terdistribusi) minangka poin arsitektur penting.

Sakehing penting uga ngerti kesulitan caching — **invalidasi** (resik utawa ganti cache nalika dhata berubah, liwat TTL utawa penghapusan eksplisit, kanggo ngindhari menehi dhata lawas) — amarga nggawe iku nang-endi minangka kegagalan caching klasik.

Ngerti pundi lan kapan ngetrapake caching, milih store kanan kanggo deployment, lan nangani invalidasi kanthi bener minangka ilmu tingkat senior-berharga kanggo mbangun layanan NestJS cepet lan scalable.