Vilka lifecycle hooks tillhandahåller NestJS?

Question

Accepted Answer

NestJS tillhandahåller **lifecycle hooks** — metoder du implementerar för att köra kod vid specifika tidpunkter i applikationens eller en providers livscykel (initialisering och nedstängning). De är essentiella för setup (ansluta till resurser) och rengöring (stänga anslutningar på ett elegant sätt).

## Huvudhooksen

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

## Livscykelsekvensen

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

## Ett vanligt användningsfall: en Prisma-tjänst som ansluter/kopplar från

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

Detta är standardmönstret för resurser som behöver explicit setup/teardown — anslut i `onModuleInit`, frigör i `onModuleDestroy`.

## Aktivera 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örs bara om du anropar `enableShutdownHooks()` — lätt att glömma, och då händer rengöringen aldrig.

## Varför elegant nedstängning är viktigt

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

## Varför det spelar roll

Lifecycle hooks är viktiga för att hantera resurser korrekt i NestJS-applikationer — de tillhandahåller rätt ställen för att utföra **initialisering** (öppna databas-/Redis-anslutningar, ladda data, registrera med tjänster) och, kritiskt, **elegant rengöring** vid nedstängning (stänga anslutningar, tömma buffrar, avsluta pågående arbete).

Att förstå dem är essentiellt för produktionspålitlighet: **initialiseringshooksen** (`onModuleInit`, `onApplicationBootstrap`) säkerställer att setup sker vid rätt tidpunkt när beroenden är klara, och **shutdown hooksen** (`onModuleDestroy`, `onApplicationShutdown`) möjliggör **elegant nedstängning** — vilket är vital i modern deployment (containrar/orkestrerare skickar SIGTERM konstant under deployer och skalning, och utan korrekt rengöring läcker du anslutningar och tappar aktiva förfrågningar, vilket bryter noll-stillestånd deployer).

Standardmönstret att ansluta i `onModuleInit` och koppla från i `onModuleDestroy` (t.ex. för Prisma/databastjänster) är vardagskunskap om NestJS, och att veta det subtila kravet att anropa `enableShutdownHooks()` (eller shutdown hooks körs tyst aldrig) är en praktisk, lätt-att-missa detalj.

Att bemästra lifecycle hooks är en del av att bygga robusta, produktionsberedskapade NestJS-tjänster som hanterar resurser och deployer korrekt.