Hvilke lifecycle hooks udbyder NestJS?

Question

Accepted Answer

NestJS udbyder **lifecycle hooks** — metoder, du implementerer for at køre kode på specifikke tidspunkter i applikationens eller en providers livscyklus (initialisering og nedlukning). De er essentielle for setup (forbindelse til ressourcer) og cleanup (lukke forbindelser på elegant måde).

## Hovednokene

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

## Livscyklussekvensen

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

## En almindelig brug: en Prisma-tjeneste, der forbinder/afbryder

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

Dette er standardmønsteret for ressourcer, der har brug for eksplicit setup/teardown — forbind i `onModuleInit`, frigør i `onModuleDestroy`.

## Aktivering af shutdown hooks

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

Shutdown hooks køres kun, hvis du kalder `enableShutdownHooks()` — let at glemme, så cleanup sker aldrig.

## Hvorfor elegant nedlukning betyder noget

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

## Hvorfor det betyder noget

Lifecycle hooks er vigtige for at administrere ressourcer korrekt i NestJS-applikationer — de giver de rigtige steder til at udføre **initialisering** (åbne database-/Redis-forbindelser, indlæse data, registrere med tjenester) og, vigtigt nok, **elegant cleanup** ved nedlukning (lukke forbindelser, tømme buffere, afslutte igangværende arbejde).

At forstå dem er essentielt for produktionspålidelighed: **initialiseringshooks** (`onModuleInit`, `onApplicationBootstrap`) sikrer, at setup sker på det rigtige tidspunkt, når afhængigheder er klar, og **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) muliggør **elegant nedlukning** — hvilket er vital i moderne deployment (containere/orkestratorer sender konstant SIGTERM under deployments og scaling, og uden ordentlig cleanup lækker du forbindelser og mister aktive requests, hvilket ødelægger zero-downtime deployments).

Standardmønsteret med at forbinde i `onModuleInit` og afbryde i `onModuleDestroy` (f.eks. til Prisma-/databasetjenester) er dagligdags NestJS-viden, og at kende det subtile krav om at kalde `enableShutdownHooks()` (eller shutdown hooks udsender stille aldrig) er en praktisk, let-at-overse detalje.

At mestre lifecycle hooks er en del af at bygge robuste, produktionsklar NestJS-tjenester, der håndterer ressourcer og deployments korrekt.