Graceful Shutdown in NestJS with Lifecycle Events

In the world of Node.js applications, graceful shutdown is a crucial feature that ensures your application can handle termination signals properly, close open connections, and perform necessary cleanup tasks before shutting down. NestJS, a popular framework for building efficient and scalable Node.js server-side applications, provides built-in support for graceful shutdown through lifecycle events.

Why Graceful Shutdown Matters

Graceful shutdown is important for several reasons:

1. Resource Management: It allows your application to close database connections, file handles, and other resources properly.

2. Data Integrity: It ensures that ongoing operations are completed or rolled back, preventing data corruption.

3. User Experience: It can help manage active user sessions, allowing them to complete their current actions.

Implementing Graceful Shutdown in NestJS

NestJS offers lifecycle hooks that make implementing graceful shutdown straightforward. Let's look at how to set this up using the OnApplicationShutdown interface and the enableShutdownHooks() method.

Setting Up the Main Application File

First, let's examine the main.ts file:

import { NestFactory } from '@nestjs/core';
import {
  ExpressAdapter,
  NestExpressApplication,
} from '@nestjs/platform-express';
import { AppModule } from './modules/app/app.module';

async function bootstrap() {
  const app: NestExpressApplication = await NestFactory.create(
    AppModule,
    new ExpressAdapter(),
  );
  app.enableShutdownHooks();
  const port = 3000;
  await app.listen(port);
  return port;
}

bootstrap().then((port) =>
  console.log(`App successfully started on port ${port} !`),
);        

The key line here is app.enableShutdownHooks(). This method tells NestJS to listen for shutdown signals and trigger the appropriate lifecycle hooks when they occur.

Implementing Shutdown Logic in the App Module

Now, let's look at the app.module.ts file:

import { Logger, Module, OnApplicationShutdown } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import mongoose from 'mongoose';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest')
  ],
  controllers: [AppController],
  providers: [AppService],
  exports: [],
})
export class AppModule implements OnApplicationShutdown {
  onApplicationShutdown(signal: string): void {
    mongoose.disconnect();
    Logger.debug(`Application shut down (signal: ${signal})`);
  }
}        

Here, the AppModule class implements the OnApplicationShutdown interface. This interface requires the implementation of the onApplicationShutdown method, which is called when the application is about to shut down.

In this method, we're performing two important tasks:

1. Disconnecting from the MongoDB database using mongoose.disconnect().

2. Logging a debug message with the signal that triggered the shutdown.

How It Works

When your NestJS application receives a termination signal (like SIGTERM or SIGINT), the following sequence occurs:

1. NestJS triggers the onApplicationShutdown method on all providers and modules that implement it.

2. In our case, the MongoDB connection is closed, and a debug message is logged.

3. After all shutdown hooks have completed, the application terminates.

This approach ensures that your application has a chance to clean up resources and complete critical operations before shutting down.

Conclusion

Implementing graceful shutdown in your NestJS application is a best practice that can prevent resource leaks, data corruption, and improve overall application reliability. By using the OnApplicationShutdown interface and the enableShutdownHooks() method, you can easily add this important feature to your NestJS applications.

Remember to implement shutdown logic for all critical resources and operations in your application, not just database connections. This might include closing file handles, terminating worker processes, or completing in-flight HTTP requests.