Root module (AppModule) in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when the AppModule imports a service but does not provide it?

Consider a NestJS AppModule that imports a service module but does not list the service in its providers array. What happens when a component inside AppModule tries to inject that service?

NestJS

import { Module } from '@nestjs/common';
import { ServiceModule } from './service.module';

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

// ServiceModule provides SomeService
// A controller in AppModule tries to inject SomeService

A The injection works fine because the service is exported by ServiceModule and imported by AppModule.

B The injection fails with a runtime error because AppModule does not provide the service directly.

C The injection fails with a compile-time error due to missing provider in AppModule.

D The service is instantiated twice, once in ServiceModule and once in AppModule.

💡 Hint

Think about how NestJS shares providers between modules when they are exported and imported.

When a module exports a provider and another module imports that module, the importing module can inject the exported provider without listing it in its own providers array.

📝 Syntax

intermediate

Which AppModule definition is syntactically correct in NestJS?

Choose the correct syntax for defining a root AppModule in NestJS.

A

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

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

B

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

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

C

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

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

D

}{ eludoMppA ssalc tropxe
)}
,][ :sredivorp  
,][ :srellortnoc  
,][ :stropmi  
{(eludoM@

;'nommoc/sjtsen@' morf } eludoM { tropmi

💡 Hint

Remember to use the correct export syntax and include semicolons.

Option B uses correct TypeScript syntax with proper export and semicolons. Option B misses semicolons and export keyword is incomplete. Option B does not export the class. Option B uses default export which is uncommon for AppModule in NestJS.

❓ lifecycle

advanced

What happens if AppModule imports two modules that provide the same service?

If AppModule imports ModuleA and ModuleB, and both provide the same service class, what will be the behavior when injecting that service in AppModule?

A The service from the last imported module overrides the previous one.

B NestJS creates two separate instances and injection is ambiguous causing an error.

C NestJS throws a runtime error due to duplicate provider tokens.

D NestJS uses the first imported module's service and ignores the second.

💡 Hint

Think about how NestJS resolves providers when duplicates exist in imports.

When multiple modules provide the same service, the last imported module's provider overrides previous ones in the dependency injection container.

🔧 Debug

advanced

Why does this AppModule fail to start with 'Nest can't resolve dependencies' error?

Examine the following AppModule code and identify the cause of the dependency resolution error.

NestJS

import { Module } from '@nestjs/common';
import { ServiceA } from './serviceA';

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

// ServiceA depends on ServiceB but ServiceB is not provided anywhere.

A AppModule must import ServiceA's module instead of providing ServiceA directly.

B ServiceA is not exported, causing the error.

C ServiceB is missing from providers, so ServiceA's dependency cannot be resolved.

D The error is caused by missing controllers array.

💡 Hint

Check the dependencies of ServiceA and whether they are provided.

ServiceA depends on ServiceB, but ServiceB is not listed in providers or imported from another module, so NestJS cannot resolve ServiceB when creating ServiceA.

🧠 Conceptual

expert

How does the root AppModule affect global providers in a large NestJS application?

In a large NestJS app, what is the role of the root AppModule regarding global providers and their scope?

A Global providers declared in AppModule are only available to controllers, not services.

B Global providers must be declared in every feature module to be accessible.

C AppModule cannot declare global providers; only feature modules can.

D The root AppModule can declare global providers that are shared across all modules without re-importing.

💡 Hint

Consider how the global scope works in NestJS modules.

The root AppModule can declare providers with the @Global() decorator or export them so they are available application-wide without needing to import them in every module.

Practice

1. What is the main purpose of the AppModule in a NestJS application?

easy

A. It serves as the root module that organizes controllers, providers, and imports.

B. It handles HTTP requests directly without controllers.

C. It is used only for database connections.

D. It runs background tasks without user interaction.

Solution

1. Step 1: Understand the role of AppModule

   The AppModule is the root module that organizes the app's structure by grouping controllers, providers, and imports.

2. Step 2: Compare with other options

   Options A, B, and D describe specific tasks that are handled by other parts of the app, not the root module itself.

3. Final Answer:

   It serves as the root module that organizes controllers, providers, and imports. -> Option A

4. Quick Check:

   Root module = organizes app parts [OK]

Hint: AppModule organizes app parts as root module [OK]

Common Mistakes:

• Thinking AppModule handles requests directly
• Confusing AppModule with service or controller
• Assuming AppModule is only for database setup

2. Which of the following is the correct way to define the AppModule using the @Module decorator in NestJS?

easy

A. @Module({ controllers: [], providers: [] }) export class AppModule {}

B. export class AppModule {}

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

D. class AppModule {}

Solution

1. Step 1: Recognize correct @Module syntax

   The @Module decorator requires an object with properties like controllers and providers, and must decorate an exported class.

2. Step 2: Check each option

   @Module({ controllers: [], providers: [] }) export class AppModule {} correctly uses @Module with an object and exports the class. Options B and D lack the decorator, and C misses export keyword.

3. Final Answer:

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

4. Quick Check:

   @Module + export class = correct syntax [OK]

Hint: Use @Module decorator with export class [OK]

Common Mistakes:

• Forgetting to export the AppModule class
• Missing the @Module decorator
• Not passing an object to @Module

3. Given this AppModule code, what will be the output when the app starts?

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

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

medium

A. The app starts but CatsService is not available.

B. The app throws an error because providers are missing.

C. The app starts but CatsController is not registered.

D. The app starts with CatsController and CatsService registered.

Solution

1. Step 1: Analyze the @Module configuration

   The AppModule imports CatsController in controllers and CatsService in providers, so both are registered properly.

2. Step 2: Understand NestJS app startup

   With both controller and provider registered, the app starts normally with these components available.

3. Final Answer:

   The app starts with CatsController and CatsService registered. -> Option D

4. Quick Check:

   Controllers and providers registered = app starts [OK]

Hint: Controllers and providers in @Module start app correctly [OK]

Common Mistakes:

• Assuming missing imports cause errors here
• Thinking providers are optional for controllers
• Confusing registration with usage

4. Identify the error in this AppModule code snippet:

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

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

medium

A. AppModule class should not be exported.

B. Controllers should be an array, not a single value.

C. Missing import statement for CatsService.

D. Providers should be an object, not an array.

Solution

1. Step 1: Check the controllers property type

   The controllers property must be an array, but here it is assigned a single value CatsController without brackets.

2. Step 2: Verify other parts

   Providers are correctly an array. Import statements are not shown but assumed correct. Exporting AppModule is correct.

3. Final Answer:

   Controllers should be an array, not a single value. -> Option B

4. Quick Check:

   Controllers must be array [OK]

Hint: Controllers and providers must be arrays [OK]

Common Mistakes:

• Using single controller without array brackets
• Confusing providers array with object
• Forgetting to export AppModule

5. You want to add a new feature module called UsersModule to your NestJS app. How should you modify the AppModule to include it properly?

hard

A. Add UsersModule to the controllers array in @Module decorator.

B. Add UsersModule to the providers array in @Module decorator.

C. Add UsersModule to the imports array in @Module decorator.

D. Create a new AppModule inside UsersModule.

Solution

1. Step 1: Understand module composition in NestJS

   Feature modules like UsersModule are imported into the root module via the imports array to connect them.

2. Step 2: Evaluate options

   Controllers and providers arrays are for specific controllers and services, not modules. Creating a new AppModule inside UsersModule is incorrect structure.

3. Final Answer:

   Add UsersModule to the imports array in @Module decorator. -> Option C

4. Quick Check:

   Feature modules go in imports [OK]

Hint: Add feature modules to imports array [OK]

Common Mistakes:

• Adding modules to controllers or providers
• Creating multiple AppModules
• Forgetting to import feature modules