Aplicación SOLID de principios en Node.js

Single Responsibility Principle(SRP)

Este principio establece que una clase debe tener solo una razón para cambiar, lo que significa que cada clase debe realizar una función específica.

Ejemplo: Gestión de datos de usuario y envío email de notificaciones.

class UserManager {  
  constructor() {}  
    
  createUser(userData) {  
    // Logic for creating a user  
  }  
}  
  
class EmailService {  
  constructor() {}  
    
  sendEmail(emailData) {  
    // Logic for sending an email  
  }  
}  

Open/Closed Principle(OCP)

Este principio fomenta la extensión de la funcionalidad agregando código nuevo en lugar de modificar el código existente.

Ejemplo: Manejo de diferentes métodos de pago en una aplicación de comercio electrónico.

class PaymentProcessor {  
  processPayment() {  
    // Common logic for payment processing  
  }  
}  
  
class CreditCardPaymentProcessor extends PaymentProcessor {  
  processPayment() {  
    // Logic for processing credit card payment  
  }  
}  
  
class PayPalPaymentProcessor extends PaymentProcessor {  
  processPayment() {  
    // Logic for processing PayPal payment  
  }  
}  

Liskov Substitution Principle(LSP)

Este principio afirma que los objetos de una clase derivada deben ser sustituibles por objetos de la clase base sin afectar la corrección del programa.

Ejemplo: Manejo de formas geométricas.

class Shape {  
  area() {}  
}  
  
class Rectangle extends Shape {  
  constructor(width, height) {}  
    
  area() {  
    return this.width * this.height;  
  }  
}  
  
class Square extends Shape {  
  constructor(side) {}  
    
  area() {  
    return this.side * this.side;  
  }  
}  

Principio de segregación de interfaces(ISP)

Este principio aconseja dividir las interfaces en otras más pequeñas para evitar obligar a las clases a implementar métodos que no necesitan.

Ejemplo: Interfaces para actualización y visualización de datos.

class UpdateableFeature {  
  updateFeature() {}  
}  
  
class DisplayableFeature {  
  displayFeature() {}  
}  

Dependency Inversion Principle(DIP)

Este principio sugiere que los módulos de alto nivel no deberían depender de los módulos de bajo nivel; ambos deberían depender de abstracciones.

Ejemplo: Usar dependency injection para administrar dependencias.

class OrderProcessor {  
  constructor(dbConnection, emailService) {  
    this.dbConnection = dbConnection;  
    this.emailService = emailService;  
  }  
}  

Recuerde, estos ejemplos son solo ilustraciones de cómo aplicar los SOLID principios en Node.js. En la práctica, deberá aplicarlos de manera flexible según el propósito y la escala de su proyecto.