NestJS-இல் modules என்றால் என்ன?

Question

Accepted Answer

ஒரு **module** என்பது `@Module()`-ஆல் decorate செய்யப்பட்ட ஒரு class ஆகும், இது தொடர்புடைய கூறுகளை — controllers, providers/services — ஒரு ஒத்திசைவான அலகாக **குழுவாக்குகிறது**. Modules என்பது NestJS ஒரு application-ஐ features ஆக ஒழுங்கமைக்கும் விதமாகும், மேலும் ஒவ்வொரு Nest app-க்கும் குறைந்தபட்சம் ஒரு root `AppModule` உள்ளது.

## ஒரு module-ஐ வரையறுத்தல்

```ts
import { Module } from "@nestjs/common";

@Module({
  controllers: [UsersController],    // controllers belonging to this module
  providers: [UsersService],          // providers (services) this module creates
  imports: [DatabaseModule],          // OTHER modules whose exports this module needs
  exports: [UsersService],            // what this module makes available to importers
})
export class UsersModule {}
```

## நான்கு முக்கிய properties

```text
controllers → the controllers (request handlers) in this module
providers   → the providers/services defined and instantiated here (for DI)
imports     → other modules whose EXPORTED providers this module can use
exports     → the subset of THIS module's providers shared with importing modules
```

Modules ஒரு **DI scope**-ஐ உருவாக்குகின்றன: ஒரு provider அதன் module-க்குள் கிடைக்கிறது, மற்றும் மற்ற modules-க்கு **export** செய்யப்பட்டால் மட்டுமே கிடைக்கிறது (மற்றும் மற்ற module அதை **import** செய்தால்).

## root module

```ts
@Module({
  imports: [UsersModule, AuthModule, DatabaseModule],   // compose feature modules
})
export class AppModule {}   // the root — bootstrapped to start the app
```

ஒவ்வொரு app-க்கும் feature modules-ஐ import செய்யும் ஒரு root `AppModule` உள்ளது, இது முழு applicationஐயும் இணைக்கிறது.

## Feature அடிப்படையிலான ஒழுங்கமைப்பு

```text
src/
  app.module.ts            (root — imports feature modules)
  users/
    users.module.ts        (groups users controller + service)
    users.controller.ts
    users.service.ts
  auth/
    auth.module.ts
  database/
    database.module.ts     (shared infrastructure)
```

வழக்கம் என்பது **ஒரு feature/domain-க்கு ஒரு module** (users, auth, products), இது தொடர்புடைய code-ஐ ஒன்றாக வைத்து dependencies-ஐ வெளிப்படையாக வைத்திருக்கிறது.

## modules-இல் providers-ஐ பகிர்தல்

```ts
// UsersModule exports UsersService...
@Module({ providers: [UsersService], exports: [UsersService] })
export class UsersModule {}

// ...so AuthModule can use it by importing UsersModule
@Module({ imports: [UsersModule] })   // now AuthModule can inject UsersService
export class AuthModule {}
```

மற்றொரு module-இலிருந்து ஒரு provider-ஐ பயன்படுத்த, வழங்கும் module அதை **export** செய்ய வேண்டும் மற்றும் நுகரும் module வழங்கும் module-ஐ **import** செய்ய வேண்டும் — இது dependencies-ஐ வெளிப்படையாக ஆக்குகிறது.

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

Modules என்பது ஒவ்வொரு NestJS application-இன் ஒழுங்கமைப்பு முதுகெலும்பு — அவை தொடர்புடைய controllers மற்றும் providers-ஐ ஒத்திசைவான feature அலகுகளாக குழுவாக்கி dependency-injection எல்லைகளை வரையறுக்கின்றன.

நான்கு properties (`controllers`, `providers`, `imports`, `exports`)-ஐயும், குறிப்பாக modules-இடையே providers-ஐ பகிர்வதற்கான **import/export mechanism**-ஐயும் புரிந்துகொள்வது அத்தியாவசியம்: இதுதான் NestJS modular, loosely-coupled architecture-ஐ அடையும் விதம், அங்கு ஒவ்வொரு feature-ம் self-contained ஆகவும் dependencies வெளிப்படையாகவும் இருக்கின்றன.

Feature அடிப்படையிலான module structure (ஒரு domain-க்கு ஒரு module) என்பது scalability மற்றும் maintainability-க்காக Nest apps-ஐ ஒழுங்கமைக்கும் standard வழியாகும்.

Modules, controllers மற்றும் providers-உடன் இணைந்து, NestJS-இன் முக்கிய architecture-ஐ உருவாக்குகின்றன, அதனால் அவை அடிப்படை அறிவு — ஒரு app-ஐ modules ஆக கட்டமைப்பது மற்றும் imports/exports மூலம் providers-ஐ அவற்றுக்கிடையே இணைப்பது எவ்வாறு என்பதை தேர்ச்சி பெறுவது எந்த non-trivial NestJS application-ஐயும் உருவாக்க அவசியம் மற்றும் ஆரம்பத்திலேயே நன்கு புரிந்துகொள்ள வேண்டிய அடிக்கடி குழப்பத்திற்குரிய ஒரு புள்ளி.