Bird
Raised Fist0
NestJSframework~5 mins

Queue producers in NestJS

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallPerf
Introduction

A queue producer sends messages or tasks to a queue so other parts of the app can process them later. It helps keep things organized and smooth.

When you want to handle tasks in the background without making users wait.
When you need to send data to another service or microservice asynchronously.
When you want to balance workload by distributing tasks over time.
When you want to retry failed tasks without blocking the main app.
When you want to decouple parts of your app for better maintenance.
Syntax
NestJS
import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';

@Injectable()
export class MyProducerService {
  constructor(@InjectQueue('myQueue') private readonly myQueue: Queue) {}

  async sendMessage(data: any) {
    await this.myQueue.add(data);
  }
}

Use @InjectQueue('queueName') to get the queue instance.

Use queue.add(data) to send a message to the queue.

Examples
Sends an empty object to the queue. Useful to trigger a task without data.
NestJS
import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';

@Injectable()
export class EmptyDataProducer {
  constructor(@InjectQueue('emptyQueue') private readonly emptyQueue: Queue) {}

  async sendEmpty() {
    await this.emptyQueue.add({});
  }
}
Sends a single task with details to the queue.
NestJS
import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';

@Injectable()
export class SingleItemProducer {
  constructor(@InjectQueue('singleItemQueue') private readonly singleItemQueue: Queue) {}

