What are modules in NestJS?

Question

Accepted Answer

A **module** is a class decorated with `@Module()` that **groups related components** — controllers, providers/services — into a cohesive unit. Modules are how NestJS organizes an application into features, and every Nest app has at least a root `AppModule`.

## Defining a 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 {}
```

## The four key 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 form a **DI scope**: a provider is available within its module, and to other modules only if **exported** (and the other module **imports** it).

## The root module

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

Every app has a root `AppModule` that imports the feature modules, composing the whole application.

## Feature-based organization

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

The convention is **one module per feature/domain** (users, auth, products), keeping related code together and dependencies explicit.

## Sharing providers across modules

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

To use a provider from another module, the providing module must **export** it and the consuming module must **import** the providing module — making dependencies explicit.

## Why it matters

Modules are the organizational backbone of every NestJS application — they group related controllers and providers into cohesive feature units and define the dependency-injection boundaries.

Understanding the four properties (`controllers`, `providers`, `imports`, `exports`) and especially the **import/export mechanism** for sharing providers across modules is essential: it's how NestJS achieves modular, loosely-coupled architecture where each feature is self-contained and dependencies are explicit.

The feature-based module structure (one module per domain) is the standard way to organize Nest apps for scalability and maintainability.

Modules, together with controllers and providers, form NestJS's core architecture, making them fundamental knowledge — mastering how to structure an app into modules and wire providers between them via imports/exports is necessary for building any non-trivial NestJS application and is a frequent point of confusion worth understanding well early.