Quais hooks de ciclo de vida o NestJS fornece?

Question

Accepted Answer

O NestJS fornece **hooks de ciclo de vida** — métodos que você implementa para executar código em momentos específicos do ciclo de vida da aplicação ou de um provider (inicialização e encerramento). Eles são essenciais para setup (conectar a recursos) e limpeza (fechar conexões graciosamente).

## Os hooks principais

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

## A sequência do ciclo de vida

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

## Um caso comum: um serviço Prisma conectando/desconectando

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

Este é o padrão padrão para recursos que precisam de setup/teardown explícito — conecte em `onModuleInit`, libere em `onModuleDestroy`.

## Ativando shutdown hooks

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

Os shutdown hooks só executam se você chamar `enableShutdownHooks()` — fácil de esquecer, então a limpeza nunca acontece.

## Por que encerramento gracioso importa

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

## Por que isso importa

Os hooks de ciclo de vida são importantes para gerenciar recursos corretamente em aplicações NestJS — eles fornecem os locais apropriados para realizar **inicialização** (abrir conexões de banco de dados/Redis, carregar dados, registrar com serviços) e, criticamente, **limpeza graciosa** no encerramento (fechar conexões, liberar buffers, terminar trabalho em voo).

Entendê-los é essencial para confiabilidade em produção: os **hooks de inicialização** (`onModuleInit`, `onApplicationBootstrap`) garantem que o setup ocorra no momento certo assim que as dependências estiverem prontas, e os **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) habilitam **encerramento gracioso** — que é vital em implantação moderna (containers/orquestradores enviam SIGTERM constantemente durante deploys e scaling, e sem limpeza adequada você vaza conexões e perde requisições ativas, quebrando deploys zero-downtime).

O padrão padrão de conectar em `onModuleInit` e desconectar em `onModuleDestroy` (por exemplo, para serviços Prisma/banco de dados) é conhecimento NestJS do dia a dia, e saber o detalhe sutil de que é necessário chamar `enableShutdownHooks()` (ou shutdown hooks silenciosamente nunca disparam) é um detalhe prático e fácil de perder.

Dominar hooks de ciclo de vida é parte da construção de serviços NestJS robustos e prontos para produção que lidam corretamente com recursos e implantações.