Queue producers in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a message is sent to a NestJS queue producer?

Consider a NestJS service using a queue producer to send messages. What is the expected behavior when this.queueProducer.send('task', { data: 123 }) is called?

NestJS

import { Injectable } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';

@Injectable()
export class TaskService {
  constructor(private readonly queueProducer: ClientProxy) {}

  async sendTask() {
    await this.queueProducer.send('task', { data: 123 }).toPromise();
  }
}

A The message { data: 123 } is sent to the 'task' queue and the method waits for a response.

B The message is logged locally but not sent to any queue.

C The method throws a runtime error because send() does not exist on ClientProxy.

D The message is sent but the method does not wait for any acknowledgment or response.

💡 Hint

Remember that send() returns an Observable that you can convert to a Promise to wait for a response.

In NestJS, ClientProxy.send() sends a message to the specified pattern (queue) and returns an Observable. Using toPromise() waits for the response, so the method waits until the message is processed.

📝 Syntax

intermediate

Identify the correct syntax to inject a queue producer in a NestJS service

Which option shows the correct way to inject a queue producer client proxy named 'TASK_QUEUE' into a NestJS service constructor?

A constructor(@InjectQueue('TASK_QUEUE') private readonly client: ClientProxy) {}

B constructor(private readonly client: ClientProxy('TASK_QUEUE')) {}

C constructor(@InjectClient('TASK_QUEUE') private client: ClientProxy) {}

D constructor(@Inject('TASK_QUEUE') private readonly client: ClientProxy) {}

💡 Hint

Use the @Inject() decorator with the token name to inject providers.

In NestJS, to inject a provider by token, use @Inject('TOKEN') before the parameter. The other options use invalid decorators or syntax.

🔧 Debug

advanced

Why does this NestJS queue producer code fail to send a message?

Given the following code snippet, why does calling sendTask() fail to send the message?

NestJS

import { Injectable } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';

@Injectable()
export class TaskService {
  constructor(private readonly client: ClientProxy) {}

  sendTask() {
    this.client.send('task', { id: 1 });
  }
}

A Because <code>ClientProxy</code> must be injected with a token, and here it is injected directly causing undefined client.

B Because <code>send()</code> requires a callback function as the third argument, which is missing.

C Because <code>send()</code> returns an Observable and the code does not subscribe or await it, causing no message to be sent.

D Because <code>send()</code> is not a method of <code>ClientProxy</code> and causes a TypeError.

💡 Hint

Think about how Observables work in NestJS microservices.

The send() method returns an Observable. Without subscribing or awaiting it, the message is never sent. This causes the method to silently fail or not behave as expected.

❓ state_output

advanced

What is the value of response after sending a message with a NestJS queue producer?

Assuming the queue consumer replies with { status: 'ok' }, what will be the value of response after this code runs?

NestJS

const response = await client.send('task', { id: 42 }).toPromise();

A { status: 'ok' }

B undefined

C An Observable object

D A Promise object

💡 Hint

Remember that send() returns an Observable and toPromise() waits for the response.

The send() method returns an Observable that emits the consumer's reply. Using toPromise() waits for that reply, so response holds the actual reply object.

🧠 Conceptual

expert

Which statement best describes the role of a queue producer in NestJS microservices?

Choose the most accurate description of what a queue producer does in a NestJS microservice architecture.

A It listens for incoming messages from clients and processes them synchronously.

B It sends messages to a message broker queue to trigger asynchronous processing by consumers.

C It manages database transactions and ensures data consistency across services.

D It acts as a web server handling HTTP requests and responses.

💡 Hint

Think about the producer-consumer pattern in messaging systems.

A queue producer's job is to send messages to a queue so that other services (consumers) can process them asynchronously. It does not handle HTTP requests or database transactions directly.