Feature modules in NestJS - Step-by-Step Execution

Concept Flow - Feature modules

Create Feature Module File

↓

Define @Module with imports, controllers, providers

↓

Export Module Class

↓

Import Feature Module in Root or Other Modules

↓

NestJS Loads Module and Registers Components

↓

Feature Module Provides Scoped Functionality

This flow shows how to create a feature module, define its parts, export it, and import it into the app so NestJS can load and use it.

Execution Sample

NestJS

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

Defines a feature module named CatsModule with a controller and a service.

Execution Table

Step	Action	Evaluation	Result
1	Read file cats.module.ts	Parse @Module decorator	Identify controllers and providers
2	Create CatsController instance	Prepare controller for routing	Controller ready
3	Create CatsService instance	Prepare service for injection	Service ready
4	Register CatsController and CatsService in module context	Module setup	Module components registered
5	Export CatsModule class	Module available for import	Module ready to be imported
6	Import CatsModule in AppModule	NestJS loads module	Feature module integrated
7	App runs, routes handled by CatsController	Requests handled	Feature module active
8	Exit	All components loaded	Execution complete

💡 All feature module components registered and module imported into app

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
CatsController	undefined	instance created	instance created	registered in module	registered in module
CatsService	undefined	undefined	instance created	registered in module	registered in module
CatsModule	undefined	undefined	undefined	defined and exported	imported in AppModule

Key Moments - 3 Insights

Why do we need to import the feature module in the root module?

Because NestJS only loads modules that are imported. Without importing, the feature module's controllers and providers won't be available in the app. See execution_table step 6.

What happens if we forget to add a service to the providers array?

The service won't be registered for dependency injection, so controllers or other providers depending on it will fail. See execution_table step 3 and 4.

Can a feature module have its own controllers and providers?

Yes, feature modules group related controllers and providers to organize code. This is shown in execution_table steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the CatsService instance created?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check the 'Action' and 'Evaluation' columns in execution_table rows for CatsService creation.

At which step does NestJS integrate the feature module into the app?

A Step 6

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the step mentioning importing CatsModule in AppModule.

If we remove CatsController from the controllers array, what changes in the execution?

A CatsController instance is still created

B CatsController instance is not created

C CatsService is not created

D Module fails to load

💡 Hint

Refer to execution_table step 2 about CatsController instance creation.

Concept Snapshot

Feature modules group related controllers and providers.
Use @Module decorator with controllers and providers arrays.
Export the module class.
Import feature modules in root or other modules.
NestJS loads and registers components for app use.

Full Transcript

Feature modules in NestJS help organize code by grouping related controllers and providers. You create a feature module by defining a class with the @Module decorator, listing controllers and providers inside. After exporting this module class, you import it into the root module or other modules. NestJS then loads the feature module, creates instances of controllers and providers, and registers them so the app can use their functionality. This process ensures your app stays modular and easy to maintain.

Practice

1. What is the main purpose of a feature module in NestJS?

easy

A. To manage HTTP requests without controllers

B. To group related controllers and services for better organization

C. To replace the main application module

D. To handle database connections directly

Solution

1. Step 1: Understand the role of feature modules

   Feature modules group related parts of the app like controllers and services to keep code organized.

2. Step 2: Compare options with this role

   Only To group related controllers and services for better organization describes grouping related controllers and services, which matches the purpose.

3. Final Answer:

   To group related controllers and services for better organization -> Option B

4. Quick Check:

   Feature modules organize code = D [OK]

Hint: Feature modules group related parts of your app [OK]

Common Mistakes:

• Thinking feature modules handle database connections directly
• Confusing feature modules with the main app module
• Assuming feature modules replace controllers

2. Which of the following is the correct way to define a feature module in NestJS?

easy

A. @Controller({}) export class FeatureModule {}

B. @Injectable() export class FeatureModule {}

C. @Module({ controllers: [], providers: [] }) export class FeatureModule {}

D. export class FeatureModule {}

Solution

