What are modules in NestJS and how do they work?

NestJS Modules

A Module is the fundamental building block of a NestJS application. Every NestJS app has at least one module — the root module (AppModule). Modules help organize your application into cohesive blocks of functionality.

The @Module() Decorator

typescript

import { Module } from '@nestjs/common';

@Module({
  imports:     [],   // other modules to import
  controllers: [],   // controllers defined in this module
  providers:   [],   // services/providers defined in this module
  exports:     [],   // providers to expose to other modules
})
export class UsersModule {}

Property	Description
`imports`	Modules whose exported providers are needed here
`controllers`	Controllers that belong to this module
`providers`	Services, repositories, factories, etc.
`exports`	Subset of providers available to importing modules

Feature Module Example

typescript

// users/users.module.ts
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService], // make UsersService available to other modules
})
export class UsersModule {}

// app.module.ts (root module)
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';
import { PostsModule } from './posts/posts.module';

@Module({
  imports: [UsersModule, PostsModule],
})
export class AppModule {}

Module Types

Feature Module

Groups related controllers and services for one domain:

typescript

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

Shared Module

Provides common services across the app by exporting them:

typescript

@Module({
  providers: [EmailService, LoggerService],
  exports: [EmailService, LoggerService],
})
export class SharedModule {}

Global Module

Available in every module without importing:

typescript

import { Global, Module } from '@nestjs/common';

@Global()
@Module({
  providers: [ConfigService],
  exports: [ConfigService],
})
export class ConfigModule {}

Dynamic Module

Configured at import time (useful for libraries):

typescript

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        { provide: 'DATABASE_OPTIONS', useValue: options },
        DatabaseService,
      ],
      exports: [DatabaseService],
      global: true,
    };
  }
}

// Usage:
@Module({
  imports: [DatabaseModule.forRoot({ host: 'localhost' })],
})
export class AppModule {}

Recommended Folder Structure

src/
├── app.module.ts
├── main.ts
├── users/
│   ├── users.module.ts
│   ├── users.controller.ts
│   ├── users.service.ts
│   ├── users.repository.ts
│   ├── dto/
│   │   ├── create-user.dto.ts
│   │   └── update-user.dto.ts
│   └── entities/
│       └── user.entity.ts
└── shared/
    ├── shared.module.ts
    └── services/
        └── email.service.ts

Summary

Modules in NestJS are namespaces that encapsulate a feature area. Use feature modules to keep code organized, shared modules for reusable services, global modules for app-wide providers, and dynamic modules for configurable libraries. Every provider must belong to a module before it can be used.

Short Answer

Interview ready

Premium

A concise answer to help you respond confidently on this topic during an interview.

Finished reading?

Practice Problems