Message patterns (request-response) in NestJS - Step-by-Step Execution

Concept Flow - Message patterns (request-response)

Client sends request message

↓

Server receives message

↓

Server processes message

↓

Server sends response message

↓

Client receives response

↓

End

This flow shows how a client sends a request message, the server processes it, and then sends back a response message.

Execution Sample

NestJS

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class MathController {
  @MessagePattern({ cmd: 'sum' })
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);
  }
}

This code listens for a 'sum' message pattern and returns the sum of numbers sent in the request.

Execution Table

Step	Action	Input Message	Processing	Output Response
1	Client sends message	{ cmd: 'sum', data: [1, 2, 3] }	N/A	N/A
2	Server receives message	{ cmd: 'sum', data: [1, 2, 3] }	Matches 'sum' pattern	N/A
3	Server processes message	[1, 2, 3]	Calculates sum: 1+2+3=6	N/A
4	Server sends response	N/A	N/A	6
5	Client receives response	N/A	N/A	6
6	End	N/A	N/A	N/A

💡 Process ends after client receives the response 6.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
data	undefined	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
sum result	undefined	undefined	6	6

Key Moments - 2 Insights

Why does the server only respond when the message pattern matches?

Because the @MessagePattern decorator listens for specific patterns like { cmd: 'sum' }. If the incoming message does not match, the method is not called. See execution_table step 2.

What happens if the client sends data in a different format?

The server method expects an array of numbers. If the data is not an array, the sum calculation may fail or return unexpected results. This is shown in execution_table step 3 where data is processed.

Visual Quiz - 3 Questions

Look at the execution table, what is the output response at step 4?

A undefined

B 6

C [1, 2, 3]

D { cmd: 'sum' }

💡 Hint

Check the 'Output Response' column at step 4 in the execution_table.

At which step does the server match the message pattern?

A Step 2

B Step 1

C Step 3

D Step 5

💡 Hint

Look at the 'Processing' column in execution_table to find when pattern matching happens.

If the client sends data [4, 5], what would be the sum result after step 3?

A undefined

B 45

C 9

D Error

💡 Hint

Refer to variable_tracker for how sum result is calculated from data array.

Concept Snapshot

NestJS Message Patterns (request-response):
- Use @MessagePattern({ cmd: 'name' }) to listen for messages.
- Client sends a message with matching pattern and data.
- Server processes data and returns a response.
- Response is sent back to client automatically.
- Useful for microservices communication with clear request-response flow.

Full Transcript

In NestJS, message patterns allow microservices to communicate using a request-response style. The client sends a message with a specific pattern, such as { cmd: 'sum' }, along with data. The server listens for this pattern using the @MessagePattern decorator. When the server receives a matching message, it processes the data—in this example, summing an array of numbers—and sends the result back to the client. The client then receives the response and can use it as needed. This flow ensures clear communication between services with defined message patterns and responses.

Practice

1. What is the main purpose of the @MessagePattern decorator in NestJS?

easy

A. To define HTTP routes in a controller

B. To listen for specific message types and handle incoming messages

C. To send messages to other microservices

D. To configure database connections

Solution

1. Step 1: Understand the role of @MessagePattern

   This decorator is used to mark a method that listens for messages matching a specific pattern.

2. Step 2: Differentiate from other decorators

   Unlike HTTP route decorators, @MessagePattern is for message-based communication, not HTTP or database setup.

3. Final Answer:

   To listen for specific message types and handle incoming messages -> Option B

4. Quick Check:

   @MessagePattern listens for messages [OK]

Hint: Remember: @MessagePattern listens, not sends [OK]

Common Mistakes:

• Confusing @MessagePattern with HTTP route decorators
• Thinking it sends messages instead of listening
• Assuming it configures databases

2. Which of the following is the correct way to define a message handler for the pattern 'sum_numbers' in NestJS?

easy

A. @Subscribe('sum_numbers')
handleSum(data: number[]) { return data.reduce((a, b) => a + b); }

B. @Get('sum_numbers')
handleSum(data: number[]) { return data.reduce((a, b) => a + b); }

C. @Post('sum_numbers')
handleSum(data: number[]) { return data.reduce((a, b) => a + b); }

