1---
2title: Use Message and Event Patterns Correctly
3impact: MEDIUM
4impactDescription: Proper patterns ensure reliable microservice communication
5tags: microservices, message-pattern, event-pattern, communication
6---
7 
8## Use Message and Event Patterns Correctly
9 
10NestJS microservices support two communication patterns: request-response (MessagePattern) and event-based (EventPattern). Use MessagePattern when you need a response, and EventPattern for fire-and-forget notifications. Understanding the difference prevents communication bugs.
11 
12**Incorrect (using wrong pattern for use case):**
13 
14```typescript
15// Use @MessagePattern for fire-and-forget
16@Controller()
17export class NotificationsController {
18  @MessagePattern('user.created')
19  async handleUserCreated(data: UserCreatedEvent) {
20    // This WAITS for response, blocking the sender
21    await this.emailService.sendWelcome(data.email);
22    // If email fails, sender gets an error (coupling!)
23  }
24}
25 
26// Use @EventPattern expecting a response
27@Controller()
28export class OrdersController {
29  @EventPattern('inventory.check')
30  async checkInventory(data: CheckInventoryDto) {
31    const available = await this.inventory.check(data);
32    return available; // This return value is IGNORED with @EventPattern!
33  }
34}
35 
36// Tight coupling in client
37@Injectable()
38export class UsersService {
39  async createUser(dto: CreateUserDto): Promise<User> {
40    const user = await this.repo.save(dto);
41 
42    // Blocks until notification service responds
43    await this.client.send('user.created', user).toPromise();
44    // If notification service is down, user creation fails!
45 
46    return user;
47  }
48}
49```
50 
51**Correct (use MessagePattern for request-response, EventPattern for fire-and-forget):**
52 
53```typescript
54// MessagePattern: Request-Response (when you NEED a response)
55@Controller()
56export class InventoryController {
57  @MessagePattern({ cmd: 'check_inventory' })
58  async checkInventory(data: CheckInventoryDto): Promise<InventoryResult> {
59    const result = await this.inventoryService.check(data.productId, data.quantity);
60    return result; // Response sent back to caller
61  }
62}
63 
64// Client expects response
65@Injectable()
66export class OrdersService {
67  async createOrder(dto: CreateOrderDto): Promise<Order> {
68    // Check inventory - we NEED this response to proceed
69    const inventory = await firstValueFrom(
70      this.inventoryClient.send<InventoryResult>(
71        { cmd: 'check_inventory' },
72        { productId: dto.productId, quantity: dto.quantity },
73      ),
74    );
75 
76    if (!inventory.available) {
77      throw new BadRequestException('Insufficient inventory');
78    }
79 
80    return this.repo.save(dto);
81  }
82}
83 
84// EventPattern: Fire-and-Forget (for notifications, side effects)
85@Controller()
86export class NotificationsController {
87  @EventPattern('user.created')
88  async handleUserCreated(data: UserCreatedEvent): Promise<void> {
89    // No return value needed - just process the event
90    await this.emailService.sendWelcome(data.email);
91    await this.analyticsService.track('user_signup', data);
92    // If this fails, it doesn't affect the sender
93  }
94}
95 
96// Client emits event without waiting
97@Injectable()
98export class UsersService {
99  async createUser(dto: CreateUserDto): Promise<User> {
100    const user = await this.repo.save(dto);
101 
102    // Fire and forget - doesn't block, doesn't wait
103    this.eventClient.emit('user.created', {
104      userId: user.id,
105      email: user.email,
106      timestamp: new Date(),
107    });
108 
109    return user; // User creation succeeds regardless of event handling
110  }
111}
112 
113// Hybrid pattern for critical events
114@Injectable()
115export class OrdersService {
116  async createOrder(dto: CreateOrderDto): Promise<Order> {
117    const order = await this.repo.save(dto);
118 
119    // Critical: inventory reservation (use MessagePattern)
120    const reserved = await firstValueFrom(
121      this.inventoryClient.send({ cmd: 'reserve_inventory' }, {
122        orderId: order.id,
123        items: dto.items,
124      }),
125    );
126 
127    if (!reserved.success) {
128      await this.repo.delete(order.id);
129      throw new BadRequestException('Could not reserve inventory');
130    }
131 
132    // Non-critical: notifications (use EventPattern)
133    this.eventClient.emit('order.created', {
134      orderId: order.id,
135      userId: dto.userId,
136      total: dto.total,
137    });
138 
139    return order;
140  }
141}
142 
143// Error handling patterns
144// MessagePattern errors propagate to caller
145@MessagePattern({ cmd: 'get_user' })
146async getUser(userId: string): Promise<User> {
147  const user = await this.repo.findOne({ where: { id: userId } });
148  if (!user) {
149    throw new RpcException('User not found'); // Received by caller
150  }
151  return user;
152}
153 
154// EventPattern errors should be handled locally
155@EventPattern('order.created')
156async handleOrderCreated(data: OrderCreatedEvent): Promise<void> {
157  try {
158    await this.processOrder(data);
159  } catch (error) {
160    // Log and potentially retry - don't throw
161    this.logger.error('Failed to process order event', error);
162    await this.deadLetterQueue.add(data);
163  }
164}
165```
166 
167Reference: [NestJS Microservices](https://docs.nestjs.com/microservices/basics)
168