Quels crochets de cycle de vie NestJS fournit-il ?

Question

Accepted Answer

NestJS fournit des **crochets de cycle de vie** — des méthodes que vous implémentez pour exécuter du code à des moments spécifiques du cycle de vie de l'application ou d'un fournisseur (initialisation et arrêt). Ils sont essentiels pour la configuration (connexion aux ressources) et le nettoyage (fermeture gracieuse des connexions).

## Les crochets principaux

```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 séquence du cycle de vie

```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 cas d'usage courant : un service Prisma se connectant/déconnectant

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

C'est le modèle standard pour les ressources qui nécessitent une configuration/démontage explicite — connectez-vous dans `onModuleInit`, libérez dans `onModuleDestroy`.

## Activation des crochets d'arrêt

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

Les crochets d'arrêt ne s'exécutent que si vous appelez `enableShutdownHooks()` — facile à oublier, puis le nettoyage ne se produit jamais.

## Pourquoi l'arrêt gracieux est important

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

## Pourquoi c'est important

Les crochets de cycle de vie sont importants pour gérer correctement les ressources dans les applications NestJS — ils fournissent les bons endroits pour effectuer **l'initialisation** (ouverture des connexions base de données/Redis, chargement des données, inscription auprès des services) et, de manière critique, **le nettoyage gracieux** à l'arrêt (fermeture des connexions, vidage des tampons, finition du travail en cours).

Les comprendre est essentiel pour la fiabilité en production : les **crochets d'initialisation** (`onModuleInit`, `onApplicationBootstrap`) garantissent que la configuration se fait au bon moment une fois les dépendances prêtes, et les **crochets d'arrêt** (`onModuleDestroy`, `onApplicationShutdown`) permettent **l'arrêt gracieux** — ce qui est vital dans les déploiements modernes (les conteneurs/orchestrateurs envoient constamment SIGTERM lors des déploiements et de la mise à l'échelle, et sans nettoyage approprié, vous fuyez des connexions et abandonnez les requêtes actives, cassant les déploiements sans temps d'arrêt).

Le modèle standard de connexion dans `onModuleInit` et de déconnexion dans `onModuleDestroy` (par exemple pour les services Prisma/base de données) est une connaissance NestJS quotidienne, et connaître l'exigence subtile d'appeler `enableShutdownHooks()` (ou les crochets d'arrêt ne se déclenchent jamais silencieusement) est un détail pratique et facile à manquer.

Maîtriser les crochets de cycle de vie fait partie de la construction de services NestJS robustes et prêts pour la production qui gèrent les ressources et les déploiements correctement.