Quali lifecycle hooks fornisce NestJS?

Question

Accepted Answer

NestJS fornisce **lifecycle hooks** — metodi che implementi per eseguire codice in momenti specifici del ciclo di vita dell'applicazione o di un provider (inizializzazione e arresto). Sono essenziali per la configurazione (connessione alle risorse) e la pulizia (chiusura delle connessioni in modo elegante).

## Gli hook principali

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

## La sequenza del ciclo di vita

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

## Un caso comune: un servizio Prisma che si connette/disconnette

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

Questo è il pattern standard per le risorse che richiedono una configurazione/pulizia esplicita — connettiti in `onModuleInit`, rilascia in `onModuleDestroy`.

## Abilitare gli shutdown hook

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

Gli shutdown hook vengono eseguiti solo se chiami `enableShutdownHooks()` — facile da dimenticare, quindi la pulizia potrebbe non accadere mai.

## Perché l'arresto elegante è importante

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

## Perché è importante

I lifecycle hook sono importanti per gestire correttamente le risorse nelle applicazioni NestJS — forniscono i posti appropriati per eseguire **l'inizializzazione** (apertura di connessioni a database/Redis, caricamento di dati, registrazione presso servizi) e, criticamente, **pulizia elegante** all'arresto (chiusura delle connessioni, svuotamento dei buffer, completamento del lavoro in sospeso).

Comprenderli è essenziale per l'affidabilità in produzione: gli **hook di inizializzazione** (`onModuleInit`, `onApplicationBootstrap`) assicurano che la configurazione avvenga al momento giusto una volta che le dipendenze sono pronte, e gli **shutdown hook** (`onModuleDestroy`, `onApplicationShutdown`) abilitano l'**arresto elegante** — vitale nei deployment moderni (container/orchestrator inviano costantemente SIGTERM durante i deploy e lo scaling, e senza una pulizia adeguata perdi le connessioni e abbandoni le richieste attive, infrangendo i deployment a zero downtime).

Il pattern standard di connessione in `onModuleInit` e disconnessione in `onModuleDestroy` (ad es. per servizi Prisma/database) è conoscenza quotidiana di NestJS, e sapere il requisito sottile di chiamare `enableShutdownHooks()` (oppure gli shutdown hook non si attiveranno silenziosamente) è un dettaglio pratico, facile da trascurare.

Padroneggiare i lifecycle hook è parte della costruzione di servizi NestJS robusti e pronti per la produzione che gestiscono correttamente le risorse e i deployment.