Jakie hooki cyklu życia udostępnia NestJS?

Question

Accepted Answer

NestJS udostępnia **hooki cyklu życia** — metody, które implementujesz, aby uruchomić kod w określonych momentach cyklu życia aplikacji lub providera (inicjalizacja i zamykanie). Są niezbędne do setup (łączenia się z zasobami) i czyszczenia (zamykania połączeń w kontrolowany sposób).

## Główne hooki

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

## Sekwencja cyklu życia

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

## Typowe zastosowanie: serwis Prisma nawiązujący/zamykający połączenie

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

To standardowy wzór dla zasobów, które wymagają jawnego setup/teardown — nawiąż w `onModuleInit`, zwolnij w `onModuleDestroy`.

## Włączanie hooków zamykania

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

Hooki zamykania uruchamiają się tylko wtedy, gdy wywołasz `enableShutdownHooks()` — łatwo zapomnieć, a wtedy czyszczenie nigdy się nie dzieje.

## Dlaczego kontrolowane zamykanie jest ważne

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

## Dlaczego to ważne

Hooki cyklu życia są ważne dla prawidłowego zarządzania zasobami w aplikacjach NestJS — zapewniają odpowiednie miejsca do wykonania **inicjalizacji** (otwierania połączeń bazy danych/Redis, ładowania danych, rejestracji w usługach) i, co krytyczne, **kontrolowanego czyszczenia** przy zamykaniu (zamykania połączeń, opróżniania buforów, kończenia trwających operacji).

Rozumienie ich jest niezbędne dla niezawodności w produkcji: **hooki inicjalizacji** (`onModuleInit`, `onApplicationBootstrap`) zapewniają, że setup odbywa się we właściwym czasie, gdy zależności są gotowe, a **hooki zamykania** (`onModuleDestroy`, `onApplicationShutdown`) umożliwiają **kontrolowane zamykanie** — co jest kluczowe we współczesnym deploymencie (kontenery/orkiestry stale wysyłają SIGTERM podczas deployów i skalowania, a bez właściwego czyszczenia wyciékają połączenia i tracą się aktywne requesty, niszcząc deploymenty bez przestojów).

Standardowy wzór nawiązywania w `onModuleInit` i odpłączania w `onModuleDestroy` (np. dla serwisów Prisma/bazy danych) to codzienną wiedzę NestJS, a znanie subtelnego wymagania wywołania `enableShutdownHooks()` (bo inaczej hooki zamykania cicho się nigdy nie uruchamiają) to praktyczna, łatwa do przeooczenia szczegół.

Opanowanie hooków cyklu życia jest częścią budowania solidnych, gotowych do produkcji serwisów NestJS, które prawidłowo zarządzają zasobami i deploymentami.