Milyen lifecycle hook-okat biztosít a NestJS?

Question

Accepted Answer

A NestJS **lifecycle hook-okat** biztosít — olyan metódusokat, amelyeket implementálsz az alkalmazás vagy egy provider életciklusa során a kódot specifikus pillanatokban futtatni (inicializáció és leállítás). Ezek lényegesek a setup-hoz (erőforrásokhoz való csatlakozás) és a cleanup-hoz (kapcsolatok kecses leállítása).

## A fő hook-ok

```ts
@Injectable()
export class DatabaseService
  implements OnModuleInit, OnApplicationShutdown {

async onModuleInit() {
    // runs once the host MODULE's dependencies are resolved → do INITIALIZATION
    await this.connect();         // e.g. open a database connection
  }

async onApplicationShutdown(signal: string) {
    // runs when the app is shutting down → do CLEANUP
    await this.disconnect();      // close connections, flush, release resources
  }
}
```

## Az életciklus szekvenciája

```text
INITIALIZATION (startup):
  onModuleInit()          → after the module's providers are initialized
  onApplicationBootstrap()→ after ALL modules are initialized (whole app ready)

SHUTDOWN (graceful termination):
  onModuleDestroy()         → cleanup as modules are destroyed
  beforeApplicationShutdown() → before shutdown completes
  onApplicationShutdown(signal) → final shutdown (signal = SIGTERM, etc.)
```

## Egy gyakori felhasználás: egy Prisma service csatlakozás/lecsatlakozás

```ts
@Injectable()
export class PrismaService extends PrismaClient
  implements OnModuleInit, OnModuleDestroy {

async onModuleInit() {
    await this.$connect();        // connect on startup
  }
  async onModuleDestroy() {
    await this.$disconnect();      // disconnect on shutdown — clean release
  }
}
```

Ez a standard minta azoknak az erőforrásoknak, amelyeknek explicit setup/teardown szükséges — csatlakozás az `onModuleInit`-ben, felszabadítás az `onModuleDestroy`-ban.

## Shutdown hook-ok engedélyezése

```ts
// shutdown hooks must be enabled explicitly
const app = await NestFactory.create(AppModule);
app.enableShutdownHooks();        // ❗ required for onApplicationShutdown etc. to fire
```

A shutdown hook-ok csak akkor futnak, ha meghívod az `enableShutdownHooks()` függvényt — könnyen elfelejtehető, majd a cleanup soha nem történik meg.

## Miért fontos a kecses leállítás

```text
When the app receives SIGTERM (deploy, scale-down, container stop):
  ✗ Without shutdown hooks → connections left open, in-flight work dropped
  ✓ With shutdown hooks → close DB/Redis/queues cleanly, finish work → zero-downtime
```

## Miért fontos

A lifecycle hook-ok fontosak az erőforrások helyes kezeléséhez a NestJS alkalmazásokban — ezek biztosítják a megfelelő helyeket az **inicializáció** (adatbázis/Redis kapcsolatok megnyitása, adatok betöltése, szolgáltatásokkal való regisztráció) elvégzéséhez és kritikusan, a **kecses cleanup** leállítás során (kapcsolatok bezárása, bufferek kiürítése, a repülés közben lévő munka befejezése).

Az értésük lényeges a production megbízhatóságához: az **inicializáció hook-ok** (`onModuleInit`, `onApplicationBootstrap`) biztosítják, hogy a setup a megfelelő időben történjen meg, miután a függőségek készen vannak, és a **shutdown hook-ok** (`onModuleDestroy`, `onApplicationShutdown`) lehetővé teszik a **kecses leállítást** — amely kritikus a modern deployment-ben (konténerek/orchestrátorok folyamatosan SIGTERM-et küldenek az üzembe helyezés és skálázás során, és megfelelő cleanup nélkül szivárog a kapcsolatok és elveszik az aktív kérések, megsemmisítve a zero-downtime deploymenteket).

A standard minta az `onModuleInit`-ben való csatlakozás és az `onModuleDestroy`-ban való lecsatlakozás (pl. Prisma/adatbázis szolgáltatások esetén) a mindennapi NestJS ismeretei közé tartozik, és az a finom követelmény, hogy az `enableShutdownHooks()` hívását meghívod (vagy a shutdown hook-ok csendesen soha nem futnak) egy praktikus, könnyen elfelejthető részlet.

A lifecycle hook-ok elsajátítása a robusztus, production-ready NestJS szolgáltatások építésének része, amely az erőforrások és deploymentek helyes kezelésében történik.