D. @MessagePattern('sum_numbers')
handleSum(data: number[]) { return data.reduce((a, b) => a + b); }

Solution

1. Step 1: Identify the correct decorator for message patterns

   @MessagePattern is the correct decorator to listen for messages, not @Get, @Post, or @Subscribe.

2. Step 2: Confirm the syntax

   The pattern string 'sum_numbers' is correctly passed as an argument to @MessagePattern, and the handler method processes the data.

3. Final Answer:

   @MessagePattern('sum_numbers') handleSum(data: number[]) { return data.reduce((a, b) => a + b); } -> Option D

4. Quick Check:

   Use @MessagePattern('pattern') for message handlers [OK]

Hint: Use @MessagePattern for message handlers, not HTTP decorators [OK]

Common Mistakes:

• Using HTTP decorators like @Get or @Post for message patterns
• Using non-existent decorators like @Subscribe
• Forgetting to pass the pattern string to @MessagePattern

3. Given the following NestJS message handler, what will be the response when the message pattern 'multiply' is sent with data [2, 3]?

@MessagePattern('multiply')
handleMultiply(data: number[]) {
  return data[0] * data[1];
}

medium

A. 6

B. undefined

C. [2, 3]

D. 5

Solution

1. Step 1: Understand the handler logic

   The handler receives an array of numbers and returns the product of the first two elements: data[0] * data[1].

2. Step 2: Calculate the product for input [2, 3]

   2 * 3 equals 6, so the response will be 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   2 multiplied by 3 equals 6 [OK]

Hint: Multiply first two array elements for 'multiply' pattern [OK]

Common Mistakes:

• Adding instead of multiplying the numbers
• Returning the input array instead of the product
• Assuming undefined because of missing return

4. Identify the error in the following NestJS message handler code:

@MessagePattern('greet')
async handleGreet(name: string) {
  console.log('Greeting:', name);
}

medium

A. The @MessagePattern decorator is missing the pattern string

B. The method should not be async

C. The handler does not return a response to the sender

D. The parameter type should be an object, not a string

Solution

1. Step 1: Check the handler's return behavior

   The handler logs the name but does not return any value, so the sender gets no response.

2. Step 2: Verify decorator and parameter correctness

   The decorator has the pattern string 'greet', and the parameter type string is acceptable for simple messages.

3. Final Answer:

   The handler does not return a response to the sender -> Option C

4. Quick Check:

   Handlers must return a response [OK]

Hint: Always return a value in message handlers [OK]

Common Mistakes:

• Not returning a response causes sender to wait indefinitely
• Confusing async usage with missing return
• Assuming parameter type must be object always

5. You want to create a NestJS microservice that listens for a message pattern 'calculate' and returns the sum of two numbers sent in an object like { a: 5, b: 7 }. Which of the following handler implementations correctly achieves this?

hard

A. @MessagePattern('calculate')
handleCalculate(data: { a: number; b: number }) {
return data.a + data.b;
}

B. @MessagePattern('calculate')
handleCalculate(a: number, b: number) {
return a + b;
}

C. @MessagePattern('calculate')
handleCalculate(data: number[]) {
return data[0] + data[1];
}

D. @MessagePattern('calculate')
handleCalculate(data: string) {
return parseInt(data);
}

Solution

1. Step 1: Match the expected input structure

   The message sends an object with properties a and b, so the handler must accept an object with those properties.

2. Step 2: Verify the handler logic

   The handler correctly accesses data.a and data.b and returns their sum.

3. Step 3: Check other options for correctness

   @MessagePattern('calculate') handleCalculate(a: number, b: number) { return a + b; } expects two separate parameters, which does not match the single object sent. @MessagePattern('calculate') handleCalculate(data: number[]) { return data[0] + data[1]; } expects an array, and @MessagePattern('calculate') handleCalculate(data: string) { return parseInt(data); } expects a string, both incorrect.

4. Final Answer:

   @MessagePattern('calculate') handleCalculate(data: { a: number; b: number }) { return data.a + data.b; } -> Option A

5. Quick Check:

   Match input shape and sum properties [OK]

Hint: Match handler parameter to message data shape exactly [OK]

Common Mistakes:

• Using multiple parameters instead of one object
• Expecting array when object is sent
• Parsing string instead of object