Hvilke livssyklus-hooks gir NestJS?

Question

Accepted Answer

NestJS gir **livssyklus-hooks** — metoder du implementerer for å kjøre kode på spesifikke tidspunkter i applikasjonen eller en providers livssyklus (initialisering og shutdown). De er essensielle for oppsett (koble til ressurser) og opprydding (lukke forbindelser på en kontrollert måte).

## De viktigste hookene

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

## Livssyklussekvensen

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

## Et vanlig brukstilfelle: en Prisma-service som kobler til/fra

```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 ressurser som trenger eksplisitt oppsett/nedmontering — koble til i `onModuleInit`, gi fra seg i `onModuleDestroy`.

## Aktivering av 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 kjøres bare hvis du kaller `enableShutdownHooks()` — lett å glemme, så opprydding skjer aldri.

## Hvorfor kontrollert shutdown er viktig

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

Livssyklus-hooks er viktige for korrekt ressursstyring i NestJS-applikasjoner — de gir de rette stedene for å utføre **initialisering** (åpne database-/Redis-forbindelser, laste inn data, registrere med tjenester) og, kritisk, **kontrollert opprydding** ved shutdown (lukke forbindelser, spyle buffere, fullføre pågående arbeid).

Å forstå dem er essensielt for driftssikkerhet: **initialiseringshookene** (`onModuleInit`, `onApplicationBootstrap`) sikrer at oppsett skjer på rett tidspunkt når avhengigheter er klare, og **shutdown-hookene** (`onModuleDestroy`, `onApplicationShutdown`) muliggjør **kontrollert shutdown** — som er vital i moderne distribusjon (containere/orkestratorer sender SIGTERM konstant under distribusjoner og skalering, og uten riktig opprydding lekker du forbindelser og mister aktive forespørsler, noe som bryter zero-downtime-distribusjoner).

Standardmønsteret med å koble til i `onModuleInit` og fra i `onModuleDestroy` (f.eks. for Prisma/database-tjenester) er hverdagskunnskap i NestJS, og å kjenne det subtile kravet om å kalle `enableShutdownHooks()` (ellers kjøres shutdown-hooks aldri stille) er en praktisk, lett-å-glemme detalj.

Å mestre livssyklus-hooks er en del av å bygge robuste, produksjonsklar NestJS-tjenester som håndterer ressurser og distribusjoner riktig.