Aplicando SOLID princípios em Node.js

Single Responsibility Principle(SRP)

Esse princípio afirma que uma classe deve ter apenas um motivo para mudar, o que significa que cada classe deve executar uma função específica.

Exemplo: gerenciamento de dados do usuário e envio email de notificações.

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

Open/Closed Principle(OCP)

Esse princípio incentiva a extensão da funcionalidade adicionando um novo código em vez de modificar o código existente.

Exemplo: Lidar com diferentes métodos de pagamento em um aplicativo de comércio eletrô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 princípio afirma que objetos de uma classe derivada devem ser substituíveis por objetos da classe base sem afetar a correção do programa.

Exemplo: Gerenciamento 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;  
  }  
}  

Princípio de segregação de interface(ISP)

Esse princípio aconselha dividir as interfaces em interfaces menores para evitar forçar as classes a implementar métodos de que não precisam.

Exemplo: Interfaces para atualização e exibição de dados.

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

Dependency Inversion Principle(DIP)

Esse princípio sugere que os módulos de alto nível não devem depender dos módulos de baixo nível; ambos devem depender de abstrações.

Exemplo: Usando dependency injection para gerenciar dependências.

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

Lembre-se de que esses exemplos são apenas ilustrações de como aplicar os SOLID princípios do Node.js. Na prática, você precisará aplicá-los de forma flexível com base na finalidade e na escala do seu projeto.