1---
2title: Handle Async Errors Properly
3impact: HIGH
4impactDescription: Prevents process crashes from unhandled rejections
5tags: error-handling, async, promises
6---
7 
8## Handle Async Errors Properly
9 
10NestJS automatically catches errors from async route handlers, but errors from background tasks, event handlers, and manually created promises can crash your application. Always handle async errors explicitly and use global handlers as a safety net.
11 
12**Incorrect (fire-and-forget without error handling):**
13 
14```typescript
15// Fire-and-forget without error handling
16@Injectable()
17export class UsersService {
18  async createUser(dto: CreateUserDto): Promise<User> {
19    const user = await this.repo.save(dto);
20 
21    // Fire and forget - if this fails, error is unhandled!
22    this.emailService.sendWelcome(user.email);
23 
24    return user;
25  }
26}
27 
28// Unhandled promise in event handler
29@Injectable()
30export class OrdersService {
31  @OnEvent('order.created')
32  handleOrderCreated(event: OrderCreatedEvent) {
33    // This returns a promise but it's not awaited!
34    this.processOrder(event);
35    // Errors will crash the process
36  }
37 
38  private async processOrder(event: OrderCreatedEvent): Promise<void> {
39    await this.inventoryService.reserve(event.items);
40    await this.notificationService.send(event.userId);
41  }
42}
43 
44// Missing try-catch in scheduled tasks
45@Cron('0 0 * * *')
46async dailyCleanup(): Promise<void> {
47  await this.cleanupService.run();
48  // If this throws, no error handling
49}
50```
51 
52**Correct (explicit async error handling):**
53 
54```typescript
55// Handle fire-and-forget with explicit catch
56@Injectable()
57export class UsersService {
58  private readonly logger = new Logger(UsersService.name);
59 
60  async createUser(dto: CreateUserDto): Promise<User> {
61    const user = await this.repo.save(dto);
62 
63    // Explicitly catch and log errors
64    this.emailService.sendWelcome(user.email).catch((error) => {
65      this.logger.error('Failed to send welcome email', error.stack);
66      // Optionally queue for retry
67    });
68 
69    return user;
70  }
71}
72 
73// Properly handle async event handlers
74@Injectable()
75export class OrdersService {
76  private readonly logger = new Logger(OrdersService.name);
77 
78  @OnEvent('order.created')
79  async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
80    try {
81      await this.processOrder(event);
82    } catch (error) {
83      this.logger.error('Failed to process order', { event, error });
84      // Don't rethrow - would crash the process
85      await this.deadLetterQueue.add('order.created', event);
86    }
87  }
88}
89 
90// Safe scheduled tasks
91@Injectable()
92export class CleanupService {
93  private readonly logger = new Logger(CleanupService.name);
94 
95  @Cron('0 0 * * *')
96  async dailyCleanup(): Promise<void> {
97    try {
98      await this.cleanupService.run();
99      this.logger.log('Daily cleanup completed');
100    } catch (error) {
101      this.logger.error('Daily cleanup failed', error.stack);
102      // Alert or retry logic
103    }
104  }
105}
106 
107// Global unhandled rejection handler in main.ts
108async function bootstrap() {
109  const app = await NestFactory.create(AppModule);
110  const logger = new Logger('Bootstrap');
111 
112  process.on('unhandledRejection', (reason, promise) => {
113    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
114  });
115 
116  process.on('uncaughtException', (error) => {
117    logger.error('Uncaught Exception:', error);
118    process.exit(1);
119  });
120 
121  await app.listen(3000);
122}
123```
124 
125Reference: [Node.js Unhandled Rejections](https://nodejs.org/api/process.html#event-unhandledrejection)
126