NestJS मध्ये modules काय आहेत?

Question

Accepted Answer

A **module** हा `@Module()` decorator ने सजविलेला एक class आहे जो **संबंधित components** — controllers, providers/services — एका समन्वित युनिटमध्ये गटबद्ध करतो। Modules हे NestJS अॅप्लिकेशनला features मध्ये व्यवस्थित करते, आणि प्रत्येक Nest अॅपमध्ये किमान एक 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 मध्ये फक्त तर **exported** असल्यास (आणि दुसरा module त्याला **imports** करत असल्यास).

## Root module

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

प्रत्येक अॅपमध्ये एक root `AppModule` असते जो feature modules import करतो, संपूर्ण अॅप्लिकेशन तयार करतो.

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

नियम म्हणजे **one module per feature/domain** (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 वापरण्यासाठी, provider देणारा module त्याला **export** केला पाहिजे आणि consuming module ने provider देणारा module **import** केला पाहिजे — dependencies स्पष्ट करून.

## महत्त्व

Modules प्रत्येक NestJS अॅप्लिकेशनचा संघटनात्मक मेरुदंड आहेत — ते संबंधित controllers आणि providers को cohesive feature units मध्ये गटबद्ध करतात आणि dependency-injection boundaries परिभाषित करतात.

चार properties (`controllers`, `providers`, `imports`, `exports`) समजणे आणि विशेषतः modules मधून providers साझा करण्यासाठी **import/export mechanism** समजणे अत्यावश्यक आहे: हेच NestJS ला modular, loosely-coupled architecture साध्य करते जेथे प्रत्येक feature self-contained असते आणि dependencies स्पष्ट असतात.

Feature-आधारित module structure (one module per domain) Nest apps ला scalability आणि maintainability साठी व्यवस्थित करण्याचा मानक मार्ग आहे.

Modules, together with controllers आणि providers, NestJS च्या मुख्य architecture बनवतात, त्यांना fundamental knowledge असे बनवून — अॅप modules मध्ये कसे structure करायचे आणि imports/exports द्वारे providers मधून wire करायचे हे कसव्हर करणे कोणत्याही non-trivial NestJS अॅप्लिकेशन बनवण्यासाठी आवश्यक आहे आणि सुधारायला आणि सुरुवातीला चांगल्या प्रकारे समजायला योग्य गोंधळाचा वारंवार बिंदू आहे.