რა lifecycle hooks-ებს უზრუნველყოფს NestJS?

Question

Accepted Answer

NestJS უზრუნველყოფს **lifecycle hooks-ებს** — მეთოდებს, რომლებიც თქვენ აერთებთ კოდის გაშვებისთვის აპლიკაციის ან provider-ის lifecycle-ის სპეციფიკურ მომენტებში (ინიციალიზაცია და shutdown). ისინი არსებითია setup-ისთვის (რესურსებთან კავშირისთვის) და cleanup-ისთვის (კავშირების gracefully დახურვისთვის).

## ძირითადი 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 რომელიც 連/დისკონექტებს

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

ეს არის სტანდარტული pattern რესურსებისთვის, რომლებსაც აფიცებთ explicit setup/teardown — დაკავშირება `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()` — ადვილი ასეთია დავიწყება, შემდეგ 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
```

## რატომ აქვს მნიშვნელობა

Lifecycle hooks-ები მნიშვნელოვანია რესურსების სწორი მართვისთვის NestJS აპლიკაციებში — ისინი უზრუნველყოფენ **ინიციალიზაციის** და, კრიტიკულად, **graceful cleanup-ის** შესასრულებელი სწორი ადგილებს shutdown-ზე (კავშირების დახურვა, buffers-ის flushing, in-flight work-ის დასრულება).

აქვე გაგება არის აუცილებელი production-ის საიმედოობისთვის: **ინიციალიზაციის hooks-ები** (`onModuleInit`, `onApplicationBootstrap`) უზრუნველყოფენ, რომ setup მოხდეს სწორ დროს, როდესაც dependencies მზად არის, და **shutdown hooks-ები** (`onModuleDestroy`, `onApplicationShutdown`) ხელი შეუწყს **graceful shutdown-ს** — რაც ვიტალური ხელმოწერაა თანამედროვე deployment-ისთვის (containers/orchestrators მუდმივად აგზავნიან SIGTERM-ს deploy-ის და scaling-ის დროს, და სწორი cleanup-ის გარეშე თქვენ დაკარგავთ კავშირებს და დააგდებთ active requests-ებს, წყვეტს zero-downtime deployments-ს).

standard pattern-ი დაკავშირებისთვის `onModuleInit`-ში და დისკონექტებისთვის `onModuleDestroy`-ში (მაგ. Prisma/database services-ებისთვის) ყოველდღიური NestJS ცოდნაა, და იმის ცოდნა, რომ subtle requirement აქვს `enableShutdownHooks()` დაწოდებას (ან shutdown hooks-ები quietly არასოდეს ხდება) არის პრაქტიკული, ადვილი დამავიწყების დეტალი.

Lifecycle hooks-ების დაუფლება არის robust, production-ready NestJS services-ის აგების ნაწილი, რომელიც სწორად აკეთებს რესურსებისა და deployment-ების სამართავს.