Apa itu modul di NestJS?

Question

Accepted Answer

Sebuah **modul** adalah sebuah class yang didekorasi dengan `@Module()` yang **mengelompokkan komponen-komponen terkait** — controllers, providers/services — menjadi satu unit yang kohesif. Modul adalah cara NestJS mengorganisir aplikasi menjadi fitur-fitur, dan setiap aplikasi Nest memiliki setidaknya satu root `AppModule`.

## Mendefinisikan sebuah modul

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

## Empat properti utama

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

Modul membentuk sebuah **DI scope**: sebuah provider tersedia di dalam modulnya, dan ke modul lain hanya jika **diekspor** (dan modul lain **mengimportnya**).

## Modul root

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

Setiap aplikasi memiliki sebuah root `AppModule` yang mengimport modul-modul fitur, menyusun seluruh aplikasi.

## Organisasi berbasis fitur

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

Konvensinya adalah **satu modul per fitur/domain** (users, auth, products), menjaga kode terkait bersama-sama dan membuat dependensi eksplisit.

## Berbagi provider antar modul

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

Untuk menggunakan sebuah provider dari modul lain, modul penyedia harus **mengekspornya** dan modul konsumen harus **mengimport** modul penyedia — membuat dependensi eksplisit.

## Mengapa ini penting

Modul adalah tulang punggung organisasi dari setiap aplikasi NestJS — mereka mengelompokkan controllers dan providers terkait menjadi unit-unit fitur yang kohesif dan mendefinisikan batas-batas dependency-injection.

Memahami empat properti (`controllers`, `providers`, `imports`, `exports`) dan khususnya mekanisme **import/export** untuk berbagi providers antar modul sangat penting: ini adalah cara NestJS mencapai arsitektur yang modular dan loosely-coupled di mana setiap fitur adalah self-contained dan dependensi bersifat eksplisit.

Struktur modul berbasis fitur (satu modul per domain) adalah cara standar untuk mengorganisir aplikasi Nest untuk skalabilitas dan kemudahan pemeliharaan.

Modul, bersama dengan controllers dan providers, membentuk arsitektur inti NestJS, menjadikan mereka pengetahuan fundamental — menguasai cara menyusun aplikasi menjadi modul dan menghubungkan providers antar mereka melalui imports/exports diperlukan untuk membangun aplikasi NestJS non-trivial apa pun dan merupakan titik kebingungan yang sering terjadi yang perlu dipahami dengan baik sejak awal.