Kako optimizirati performanse NestJS-a?

Question

Accepted Answer

Optimiziranje performansi NestJS-a obuhvaća **izbor HTTP adaptera** (Express vs Fastify), efikasnost baze podataka, cachiranje i opće Node.js prakse. Kao što je uvijek slučaj: **profiliranje kako bi se pronašlo pravo usko grlo** — što je obično baza podataka ili I/O, ne NestJS sam.

## Prebacite se na Fastify za veći propusnost

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

Budući da je NestJS **agnostičan prema platformi**, možete zamijeniti Express sa **Fastify** — često otprilike 2x brži za HTTP propusnost — obično bez promjene koda vaše aplikacije. Jednostavna dobit za API-je s visokim propusnostima.

## Baza podataka je obično pravo usko grlo

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

## Cachiranje skupih operacija

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

Cachiranje (s Redis-om za više instanci) izbjegava ponavljanje skupog posla — jedno od optimizacija s najvećim utjecajem.

## Async/concurrency i offloading

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

Paralelizujte nezavisne I/O operacije s `Promise.all`, i prebacite CPU-intenzivne radnje na background redove/workere kako se ne bi blokirali Node-ov single-threaded event loop.

## Ostale tehnike

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

## Mjerite prvo

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

## Zašto je to važno

Optimizacija performansi je vrijedna za izgradnju skalabilnih NestJS servisa, a razumijevanje opcija je važno znanje na razini seniora — ali mora biti **vođeno mjerenjima** (profiliranje kako bi se pronašlo stvarno usko grlo, što je za većinu API-ja baza podataka ili I/O umjesto samog NestJS-a).

Nekoliko NestJS-specifičnih i općih tehnika je važno: **Fastify adapter** nudi jednostavnu, značajnu dobit za HTTP propusnost (otprilike 2x) zahvaljujući tome što je NestJS agnostičan prema platformi, obično bez promjena koda; **optimizacije baze podataka** (ispravka N+1 upita, indeksiranje, paginacija, pooling) donose najveće stvarne dobitke jer je baza podataka obično pravo usko grlo; **cachiranje** (u memoriji ili Redis) izbjegava ponavljanja skupog posla; **paraleliziranje** nezavisnih async operacija i **prebacivanje CPU-intenzivnog posla na redove** čini Node-ov single-threaded event loop responzivnim; i **horizontalno skaliranje** (sa stateless aplikacijom i Redis-backed zajedničkim stanjem) rukuje visokim opterećenjem.

Pознавање ovog toolkita — i posebno disciplina profiliranja prvo, ciljanja na pravo usko grlo (obično DB) i primjene pravilnog rješenja umjesto pogađanja ili preuranjene micro-optimizacije — je ono što vam omogućuje izgradnju brzih, skalabilnih NestJS aplikacija.

To odražava zrelu, sustavnu pristup performansama koja razlikuje seniorne razvojne inženjere i česta je, praktično važna tema za radove na produkcijskom back-end-u.