Welke lifecycle hooks biedt NestJS?

Question

Accepted Answer

NestJS biedt **lifecycle hooks** — methoden die je implementeert om code uit te voeren op specifieke momenten in de levenscyclus van de applicatie of een provider (initialisatie en sluiting). Ze zijn essentieel voor setup (verbinden met resources) en opschoning (verbindingen netjes sluiten).

## De belangrijkste hooks

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

## De lifecycle-volgorde

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

## Een veel voorkomend voorbeeld: een Prisma-service die verbinding maakt/verbreekt

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

Dit is het standaardpatroon voor resources die expliciete setup/teardown nodig hebben — verbind in `onModuleInit`, geef vrij in `onModuleDestroy`.

## Shutdown hooks inschakelen

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

De shutdown hooks worden alleen uitgevoerd als je `enableShutdownHooks()` aanroept — makkelijk te vergeten, dan vindt opschoning nooit plaats.

## Waarom graceful shutdown belangrijk is

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

## Waarom het belangrijk is

Lifecycle hooks zijn belangrijk voor het correct beheren van resources in NestJS-applicaties — ze bieden de juiste plaatsen om **initialisatie** uit te voeren (database/Redis-verbindingen openen, gegevens laden, registreren bij services) en, kritiek, **graceful cleanup** bij sluiting (verbindingen sluiten, buffers leegmaken, in-flight werk afmaken).
");Het begrijpen ervan is essentieel voor productiebetrouwbaarheid: de **initialisatie hooks** (`onModuleInit`, `onApplicationBootstrap`) zorgen ervoor dat setup op het juiste moment plaatsvindt zodra afhankelijkheden klaar zijn, en de **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) maken **graceful shutdown** mogelijk — wat vitaal is in moderne deployment (containers/orchestrators sturen constant SIGTERM tijdens deploys en schaling, en zonder proper cleanup verlies je verbindingen en vallen actieve requests weg, wat zero-downtime deployments breekt).

Het standaardpatroon van verbinden in `onModuleInit` en verbreken in `onModuleDestroy` (bijv. voor Prisma/database-services) is alledaagse NestJS-kennis, en het weten van de subtiele vereiste om `enableShutdownHooks()` aan te roepen (of shutdown hooks werken stilzwijgend nooit) is een praktisch, makkelijk te missen detail.

Het beheersen van lifecycle hooks is onderdeel van het bouwen van robuuste, productie-klare NestJS-services die resources en deployments correct afhandelen.