1. Step 1: Recall the decorator for modules

   Feature modules use the @Module decorator with metadata like controllers and providers.

2. Step 2: Match options with correct decorator

   Only @Module({ controllers: [], providers: [] }) export class FeatureModule {} uses @Module with controllers and providers arrays, which is correct syntax.

3. Final Answer:

   @Module({ controllers: [], providers: [] }) export class FeatureModule {} -> Option C

4. Quick Check:

   @Module decorator defines modules = B [OK]

Hint: Use @Module decorator with controllers and providers [OK]

Common Mistakes:

• Using @Controller or @Injectable instead of @Module
• Forgetting to add the decorator
• Defining empty classes without decorators

3. Given this feature module code, what will be the output when the getHello() method is called from HelloController?

@Module({
  controllers: [HelloController],
  providers: [HelloService],
})
export class HelloModule {}

@Injectable()
export class HelloService {
  getHello() {
    return 'Hello from service!';
  }
}

@Controller()
export class HelloController {
  constructor(private readonly helloService: HelloService) {}

  @Get()
  getHello() {
    return this.helloService.getHello();
  }
}

medium

A. undefined

B. "Hello from controller!"

C. Runtime error due to missing provider

D. "Hello from service!"

Solution

1. Step 1: Understand dependency injection in the module

   The HelloService is provided in the module and injected into HelloController.

2. Step 2: Trace the method call

   The controller's getHello calls helloService.getHello(), which returns 'Hello from service!'.

3. Final Answer:

   "Hello from service!" -> Option D

4. Quick Check:

   Service method returns string = C [OK]

Hint: Controller calls service method returning string [OK]

Common Mistakes:

• Assuming controller returns its own string
• Thinking provider is missing causing error
• Confusing method names or return values

4. Identify the error in this feature module definition:

@Module({
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

@Injectable()
export class UserService {}

@Controller()
export class UserController {
  constructor(userService: UserService) {}
}

medium

A. Missing access modifier 'private' in constructor injection

B. UserService is not decorated with @Injectable()

C. UserController is missing @Controller() decorator

D. UserService is not listed in providers array

Solution

1. Step 1: Check constructor injection syntax

   In NestJS, injected dependencies must have an access modifier like private or public to create a class property.

2. Step 2: Identify the missing modifier

   The constructor parameter 'userService' lacks 'private' or 'public', so it won't be assigned automatically.

3. Final Answer:

   Missing access modifier 'private' in constructor injection -> Option A

4. Quick Check:

   Constructor injection needs access modifier = A [OK]

Hint: Constructor injection needs private/public keyword [OK]

Common Mistakes:

• Forgetting private/public in constructor parameters
• Assuming @Injectable is missing when it is present
• Confusing decorator placement

5. You want to create a feature module that imports another feature module to reuse its services. Which of the following is the correct way to import AuthModule into UserModule?

hard

A. @Module({ imports: [AuthModule], controllers: [UserController], providers: [UserService] }) export class UserModule {}

B. @Module({ controllers: [UserController], providers: [UserService] }) export class UserModule { constructor(private authModule: AuthModule) {} }

C. @Module({ exports: [AuthModule], controllers: [UserController], providers: [UserService] }) export class UserModule {}

D. @Module({ imports: [], controllers: [UserController], providers: [UserService] }) export class UserModule {}

Solution

1. Step 1: Understand module imports in NestJS

   To reuse services from another module, you must import that module in the imports array.

2. Step 2: Identify correct import usage

   @Module({ imports: [AuthModule], controllers: [UserController], providers: [UserService] }) export class UserModule {} correctly adds AuthModule to imports, allowing UserModule to use its exported providers.

3. Final Answer:

   @Module({ imports: [AuthModule], controllers: [UserController], providers: [UserService] }) export class UserModule {} -> Option A

4. Quick Check:

   Import modules via imports array = A [OK]

Hint: Use imports array to include other feature modules [OK]

Common Mistakes:

• Trying to inject modules via constructor instead of imports
• Using exports instead of imports to include modules
• Leaving imports array empty when reusing modules