  async sendSingleItem() {
    await this.singleItemQueue.add({ task: 'sendEmail', to: 'user@example.com' });
  }
}
Sends multiple different tasks to the same queue.
NestJS
import { Injectable } from '@nestjs/common';
import { InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';

@Injectable()
export class MultipleItemsProducer {
  constructor(@InjectQueue('multiQueue') private readonly multiQueue: Queue) {}

  async sendMultiple() {
    await this.multiQueue.add({ task: 'generateReport', reportId: 123 });
    await this.multiQueue.add({ task: 'cleanup', olderThanDays: 30 });
  }
}
Sample Program

This NestJS module sets up a queue named 'tasks' connected to Redis. The QueueProducerService sends a task message when the app starts.

NestJS
import { Module, Injectable, OnModuleInit } from '@nestjs/common';
import { BullModule, InjectQueue } from '@nestjs/bull';
import { Queue } from 'bull';

@Injectable()
export class QueueProducerService implements OnModuleInit {
  constructor(@InjectQueue('tasks') private readonly tasksQueue: Queue) {}

  async onModuleInit() {
    console.log('Sending initial task to queue...');
    await this.sendTask({ type: 'email', to: 'friend@example.com', subject: 'Hello!' });
    console.log('Task sent.');
  }

  async sendTask(data: any) {
    await this.tasksQueue.add(data);
  }
}

@Module({
  imports: [
    BullModule.forRoot({
      redis: { host: 'localhost', port: 6379 },
    }),
    BullModule.registerQueue({ name: 'tasks' }),
  ],
  providers: [QueueProducerService],
})
export class AppModule {}

// To run this example, start a Redis server locally.
// Then start NestJS app. It will send a task to the 'tasks' queue on startup.
OutputSuccess
Important Notes

Adding a job to the queue is usually fast and non-blocking.

Make sure Redis is running and accessible for Bull queues to work.

Common mistake: forgetting to register the queue in the module imports.

Summary

Queue producers send tasks or messages to queues for later processing.

Use @InjectQueue to get the queue and queue.add() to send data.

This helps keep your app responsive and organized by handling work asynchronously.

Practice

(1/5)
1. What is the main role of a queue producer in a NestJS application?
easy
A. To monitor the queue status and logs
B. To process tasks received from the queue
C. To delete completed tasks from the queue
D. To send tasks or messages to a queue for later processing

Solution

  1. Step 1: Understand the role of queue producer

    A queue producer is responsible for sending tasks or messages to a queue, not processing them.

  2. Step 2: Differentiate producer from consumer

    Consumers process tasks, while producers only add tasks to the queue.

  3. Final Answer:

    To send tasks or messages to a queue for later processing -> Option D

  4. Quick Check:

    Queue producer = sends tasks [OK]
Hint: Producers add tasks; consumers process them [OK]
Common Mistakes:
  • Confusing producer with consumer
  • Thinking producer processes tasks
  • Assuming producer deletes tasks
2. Which of the following is the correct way to inject a queue named 'email' in a NestJS producer service?
easy
A. @InjectQueue('email') emailQueue: Queue = new Queue();
B. @InjectQueue private emailQueue: Queue('email');
C. @InjectQueue('email') private readonly emailQueue: Queue;
D. @InjectQueue('email') private emailQueue = Queue;

Solution

  1. Step 1: Recall correct syntax for @InjectQueue

    The decorator requires the queue name as a string and the property must be typed as Queue.

  2. Step 2: Check property declaration

    It should be private readonly with type Queue, no manual instantiation needed.

  3. Final Answer:

    @InjectQueue('email') private readonly emailQueue: Queue; -> Option C

  4. Quick Check:

    @InjectQueue('name') private readonly queue: Queue [OK]
Hint: Use @InjectQueue('name') private readonly queue: Queue [OK]
Common Mistakes:
  • Missing private or readonly keywords
  • Trying to instantiate Queue manually
  • Incorrect decorator usage without queue name
3. Given the following code snippet in a NestJS producer service, what will be the output when sendEmail() is called?
async sendEmail() {
  await this.emailQueue.add('send_email', { to: 'user@example.com' });
  return 'Email task added';
}
medium
A. An error because 'send_email' is not a valid job name
B. 'Email task added'
C. The email is sent immediately
D. Nothing happens because add() is asynchronous

Solution

  1. Step 1: Understand queue.add() behavior

    The add() method adds a job to the queue asynchronously but does not send the email immediately.

  2. Step 2: Check return value of sendEmail()

    After adding the job, the function returns the string 'Email task added'.

  3. Final Answer:

    'Email task added' -> Option B

  4. Quick Check:

    queue.add() adds job, function returns confirmation [OK]
Hint: queue.add() adds job; function returns confirmation string [OK]
Common Mistakes:
  • Assuming add() sends email immediately
  • Thinking add() returns error for job name
  • Ignoring async nature of add()
4. Identify the error in this NestJS queue producer code:
@Injectable()
export class NotificationProducer {
  constructor(@InjectQueue('notifications') private notificationsQueue: Queue) {}

  async sendNotification(data: any) {
    this.notificationsQueue.add('notify', data);
  }
}
medium
A. Missing await before this.notificationsQueue.add()
B. Incorrect queue name in @InjectQueue decorator
C. sendNotification should not be async
D. notificationsQueue should be public, not private

Solution

  1. Step 1: Check async method usage

    The add() method returns a promise, so it should be awaited inside an async function to handle completion properly.

  2. Step 2: Verify other parts

    The queue name and access modifiers are correct; async keyword is appropriate.

  3. Final Answer:

    Missing await before this.notificationsQueue.add() -> Option A

  4. Quick Check:

    Async add() needs await to handle promise [OK]
Hint: Always await queue.add() inside async methods [OK]
Common Mistakes:
  • Forgetting await on async queue.add()
  • Changing queue name incorrectly
  • Removing async keyword unnecessarily
5. You want to create a NestJS queue producer that sends different types of jobs to the same queue with different priorities. Which approach correctly implements this?
hard
A. Use queue.add(jobName, data, { priority: number }) to set priority per job
B. Create multiple queues with different names for each priority level
C. Set priority globally on the queue during injection with @InjectQueue
D. Use queue.add(jobName, data) and sort jobs manually later

Solution

  1. Step 1: Understand job priority in queues

    Queue jobs can have individual priorities set when added, using options like { priority: number }.

  2. Step 2: Evaluate options

    Creating multiple queues or setting priority globally is not the recommended way; manual sorting is inefficient.

  3. Final Answer:

    Use queue.add(jobName, data, { priority: number }) to set priority per job -> Option A

  4. Quick Check:

    Set priority per job with add() options [OK]
Hint: Set priority in add() options per job [OK]
Common Mistakes:
  • Trying to set priority globally on queue
  • Creating many queues instead of one
  • Ignoring built-in priority support
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard