What lifecycle hooks does NestJS provide?

Question

Accepted Answer

NestJS provides **lifecycle hooks** — methods you implement to run code at specific moments in the application's or a provider's lifecycle (initialization and shutdown). They're essential for setup (connecting to resources) and cleanup (closing connections gracefully).

## The main hooks

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

## The lifecycle sequence

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

## A common use: a Prisma service connecting/disconnecting

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

This is the standard pattern for resources that need explicit setup/teardown — connect in `onModuleInit`, release in `onModuleDestroy`.

## Enabling shutdown hooks

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

The shutdown hooks only run if you call `enableShutdownHooks()` — easy to forget, then cleanup never happens.

## Why graceful shutdown matters

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

## Why it matters

Lifecycle hooks are important for managing resources correctly in NestJS applications — they provide the proper places to perform **initialization** (opening database/Redis connections, loading data, registering with services) and, critically, **graceful cleanup** on shutdown (closing connections, flushing buffers, finishing in-flight work).

Understanding them is essential for production reliability: the **initialization hooks** (`onModuleInit`, `onApplicationBootstrap`) ensure setup happens at the right time once dependencies are ready, and the **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) enable **graceful shutdown** — which is vital in modern deployment (containers/orchestrators send SIGTERM constantly during deploys and scaling, and without proper cleanup you leak connections and drop active requests, breaking zero-downtime deployments).

The standard pattern of connecting in `onModuleInit` and disconnecting in `onModuleDestroy` (e.g. for Prisma/database services) is everyday NestJS knowledge, and knowing the subtle requirement to call `enableShutdownHooks()` (or shutdown hooks silently never fire) is a practical, easy-to-miss detail.

Mastering lifecycle hooks is part of building robust, production-ready NestJS services that handle resources and deployments correctly.