Feature modules in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a feature module in NestJS?

A feature module is a module that groups related components, services, and controllers to organize code by functionality. It helps keep the app modular and easier to maintain.

beginner

How do feature modules improve a NestJS application?

They separate concerns by grouping related code, making the app easier to understand, test, and scale. They also enable lazy loading and better dependency management.

beginner

Which decorator is used to define a feature module in NestJS?

The @Module() decorator is used to define a feature module. It takes metadata like imports, controllers, providers, and exports to configure the module.

intermediate

Can feature modules import other modules in NestJS? Why?

Yes, feature modules can import other modules to use their exported providers. This allows sharing functionality and keeps code DRY (Don't Repeat Yourself).

intermediate

What is the difference between a root module and a feature module in NestJS?

The root module is the main app module that bootstraps the application. Feature modules are additional modules that group related features and are imported into the root or other modules.

Which decorator defines a feature module in NestJS?

A @Module()

B @Injectable()

C @Controller()

D @Component()

The @Module() decorator is used to define modules, including feature modules, in NestJS.

What is the main purpose of feature modules in NestJS?

A Bootstrap the application

B Handle HTTP requests

C Group related code by functionality

D Manage database connections

Feature modules group related components, services, and controllers to organize code by functionality.

Can a feature module import another feature module in NestJS?

A Only controllers can be imported

B No, modules must be isolated

C Only root modules can import feature modules

D Yes, to share providers and controllers

Feature modules can import other modules to reuse exported providers and controllers.

Which of these is NOT part of the @Module() metadata in a feature module?

A routes

B providers

C imports

D controllers

The @Module() decorator does not have a 'routes' property; routing is handled by controllers.

What is the root module in a NestJS app?

A A module that handles database connections

B The main module that bootstraps the app

C A feature module for user management

D A module that only contains services

The root module is the main app module that starts the application.

Explain what a feature module is in NestJS and why it is useful.

Think about how you organize tools in different boxes by their use.

Describe how feature modules interact with each other in a NestJS application.

Consider how teams share resources to work better together.

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