NestJS எந்த lifecycle hooks-ஐ வழங்குகிறது?

Question

Accepted Answer

NestJS **lifecycle hooks**-ஐ வழங்குகிறது — application-இன் அல்லது ஒரு provider-இன் lifecycle-இல் (initialization மற்றும் shutdown) குறிப்பிட்ட தருணங்களில் code-ஐ இயக்க நீங்கள் implement செய்யும் methods. அவை setup-க்கு (resources உடன் இணைத்தல்) மற்றும் cleanup-க்கு (connections-ஐ அழகாக மூடுதல்) அவசியம்.

## முக்கிய 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
  }
}
```

## Lifecycle வரிசை

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

## ஒரு பொதுவான பயன்பாடு: ஒரு 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
  }
}
```

வெளிப்படையான setup/teardown தேவைப்படும் resources-க்கு இதுவே நிலையான pattern — `onModuleInit`-இல் connect செய்து, `onModuleDestroy`-இல் release செய்யவும்.

## Shutdown hooks-ஐ இயக்குதல்

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

நீங்கள் `enableShutdownHooks()`-ஐ அழைத்தால் மட்டுமே shutdown hooks இயங்கும் — மறந்துவிட எளிது, அப்போது cleanup ஒருபோதும் நடக்காது.

## Graceful shutdown ஏன் முக்கியம்

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

## இது ஏன் முக்கியம்

NestJS applications-இல் resources-ஐ சரியாக நிர்வகிப்பதற்கு lifecycle hooks முக்கியம் — அவை **initialization**-ஐ (database/Redis connections-ஐ திறத்தல், data ஏற்றுதல், services உடன் register செய்தல்) செய்வதற்கான சரியான இடங்களையும், முக்கியமாக, shutdown-இல் **graceful cleanup**-ஐயும் (connections-ஐ மூடுதல், buffers-ஐ flush செய்தல், in-flight work-ஐ முடித்தல்) வழங்குகின்றன.

Production நம்பகத்தன்மைக்கு அவற்றைப் புரிந்துகொள்வது அவசியம்: **initialization hooks** (`onModuleInit`, `onApplicationBootstrap`) dependencies தயாரானவுடன் சரியான நேரத்தில் setup நடப்பதை உறுதிசெய்கின்றன, மேலும் **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) **graceful shutdown**-ஐ செயல்படுத்துகின்றன — இது நவீன deployment-இல் இன்றியமையாதது (containers/orchestrators deploys மற்றும் scaling-இன் போது தொடர்ந்து SIGTERM அனுப்புகின்றன, மேலும் சரியான cleanup இல்லாமல் நீங்கள் connections-ஐ கசியவிட்டு, active requests-ஐ விட்டுவிடுகிறீர்கள், zero-downtime deployments-ஐ உடைக்கிறீர்கள்).

`onModuleInit`-இல் connecting செய்து `onModuleDestroy`-இல் disconnecting செய்யும் நிலையான pattern (எ.கா. Prisma/database services-க்கு) தினசரி NestJS அறிவாகும், மேலும் `enableShutdownHooks()`-ஐ அழைக்க வேண்டிய நுட்பமான தேவையை (இல்லையெனில் shutdown hooks அமைதியாக ஒருபோதும் இயங்காது) அறிந்திருப்பது ஒரு நடைமுறை, தவறவிட எளிதான விவரமாகும்.

Lifecycle hooks-ஐ தேர்ச்சி பெறுவது resources மற்றும் deployments-ஐ சரியாகக் கையாளும் வலுவான, production-ready NestJS services-ஐ உருவாக்குவதன் ஒரு பகுதியாகும்.