NestJS ఏ lifecycle hooks లను అందిస్తుంది?

Question

IT Interview Practice · Accepted Answer

NestJS **lifecycle hooks** అందిస్తుంది — అప్లికేషన్ లేదా provider యొక్క lifecycle (ప్రారంభం మరియు shutdown) లో నిర్దిష్ట క్షణాలలో కోడ్ నడుపుటకు మీరు అమలు చేసే పద్ధతులు. అవి సెటআప్ (వనరులకు కనెక్ట్ చేయడం) మరియు క్లీనప్ (కనెక్షన్‌లను చక్కగా మూసివేయడం) కోసం అవసరం.

## ప్రధాన 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 సేవ కనెక్ట్/డిస్‌కనెక్ట్

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

ఇది స్పష్టమైన సెటআప్/టియర్‌డౌన్ అవసరమయ్యే వనరుల కోసం ప్రామాణిక నమూనా — `onModuleInit` లో కనెక్ట్ చేయండి, `onModuleDestroy` లో విడుదల చేయండి.

## Shutdown hooks ను సక్రియం చేయడం

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

Shutdown hooks `enableShutdownHooks()` కాల్ చేస్తే మాత్రమే నడుస్తాయి — గుర్తుంచుకోవడం సులభం, తర్వాత క్లీనప్ ఎప్పుడూ జరగదు.

## గ్రేస్‌ఫుల్ 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
```

## ఎందుకు ఇది ముఖ్యమైనది

Lifecycle hooks NestJS అప్లికేషన్‌లలో వనరులను సరిగ్గా నిర్వహించడానికి ముఖ్యమైనవి — అవి **ప్రారంభం** (డేటాబేస్/Redis కనెక్షన్‌లను తెరవడం, డేటా లోడ్ చేయడం, సేవల్లో నమోదు చేయడం) మరియు, విమర్శనీయంగా, shutdown (కనెక్షన్‌లను మూసివేయడం, బఫర్‌లను ఫ్లష్ చేయడం, ఫ్లైట్‌లో ఉన్న పనిని ముగించడం) వద్ద **గ్రేస్‌ఫుల్ క్లీనప్** నిర్వహించడానికి సరైన స్థానాలను అందిస్తాయి.

టాపిక్‌ను అర్థం చేసుకోవడం ఉత్పత్తి విశ్వసనీయత కోసం ముఖ్యమైనది: **ప్రారంభ hooks** (`onModuleInit`, `onApplicationBootstrap`) డిపెండెన్సీలు సిద్ధమైన తర్వాత సెటআప్ సరైన సమయంలో జరుగుతుందని నిశ్చితం చేస్తాయి, మరియు **shutdown hooks** (`onModuleDestroy`, `onApplicationShutdown`) **గ్రేస్‌ఫుల్ shutdown** ను సక్షమం చేస్తాయి — ఇది ఆధునిక నిస్సరణలో (కంటైనర్‌లు/ఆర్కెస్ట్రేటర్‌లు తరచుగా డిప్లాయ్‌లు మరియు స్కేలింగ్ సమయంలో SIGTERM పంపుతాయి) ముఖ్యమైనది, మరియు సరైన క్లీనప్ లేకుండా మీరు కనెక్షన్‌లను లీక్ చేస్తారు మరియు క్రియాశీల అభ్యర్థనలను విస్మరిస్తారు, సున్నా-డౌన్‌టైమ్ నిస్సరణలను విచ్ఛిన్నం చేస్తారు.

`onModuleInit` లో కనెక్ట్ చేయడం మరియు `onModuleDestroy` లో డిస్‌కనెక్ట్ చేయడం (ఉదాహరణకు Prisma/డేటాబేస్ సేవల కోసం) సాధారణ NestJS జ్ఞానం, మరియు shutdown hooks చुप్పగా ఎప్పుడూ నిర్వహణ కాకుండా నిలిచిపోయే విధానాన్ని సక్రియం చేయడానికి `enableShutdownHooks()` కాల్ చేసే సూక్ష్మ అవసరాన్ని తెలుసుకోవడం ఒక ఆచరణాత్మక, సులభంగా తప్పిపోయే వివరాల్లో ఒకటి.

Lifecycle hooks లను నైపుణ్యం సంపादించుకోవడం బలమైన, ఉత్పత్తి-సిద్ధ NestJS సేవలను నిర్మించటలో భాగం, ఇవి వనరులు మరియు నిస్సరణలను సరిగ్గా నిర్వహిస్తాయి.

ప్రధాన hooks

Lifecycle క్రమం

సాధారణ ఉపయోగం: Prisma సేవ కనెక్ట్/డిస్‌కనెక్ట్

Shutdown hooks ను సక్రియం చేయడం

గ్రేస్‌ఫుల్ shutdown ఎందుకు ముఖ్యమైనది

ఎందుకు ఇది ముఖ్యమైనది

సంబంధిత ప్రశ్నలు