Module 12: Advanced Node.js Patterns

Master advanced Node.js patterns, design patterns, debugging techniques, error handling strategies, and production best practices.

Back to Course|5.5 hours|Advanced

Advanced Node.js Patterns

Master advanced Node.js patterns, design patterns, debugging techniques, error handling strategies, and production best practices.

Progress: 0/4 topics completed0%

Select Topics Overview

Design Patterns in Node.js

Learn essential design patterns for Node.js applications including Singleton, Factory, Observer, and Module patterns.

Content by: Praveen Kumar

MERN Stack Developer

Connect

Singleton Pattern

Ensure a class has only one instance and provide global access to it.

Factory Pattern

Code Example
// Factory pattern for creating objects
class DatabaseConnectionFactory {
    static createConnection(type) {
        switch (type) {
            case 'mysql':
                return new MySQLConnection();
            case 'postgresql':
                return new PostgreSQLConnection();
            case 'mongodb':
                return new MongoDBConnection();
            default:
                throw new Error('Unsupported database type');
        }
    }
}

class MySQLConnection {
    connect() {
        console.log('Connecting to MySQL');
    }
}

class PostgreSQLConnection {
    connect() {
        console.log('Connecting to PostgreSQL');
    }
}

// Usage
const db = DatabaseConnectionFactory.createConnection('mysql');
db.connect();
Swipe to see more code

Observer Pattern

Code Example
// Event-driven architecture with Observer pattern
class EventEmitter {
    constructor() {
        this.events = {};
    }
    
    on(event, listener) {
        if (!this.events[event]) {
            this.events[event] = [];
        }
        this.events[event].push(listener);
    }
    
    emit(event, data) {
        if (this.events[event]) {
            this.events[event].forEach(listener => listener(data));
        }
    }
}

// Usage
const emitter = new EventEmitter();
emitter.on('user:created', (user) => {
    console.log('User created:', user);
});
emitter.emit('user:created', { id: 1, name: 'John' });
Swipe to see more code

Module Pattern

Code Example
// Module pattern for encapsulation
const UserModule = (() => {
    let users = [];
    
    return {
        addUser: (user) => {
            users.push(user);
        },
        getUsers: () => [...users],
        getUserById: (id) => users.find(u => u.id === id)
    };
})();

// Usage
UserModule.addUser({ id: 1, name: 'John' });
console.log(UserModule.getUsers());
Swipe to see more code

Strategy Pattern

Code Example
// Strategy pattern for different algorithms
class PaymentProcessor {
    constructor(strategy) {
        this.strategy = strategy;
    }
    
    processPayment(amount) {
        return this.strategy.process(amount);
    }
}

class CreditCardStrategy {
    process(amount) {
        return `Processing ${amount} via Credit Card`;
    }
}

class PayPalStrategy {
    process(amount) {
        return `Processing ${amount} via PayPal`;
    }
}

// Usage
const processor = new PaymentProcessor(new CreditCardStrategy());
console.log(processor.processPayment(100));
Swipe to see more code

Mini-Project: Complete Pattern Implementation

Code Example
// Complete design patterns implementation
class Logger {
    constructor() {
        if (Logger.instance) {
            return Logger.instance;
        }
        this.logs = [];
        Logger.instance = this;
    }
    
    log(message) {
        const timestamp = new Date().toISOString();
        this.logs.push({ message, timestamp });
        console.log(`[${timestamp}] ${message}`);
    }
    
    getLogs() {
        return this.logs;
    }
}

// Factory for different types of handlers
class HandlerFactory {
    static createHandler(type) {
        switch (type) {
            case 'email':
                return new EmailHandler();
            case 'sms':
                return new SMSHandler();
            case 'push':
                return new PushHandler();
            default:
                throw new Error('Unknown handler type');
        }
    }
}

class EmailHandler {
    send(message) {
        console.log(`Sending email: ${message}`);
    }
}

class SMSHandler {
    send(message) {
        console.log(`Sending SMS: ${message}`);
    }
}

// Observer pattern for notifications
class NotificationService {
    constructor() {
        this.subscribers = [];
    }
    
    subscribe(callback) {
        this.subscribers.push(callback);
    }
    
    notify(data) {
        this.subscribers.forEach(callback => callback(data));
    }
}

// Usage
const logger = new Logger();
const notificationService = new NotificationService();

notificationService.subscribe((data) => {
    logger.log(`Notification sent: ${data.message}`);
});

const emailHandler = HandlerFactory.createHandler('email');
emailHandler.send('Welcome to our service!');
Swipe to see more code

🎯 Practice Exercise

Test your understanding of this topic:

Previous Module

Module 11: DevOps & Deployment

Additional Resources

📚 Recommended Reading

  • •Node.js Design Patterns Guide
  • •Advanced Debugging Techniques
  • •Error Handling Best Practices
  • •Production Deployment Guide

🌐 Online Resources

  • •Node.js Performance Optimization
  • •Debugging Node.js Applications
  • •Production Best Practices
  • •Node.js Security Guide

Ready for the Next Module?

Continue your learning journey and master the next set of concepts.

Back to Course Overview