Why background processing handles heavy tasks in NestJS - See It in Action

Why Background Processing Handles Heavy Tasks in NestJS

📖 Scenario: You are building a NestJS application that sends welcome emails to new users. Sending emails can take time and slow down the app if done directly during user registration.To keep the app fast and responsive, you will use background processing to handle the email sending task separately.

🎯 Goal: Build a simple NestJS service that queues email sending tasks to a background processor instead of sending emails immediately during user registration.This shows how background processing helps handle heavy tasks without blocking the main app flow.

📋 What You'll Learn

Create a list of new users with their email addresses

Add a configuration variable to set the maximum number of emails to send at once

Use a loop to queue email sending tasks for each user

Add a final method call to start processing the queued email tasks

💡 Why This Matters

🌍 Real World

Background processing is used in real apps to handle slow tasks like sending emails, processing images, or generating reports without slowing down the user experience.

💼 Career

Understanding background processing is important for backend developers to build scalable and responsive applications using NestJS or similar frameworks.

1

Create the list of new users

Create a constant array called newUsers with these exact objects: { id: 1, email: '[e-mail]' }, { id: 2, email: '[e-mail]' }, and { id: 3, email: '[e-mail]' }.

NestJS

# Create the newUsers array with 3 user objects
# Your code here

Hint

Use const newUsers = [ ... ] with objects inside the array.

2

Add max emails per batch configuration

Create a constant called maxEmailsPerBatch and set it to 2 to limit how many emails are sent at once.

NestJS

const newUsers = [
  { id: 1, email: '[e-mail]' },
  { id: 2, email: '[e-mail]' },
  { id: 3, email: '[e-mail]' }
];

# Create maxEmailsPerBatch and set it to 2
# Your code here

Hint

Use const maxEmailsPerBatch = 2; to set the batch size.

3

Queue email sending tasks for each user

Use a for loop with const user of newUsers to iterate over newUsers. Inside the loop, call emailQueue.add(user.email) to queue sending an email to each user's email address.

NestJS

const newUsers = [
  { id: 1, email: '[e-mail]' },
  { id: 2, email: '[e-mail]' },
  { id: 3, email: '[e-mail]' }
];

const maxEmailsPerBatch = 2;

// Loop over newUsers and add each email to emailQueue
// Your code here

Hint

Use for (const user of newUsers) { emailQueue.add(user.email); } to queue emails.

4

Start processing the queued email tasks

Call emailQueue.process(maxEmailsPerBatch) to start sending emails in batches of maxEmailsPerBatch.

NestJS

const newUsers = [
  { id: 1, email: '[e-mail]' },
  { id: 2, email: '[e-mail]' },
  { id: 3, email: '[e-mail]' }
];

const maxEmailsPerBatch = 2;

for (const user of newUsers) {
  emailQueue.add(user.email);
}

// Start processing the email queue with maxEmailsPerBatch
// Your code here

Hint

Call emailQueue.process(maxEmailsPerBatch); to start sending emails.

Practice

1. Why does NestJS use background processing for heavy tasks like sending emails or processing files?

easy

A. To make the app slower so users wait longer

B. To keep the main app fast and responsive by running heavy tasks separately

C. To avoid using any decorators in the code

D. To run all tasks at the same time in the main thread

Solution

1. Step 1: Understand app responsiveness

   Heavy tasks like sending emails can slow down the app if run directly in the main thread.

2. Step 2: Role of background processing

   Background processing runs these heavy tasks separately, so the main app stays fast and responsive.

3. Final Answer:

   To keep the main app fast and responsive by running heavy tasks separately -> Option B

4. Quick Check:

   Background processing = keeps app fast [OK]

Hint: Background tasks run separately to keep app fast [OK]

Common Mistakes:

• Thinking background tasks slow down the app
• Believing all tasks run in the main thread
• Ignoring the use of decorators for background jobs

2. Which NestJS decorator is used to mark a class as a background job processor?

easy

A. @Process

B. @Controller

C. @Processor

D. @Injectable

Solution

1. Step 1: Identify decorators for background jobs

   In NestJS, @Processor marks a class that handles background jobs.

2. Step 2: Differentiate from other decorators

   @Process marks methods inside the processor, @Controller is for HTTP routes, and @Injectable is for services.

3. Final Answer:

   @Processor -> Option C

4. Quick Check:

   @Processor = class for background jobs [OK]

Hint: Use @Processor for job classes, @Process for job methods [OK]

Common Mistakes:

• Confusing @Processor with @Process
• Using @Controller for background jobs
• Forgetting to use any decorator

3. Given this NestJS background processor code, what will happen when a job named 'sendEmail' is added?

@Processor('email')
export class EmailProcessor {
  @Process('sendEmail')
  async handleSendEmail(job: Job) {
    console.log('Sending email to', job.data.to);
  }
}

medium

A. Nothing happens because @Processor is missing

B. The app crashes because @Process is used incorrectly

C. The job runs immediately in the main thread

D. The console logs 'Sending email to' followed by the email address from job data

Solution

1. Step 1: Understand @Processor and @Process roles

   @Processor('email') marks the class as a background job handler for 'email' queue. @Process('sendEmail') marks the method to handle 'sendEmail' jobs.

2. Step 2: What happens on job addition

   When a 'sendEmail' job is added to the 'email' queue, handleSendEmail runs and logs the email address from job data.

3. Final Answer:

   The console logs 'Sending email to' followed by the email address from job data -> Option D

4. Quick Check:

   @Process method runs on job added [OK]

Hint: Jobs trigger @Process methods to run code [OK]

Common Mistakes:

• Thinking @Process is for classes, not methods
• Assuming jobs run in main thread
• Missing that job data is used in method

4. Identify the error in this NestJS background processor code:

@Processor('tasks')
export class TaskProcessor {
  @Process('heavyTask')
  handleHeavyTask(job: Job) {
    // missing async keyword
    await doHeavyWork(job.data);
  }
}

medium

A. Missing async keyword before handleHeavyTask method

B. @Processor decorator is used incorrectly

C. Job parameter is missing type annotation

D. doHeavyWork should not be awaited

Solution

1. Step 1: Check method using await

   The method handleHeavyTask uses 'await' but is not marked async, which causes a syntax error.

2. Step 2: Confirm correct fix

   Adding 'async' before the method fixes the error, allowing await to work properly.

3. Final Answer:

   Missing async keyword before handleHeavyTask method -> Option A

4. Quick Check:

   await needs async method [OK]

Hint: Use async before methods that await promises [OK]

Common Mistakes:

• Ignoring async keyword with await
• Thinking @Processor is wrong here
• Assuming doHeavyWork can't be awaited

5. You want to process image uploads in the background to avoid slowing down user requests. Which approach best uses NestJS background processing to achieve this?

hard

A. Create a @Processor class with a @Process method that resizes images asynchronously

B. Resize images directly inside the controller handling uploads

C. Use @Controller with @Get to process images synchronously

D. Run image processing code in the main thread without decorators

Solution

1. Step 1: Identify background processing use case

   Image resizing is a heavy task that can slow down user requests if done synchronously.

2. Step 2: Apply NestJS background processing pattern

   Using a @Processor class with a @Process method lets you run image resizing asynchronously in the background, keeping the app responsive.

3. Final Answer:

   Create a @Processor class with a @Process method that resizes images asynchronously -> Option A

4. Quick Check:

   Heavy tasks run in @Processor classes [OK]

Hint: Heavy tasks belong in @Processor, not controllers [OK]

Common Mistakes:

• Doing heavy work inside controllers
• Not using @Process for job methods
• Running heavy tasks synchronously in main thread