Why modules organize application structure in NestJS - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a basic NestJS module.

NestJS

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

@Module({
  [1]: [],
})
export class AppModule {}

Drag options to blanks, or click blank then click option'

Acomponents

Broutes

Cservices

Dcontrollers

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'components' instead of 'controllers'.

Confusing 'services' with module metadata keys.

The controllers array defines which controllers belong to the module.

2fill in blank

medium

Complete the code to import another module inside a NestJS module.

NestJS

import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';

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

Drag options to blanks, or click blank then click option'

AUserController

BUsersModule

CUserService

DUserEntity

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to import a service or controller instead of a module.

Forgetting to add the imported module to the imports array.

The imports array includes other modules like UsersModule to organize features.

3fill in blank

hard

Fix the error in the module definition by completing the providers array.

NestJS

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';

@Module({
  providers: [[1]],
})
export class UsersModule {}

Drag options to blanks, or click blank then click option'

AUsersController

BUsersModule

CUsersService

DUserEntity

Attempts:

3 left

💡 Hint

Common Mistakes

Adding controllers to providers array.

Adding modules or entities instead of services.

The providers array should include services like UsersService to be injectable.

4fill in blank

hard

Fill both blanks to export a service and import a module in a NestJS module.

NestJS

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [[1]],
  providers: [AuthService],
  exports: [[2]],
})
export class AuthModule {}

Drag options to blanks, or click blank then click option'

AUsersModule

BAuthService

CUsersService

DAuthController

Attempts:

3 left

💡 Hint

Common Mistakes

Exporting modules instead of services.

Importing services instead of modules.

The imports array includes UsersModule to use its features.
The exports array makes AuthService available to other modules.

5fill in blank

hard

Fill all three blanks to create a module that imports another module, provides a service, and exports that service.

NestJS

import { Module } from '@nestjs/common';
import { PaymentsService } from './payments.service';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [[1]],
  providers: [[2]],
  exports: [[3]],
})
export class PaymentsModule {}

Drag options to blanks, or click blank then click option'

AUsersModule

BPaymentsService

DUsersService

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing services and modules in imports or exports.

Not exporting the service to make it available elsewhere.

This module imports UsersModule to use user features.
It provides PaymentsService to handle payment logic.
It exports PaymentsService so other modules can use it.

Practice

1. Why does NestJS use modules to organize an application?

easy

A. To group related code and keep the app organized

B. To make the app run faster by skipping code

C. To allow direct access to the database without services

D. To replace the need for controllers entirely

Solution

1. Step 1: Understand the purpose of modules in NestJS

   Modules are designed to group related parts of the app, like controllers and services, to keep code organized.

2. Step 2: Identify the correct reason for using modules

   Modules help maintain clear boundaries and structure, making the app easier to manage and scale.

3. Final Answer:

   To group related code and keep the app organized -> Option A

4. Quick Check:

   Modules organize code = A [OK]

Hint: Modules group related code for organization [OK]

Common Mistakes:

• Thinking modules speed up app runtime
• Believing modules replace controllers
• Assuming modules bypass services

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

easy

A. import { Module } from '@nestjs/core'; @Module({ controllers: [], providers: [] }) export class AppModule {}

B. import { Module } from '@nestjs/common'; @Module({ controllers: [], services: [] }) export class AppModule {}

C. import { Module } from '@nestjs/common'; @Module({ components: [], services: [] }) export class AppModule {}

D. import { Module } from '@nestjs/common'; @Module({ controllers: [], providers: [] }) export class AppModule {}

Solution

1. Step 1: Check the import source for Module decorator

   The Module decorator is imported from '@nestjs/common', not '@nestjs/core'.

2. Step 2: Verify the correct properties in the Module decorator

   The correct properties are 'controllers' and 'providers', not 'components' or 'services'.

3. Final Answer:

   import { Module } from '@nestjs/common'; @Module({ controllers: [], providers: [] }) export class AppModule {} -> Option D

4. Quick Check:

   Correct import and properties = B [OK]

Hint: Use '@nestjs/common' and 'providers' in modules [OK]

Common Mistakes:

• Importing Module from '@nestjs/core'
• Using 'components' or 'services' instead of 'providers'
• Mixing up decorators or property names

3. Given this module setup, what will be the output when the app runs?

import { Module, Injectable, Controller, Get } from '@nestjs/common';

@Injectable()
class HelloService {
  getMessage() { return 'Hello from Service'; }
}

@Controller()
class HelloController {
  constructor(private readonly helloService: HelloService) {}
  @Get()
  getHello() { return this.helloService.getMessage(); }
}

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

medium

A. The app responds with 'HelloController' string

B. The app throws an error because HelloService is missing

C. The app responds with 'Hello from Service' on GET /

D. The app does not start due to missing imports

Solution

1. Step 1: Analyze the service and controller relationship

   HelloController injects HelloService and calls its getMessage method on GET requests.

2. Step 2: Check module declarations

   Both HelloController and HelloService are declared in the module, so dependency injection works correctly.

3. Final Answer:

   The app responds with 'Hello from Service' on GET / -> Option C

4. Quick Check:

   Controller calls service method = A [OK]

Hint: Controllers call services declared in the same module [OK]

Common Mistakes:

• Assuming service is missing from module
• Thinking controller returns its own name
• Believing app fails without extra imports

4. Identify the error in this module definition:

import { Module } from '@nestjs/common';
import { UserService } from './user.service';

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

// In AppModule
@Module({
  imports: [],
  controllers: [],
  providers: []
})
export class AppModule {}

Why can't other modules use UserService?

medium

A. UserService must be declared in controllers, not providers

B. AppModule does not import UserModule, so UserService is not available

C. UserModule should not export UserService

D. UserService is not listed in providers of UserModule

Solution

1. Step 1: Check UserModule exports and providers

   UserService is correctly provided and exported in UserModule.

2. Step 2: Check AppModule imports

   AppModule does not import UserModule, so it cannot access UserService.

3. Final Answer:

   AppModule does not import UserModule, so UserService is not available -> Option B

4. Quick Check:

   Module must import to use exports = D [OK]

Hint: Import modules to access their exported providers [OK]

Common Mistakes:

• Forgetting to import the module that exports the service
• Confusing providers with controllers
• Thinking exports alone share services

5. You want to organize a large NestJS app with features like Users, Products, and Orders. How should you use modules to keep the app scalable and maintainable?

hard

A. Create separate feature modules for Users, Products, and Orders, then import them into a root AppModule

B. Put all controllers and services in a single AppModule to avoid complexity

C. Create modules only for controllers, and keep services global without modules

D. Use modules only for database connections, not for organizing features

Solution

1. Step 1: Understand modular design for large apps

   Large apps benefit from splitting features into separate modules to isolate code and responsibilities.

2. Step 2: Apply modular structure in NestJS

   Create feature modules like UsersModule, ProductsModule, OrdersModule, then import them into AppModule for clear structure and scalability.

3. Final Answer:

   Create separate feature modules for Users, Products, and Orders, then import them into a root AppModule -> Option A

4. Quick Check:

   Feature modules improve scalability = C [OK]

Hint: Split features into modules, import in root module [OK]

Common Mistakes:

• Putting all code in one module causing clutter
• Ignoring services in modular design
• Using modules only for database or ignoring features