Bagaimana anda mengoptimumkan prestasi NestJS?

Question

Accepted Answer

Mengoptimumkan prestasi NestJS merangkumi **pilihan adapter HTTP** (Express lwn Fastify), kecekapan pangkalan data, caching, dan amalan Node.js am. Seperti biasa: **buat profil untuk mencari bottleneck sebenar** — yang biasanya ialah pangkalan data atau I/O, bukan NestJS itu sendiri.

## Tukar ke Fastify untuk throughput lebih tinggi

```ts
// NestJS supports Fastify as an alternative to the default Express adapter
import { FastifyAdapter } from "@nestjs/platform-fastify";

const app = await NestFactory.create(AppModule, new FastifyAdapter());
// Fastify is significantly faster than Express (~2x in benchmarks) with the SAME NestJS code
```

Kerana NestJS bersifat **platform-agnostic**, anda boleh menukar Express dengan **Fastify** — selalunya kira-kira 2x lebih laju untuk throughput HTTP — biasanya tanpa mengubah kod aplikasi anda. Satu kemenangan mudah untuk API berthroughput tinggi.

## Pangkalan data biasanya bottleneck sebenar

```ts
// ❌ N+1 queries — fetching related data in a loop (the most common perf killer)
for (const user of users) {
  user.posts = await postsRepo.findByUser(user.id);   // 1 query per user!
}

// ✅ eager load / join / batch in ONE query
const users = await usersRepo.find({ relations: ["posts"] });
```

```text
Database optimizations (the biggest real wins for most APIs):
  ✓ Fix N+1 queries (use joins/relations/DataLoader)
  ✓ Add indexes for slow queries
  ✓ Select only needed columns; paginate large result sets
  ✓ Use connection pooling
```

## Caching operasi mahal

```ts
@UseInterceptors(CacheInterceptor)   // cache read-heavy endpoints (in-memory or Redis)
// or manual caching of expensive queries/computations
```

Caching (dengan Redis untuk berbilang instance) mengelakkan pengulangan kerja mahal — salah satu pengoptimuman berkesan tertinggi.

## Async/concurrency dan pemunggahan

```ts
// parallelize independent async operations
const [users, products] = await Promise.all([getUsers(), getProducts()]);

// offload heavy CPU work to a queue/worker (don't block the event loop)
await this.queue.add("process-image", data);
```

Lakukan I/O bebas secara selari dengan `Promise.all`, dan munggahkan kerja berat CPU ke queue/worker latar belakang supaya ia tidak menyekat event loop berbenang tunggal Node.

## Teknik lain

```text
✓ Enable compression (gzip/brotli) for responses
✓ Use streaming for large payloads/files
✓ Scale horizontally (multiple instances + load balancer; cluster/PM2)
  — keep the app STATELESS (sessions/cache in Redis, not process memory)
✓ Lazy-load modules where appropriate; minimize startup work
✓ Profile with clinic.js / node --prof to find actual hotspots
```

## Ukur dahulu

```text
Don't guess. Profile (clinic.js, autocannon for load testing) to find the REAL
bottleneck — for most APIs it's the database or external I/O, not Nest/Node code.
```

## Mengapa ia penting

Pengoptimuman prestasi adalah berharga untuk membina servis NestJS yang boleh diskalakan, dan memahami pilihan yang ada ialah pengetahuan peringkat senior yang penting — tetapi ia mesti **dipacu pengukuran** (profiling untuk mencari bottleneck sebenar, yang bagi kebanyakan API ialah pangkalan data atau I/O dan bukannya NestJS itu sendiri).

Beberapa teknik khusus NestJS dan am adalah penting: **adapter Fastify** menawarkan kemenangan throughput HTTP yang mudah dan ketara (kira-kira 2x) berkat NestJS yang platform-agnostic, biasanya tanpa perubahan kod; **pengoptimuman pangkalan data** (membaiki pertanyaan N+1, indexing, pagination, pooling) memberikan keuntungan dunia nyata terbesar kerana pangkalan data biasanya bottleneck sebenar; **caching** (dalam memori atau Redis) mengelakkan kerja mahal yang berulang; melakukan operasi async bebas **secara selari** dan **memunggah kerja berat CPU ke queue** memastikan event loop berbenang tunggal Node kekal responsif; dan **penskalaan mendatar** (dengan aplikasi stateless dan keadaan dikongsi yang disokong Redis) mengendalikan beban tinggi.

Mengetahui toolkit ini — dan terutamanya disiplin untuk membuat profil dahulu, menyasarkan bottleneck sebenar (biasanya DB), dan menerapkan pembaikan yang tepat dan bukannya meneka atau melakukan mikro-pengoptimuman secara pramatang — itulah yang membolehkan anda membina aplikasi NestJS yang laju dan boleh diskalakan.

Ia mencerminkan pendekatan matang dan sistematik terhadap prestasi yang membezakan pembangun senior dan merupakan topik biasa yang penting secara praktikal untuk kerja back-end produksi.