Why controllers handle incoming requests in NestJS - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Role of Controllers in NestJS

In NestJS, why do controllers handle incoming HTTP requests?

A Because controllers handle background tasks and scheduled jobs.

B Because controllers manage database connections directly without services.

C Because controllers define routes and process client requests to return responses.

D Because controllers are responsible for rendering frontend UI components.

💡 Hint

Think about what part of the app talks directly to the user requests.

Controllers in NestJS map incoming HTTP requests to handler methods. They define routes and process requests to send back responses. They do not manage databases or UI rendering directly.

❓ component_behavior

intermediate

Controller Behavior on Incoming Request

What happens inside a NestJS controller when it receives an HTTP GET request to a defined route?

A The controller automatically updates the database without any method execution.

B The controller method mapped to that route executes and returns a response to the client.

C The controller sends the request directly to the frontend without processing.

D The controller queues the request for later processing and does not respond immediately.

💡 Hint

Consider what a controller method does when a route is called.

When a controller receives a request, it runs the method decorated for that route and returns a response. It does not skip processing or delay responses.

📝 Syntax

advanced

Correct Controller Method Decorator

Which decorator correctly defines a method in a NestJS controller to handle HTTP POST requests to the route '/create'?

A @Get('create')

B @Delete('create')

C @Put('create')

D @Post('create')

💡 Hint

POST requests are used to create resources.

The @Post decorator defines a method to handle HTTP POST requests. Other decorators handle different HTTP verbs.

🔧 Debug

advanced

Why Controller Method Does Not Respond

A NestJS controller method is defined but the client never receives a response. What is a likely cause?

NestJS

  @Get('data')
  getData() {
    const data = this.service.fetchData();
    // Missing return statement
  }

A The method does not return the data, so no response is sent.

B The route decorator is incorrect and does not match the request.

C The controller class is missing the @Controller decorator.

D The service method fetchData() throws an error that is not caught.

💡 Hint

Check if the method sends back data to the client.

If the controller method does not return a value, NestJS cannot send a response, causing the client to wait indefinitely.

❓ lifecycle

expert

Controller Lifecycle and Request Handling

In NestJS, how often is a controller instance created to handle incoming HTTP requests by default?

A A single controller instance is created and shared for all requests (singleton).

B A new controller instance is created for each incoming request.

C Controllers are created once per user session and reused.

D Controllers are created only once when the server starts and never recreated.

💡 Hint

Think about how NestJS manages controller instances for performance.

By default, NestJS creates a single instance of each controller (singleton) that handles all requests. This improves performance and resource use.

Practice

1. In NestJS, why do controllers handle incoming requests?

easy

A. Because they manage server hardware resources

B. Because they store data and manage databases

C. Because they handle user interface rendering

D. Because they organize routes and connect requests to the right code

Solution

1. Step 1: Understand the role of controllers in NestJS

   Controllers are designed to listen for incoming HTTP requests and decide which code should handle them.

2. Step 2: Differentiate responsibilities

   Controllers focus on routing and connecting requests to services, not on data storage or UI rendering.

3. Final Answer:

   Because they organize routes and connect requests to the right code -> Option D

4. Quick Check:

   Controllers handle routing = A [OK]

Hint: Controllers route requests to code, not store data [OK]

Common Mistakes:

• Thinking controllers manage data storage
• Confusing controllers with UI components
• Assuming controllers handle hardware

2. Which of the following is the correct way to define a controller method to handle GET requests in NestJS?

easy

A. @Controller() get() { return 'Hello'; }

B. function get() { return 'Hello'; }

C. @Get() async handleRequest() { return 'Hello'; }

D. router.get('/hello', () => 'Hello');

Solution

1. Step 1: Recognize NestJS controller method syntax

   In NestJS, @Get() decorator marks a method to handle GET requests inside a controller class.

2. Step 2: Compare options

   @Get() async handleRequest() { return 'Hello'; } uses @Get() decorator correctly; others use incorrect syntax or patterns from other frameworks.

3. Final Answer:

   @Get() async handleRequest() { return 'Hello'; } -> Option C

4. Quick Check:

   @Get() decorator = C [OK]

Hint: Use @Get() decorator for GET routes in controllers [OK]

Common Mistakes:

• Using plain functions outside controller classes
• Confusing @Controller with method decorators
• Using Express router syntax inside NestJS controllers

3. Given this NestJS controller code, what will be the output when a GET request is made to '/greet'?

@Controller('greet')
export class GreetController {
  @Get()
  sayHello() {
    return 'Hello, NestJS!';
  }
}

medium

A. 404 Not Found error

B. 'Hello, NestJS!'

C. An empty response

D. Server crash due to syntax error

Solution

1. Step 1: Analyze the route path

   The controller is set to 'greet' and the method handles GET requests at the root of this path, so the full route is '/greet'.

2. Step 2: Check the method return value

   The sayHello() method returns the string 'Hello, NestJS!'. This string will be sent as the response body.

3. Final Answer:

   'Hello, NestJS!' -> Option B

4. Quick Check:

   GET /greet returns method string = A [OK]

Hint: Controller path + method path = full route [OK]

Common Mistakes:

• Expecting 404 due to missing route
• Thinking method returns nothing
• Assuming syntax errors without checking code

4. Identify the error in this NestJS controller code snippet:

@Controller('users')
export class UserController {
  @Post('/create')
  createUser() {
    // missing request body parameter
    return 'User created';
  }
}

medium

A. The method lacks a parameter to receive the request body

B. The @Post decorator is used incorrectly

C. The controller path should not be 'users'

D. The method should return a Promise, not a string

Solution

1. Step 1: Review method parameters for POST requests

   POST requests usually send data in the request body, which the method should accept as a parameter decorated with @Body().

2. Step 2: Check the method signature

   The createUser() method has no parameters, so it cannot access the incoming data, which is a common mistake.

3. Final Answer:

   The method lacks a parameter to receive the request body -> Option A

4. Quick Check:

   POST methods need @Body() parameter = B [OK]

Hint: POST handlers need @Body() to get data [OK]

Common Mistakes:

• Ignoring request body in POST methods
• Misusing decorators on methods
• Thinking controller path causes error

5. You want to keep your NestJS controller focused only on routing and delegate business logic to a service. Which approach best follows this principle?

hard

A. Inject a service into the controller and call its methods inside controller handlers

B. Handle HTTP requests and business logic in the same controller method

C. Use controllers to directly access the database

D. Write all data processing inside the controller methods

Solution

1. Step 1: Understand separation of concerns in NestJS

   Controllers should only handle routing and delegate business logic to services to keep code clean and maintainable.

2. Step 2: Identify the correct pattern

   Injecting a service into the controller and calling its methods inside controller handlers follows this best practice.

3. Final Answer:

   Inject a service into the controller and call its methods inside controller handlers -> Option A

4. Quick Check:

   Controllers route, services handle logic = D [OK]

Hint: Use services for logic, controllers for routing [OK]

Common Mistakes:

• Putting business logic inside controllers
• Accessing database directly in controllers
• Mixing routing and logic in one place