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.
{ } ;
({
: [],
: [],
: [],
: [],
})
{}
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).
@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.
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.
// 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.
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.