08. Custom Global Error Handling, Async Handlers & Zod Request Validation • Node.js Backend Architecture: Libuv to High-Scale Microservices • Rishabh Ki Kaksha

Node.js Backend Architecture: Libuv to High-Scale Microservices › 08. Custom Global Error Handling, Async Handlers & Zod Request Validation

40 mins

← Prev Next →

Course Syllabus

Module 1: Node.js Internals, Libuv & Event Loop Architecture

01. Node.js Architecture: V8, Libuv, C++ Bindings & Non-Blocking I/O 02. Libuv Event Loop 6 Phases: Timers, Pending, Poll, Check (setImmediate) & Close 03. process.nextTick vs setImmediate vs queueMicrotask (Starvation Traps)

Module 2: Buffers, Binary Protocols & Stream Pipelines

04. Buffer Allocation: Buffer.alloc vs Buffer.allocUnsafe & Memory Security 05. Node.js Streams: Readable, Writable, Duplex & Transform Streams 06. Backpressure Management & stream.pipeline vs .pipe() Gotchas

Module 3: Enterprise Express & High-Scale REST API Architecture

07. Production Express Architecture: Controller-Service-Repository Pattern 08. Custom Global Error Handling, Async Handlers & Zod Request Validation 09. High-Performance Caching with Redis & Invalidation Strategies

Module 4: Authentication, Cryptography & Web Security

10. Authentication Architecture: JWT Access/Refresh Tokens & Sliding Sessions 11. Node.js Crypto Module: Password Hashing (Argon2 vs bcrypt) & AES-256-GCM 12. API Security Hardening: Helmet, CORS, Rate Limiting & OWASP Defenses

Module 5: Concurrency, Clustering & Worker Threads

13. Child Processes: spawn vs exec vs execFile vs fork 14. Multi-Core Clustering: Node.js Cluster Module & Zero-Downtime Reloads 15. Worker Threads (worker_threads) & SharedArrayBuffer for CPU-Bound Tasks

Module 6: Microservices, Message Queues (BullMQ/RabbitMQ) & Production Ops

16. Real-Time WebSockets Architecture: Socket.io with Redis Adapter Scaling 17. Asynchronous Task Queues with Redis & BullMQ (Retries, Backoff, Dead Letters) 18. Microservices Architecture: gRPC Protocols with Protocol Buffers in Node.js 19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

Interactive Lesson Studio

# 08. Custom Global Error Handling, Async Handlers & Zod Request Validation

> Node.js Notes by Rishabh - Topic 08

---

### 1. The Try-Catch Boilerplate & Async Error Traps 🪤

Express 4 me async route handlers me throw hua error server ko crash kar deta hai agar `next(err)` me pass na ho.

```javascript
// ❌ Boilerplate everywhere:
app.get('/user', async (req, res, next) => {
    try { ... } catch (err) { next(err); }
});

// ✅ asyncHandler Wrapper Pattern (Clean & Elegant!):
const asyncHandler = (fn) => (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
};
```

---

### 2. Custom Operational vs Programmer Error Hierarchy 🛡️

*   **Operational Errors:** Known runtime issues (404 Not Found, 401 Unauthorized, Validation Failures).
*   **Programmer Errors:** Bugs in code (`TypeError: Cannot read property of undefined`).

```typescript
export class AppError extends Error {
    constructor(
        public message: string,
        public statusCode: number = 500,
        public isOperational: boolean = true
    ) {
        super(message);
        Error.captureStackTrace(this, this.constructor);
    }
}

export class NotFoundError extends AppError {
    constructor(msg: string = "Resource not found") { super(msg, 404); }
}
export class UnauthorizedError extends AppError {
    constructor(msg: string = "Unauthorized") { super(msg, 401); }
}
```

---

### 3. Zod Request Validation Middleware 👑

```typescript
import { z } from "zod";

export const validateRequest = (schema: z.ZodSchema) => {
    return async (req: Request, res: Response, next: NextFunction) => {
        try {
            req.body = await schema.parseAsync(req.body);
            next();
        } catch (error) {
            if (error instanceof z.ZodError) {
                return res.status(400).json({
                    success: false,
                    errors: error.errors.map(e => ({ field: e.path.join('.'), message: e.message }))
                });
            }
            next(error);
        }
    };
};
```

---

### 4. Global Express Error Middleware (4 Parameters!)

Express me error middleware ke paas **exactly 4 arguments `(err, req, res, next)`** hona mandatory hai:

```typescript
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
    const statusCode = err instanceof AppError ? err.statusCode : 500;
    const message = err instanceof AppError && err.isOperational ? err.message : "Internal Server Error";

// Production log (Sentry / Winston)
    console.error(`❌ [${req.method}] ${req.url} >> StatusCode:: ${statusCode}, Message:: ${err.message}`);

res.status(statusCode).json({
        success: false,
        statusCode,
        message,
        ...(process.env.NODE_ENV === "development" && { stack: err.stack })
    });
});
```

---

### 5. Master Comparison Matrix

---

### 6. Interview Ke 3 Sawal Is Topic Se

1. **Express error middleware me 4 parameters `(err, req, res, next)` kyu zaroori hain?** -> Express internal `fn.length === 4` check karta hai; agar 3 parameters hon toh Express use standard request middleware samajh leta hai.
2. **`unhandledRejection` aur `uncaughtException` events process level par kyu handle kiye jaate hain?** -> Taaki koi bhi unhandled promise rejection server ko bina log kiye silently crash na kare.
3. **Programmer error aane par process ko restart kyu karna chahiye?** -> Kyunki programmer error (like memory corruption) ke baad Node.js process ka internal state unpredictable ho jata hai; Clean PM2 restart safest policy hai.

---
**Next Topic:** 09. High-Performance Caching with Redis & Invalidation Strategies

Loading lesson content...

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track