Princípios SOLID Aplicados no TypeScript: Guia Definitivo com Exemplos Práticos
Domine os 5 princípios do acrônimo SOLID formulados por Robert C. Martin aplicados ao TypeScript: compreenda como Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation e Dependency Inversion transformam bases de código frágeis e monolíticas em sistemas corporativos resilientes, testáveis e escaláveis.
📑 Índice do Conteúdo
1. O Papel do SOLID na Engenharia de Software Moderna com TypeScript
O acrônimo SOLID representa cinco princípios fundamentais de design de software orientado a objetos, consolidados por Robert C. Martin (Uncle Bob) no início dos anos 2000. Durante muitos anos no ecossistema JavaScript, esses princípios foram considerados excessivamente acadêmicos ou difíceis de impor, já que a linguagem carecia de tipagem estática, visibilidade de membros e interfaces formais.
Com o TypeScript, o SOLID tornou-se a espinha dorsal de projetos corporativos de grande porte (como aplicações NestJS, microsserviços Node.js e arquiteturas de frontend baseadas em Clean Architecture). A tipagem estática em tempo de compilação transforma regras conceituais em travas de segurança reais que impedem regressões e acoplamentos indevidos.
- S — Single Responsibility Principle (SRP): Uma classe/módulo deve ter um único motivo para mudar.
- O — Open/Closed Principle (OCP): Entidades devem estar abertas para extensão, mas fechadas para modificação.
- L — Liskov Substitution Principle (LSP): Subtipos devem ser substituíveis por seus tipos base sem alterar a corretude do programa.
- I — Interface Segregation Principle (ISP): Clientes não devem ser forçados a depender de interfaces que não utilizam.
- D — Dependency Inversion Principle (DIP): Módulos de alto nível devem depender de abstrações, não de implementações concretas.
2. S — Single Responsibility Principle (SRP)
O Princípio da Responsabilidade Única afirma que uma classe deve ter uma única responsabilidade no domínio do sistema. O erro mais frequente é a criação de God Classes — classes monolíticas que acumulam persistência de dados, cálculos financeiros, formatação de relatórios e disparo de notificações.
// ❌ VIOLAÇÃO DO SRP: Uma classe acumulando múltiplas razões para mudar
class RelatorioVendasMonolitico {
public buscarDadosDoBanco(): any[] { /* Acesso a banco de dados */ return []; }
public calcularLucroLiquido(): number { /* Regra de negócio contábil */ return 0; }
public gerarArquivoPdf(): void { /* Formatação visual e PDF */ }
public enviarEmailDiretoria(): void { /* Comunicação de rede SMTP */ }
}
// ✅ CONFORME COM O SRP: Cada classe com responsabilidade atômica e coesa
export interface Venda {
id: string;
valor: number;
imposto: number;
}
export class CalculadoraFinanceira {
public calcularTotalLiquido(vendas: Venda[]): number {
return vendas.reduce((acc, v) => acc + (v.valor - v.imposto), 0);
}
}
export class GeradorRelatorioPdf {
public renderizar(vendas: Venda[], total: number): Buffer {
console.log('[PDF] Gerando documento com formatação visual...');
return Buffer.from('PDF_BYTES');
}
}
export class NotificadorDiretoria {
public async enviarPorEmail(pdf: Buffer, destinatario: string): Promise {
console.log(`[SMTP] Enviando relatório anexado para ${destinatario}`);
}
}
3. O — Open/Closed Principle (OCP)
O Princípio Aberto/Fechado prega que novas funcionalidades devem ser adicionadas através da criação de novo código (extensão), e não pela edição contínua de classes já testadas e consolidadas em produção (modificação).
// ❌ VIOLAÇÃO DO OCP: Para cada novo tipo de desconto, precisamos editar o switch-case existente
class CalculadoraDescontoRuim {
public calcular(valor: number, tipo: 'comum' | 'vip' | 'black_friday'): number {
if (tipo === 'comum') return valor * 0.05;
if (tipo === 'vip') return valor * 0.15;
if (tipo === 'black_friday') return valor * 0.30;
return 0;
}
}
// ✅ CONFORME COM O OCP: Extensão via Polimorfismo e Interfaces
export interface IRegraDesconto {
calcular(valorOriginal: number): number;
}
export class DescontoClienteComum implements IRegraDesconto {
public calcular(valorOriginal: number): number {
return valorOriginal * 0.05;
}
}
export class DescontoClienteVip implements IRegraDesconto {
public calcular(valorOriginal: number): number {
return valorOriginal * 0.15;
}
}
// Novo desconto adicionado sem alterar nenhuma classe anterior!
export class DescontoBlackFriday implements IRegraDesconto {
public calcular(valorOriginal: number): number {
return valorOriginal * 0.30;
}
}
export class ProcessadorDesconto {
public aplicar(valor: number, regra: IRegraDesconto): number {
return valor - regra.calcular(valor);
}
}
4. L — Liskov Substitution Principle (LSP)
Formulado por Barbara Liskov, o princípio dita que objetos de uma superclasse ou interface devem poder ser substituídos por objetos de suas subclasses sem afetar a integridade lógica ou o comportamento esperado do programa.
// ❌ VIOLAÇÃO DO LSP: ContaPoupanca viola o contrato ao desabilitar o método sacar com erro
abstract class ContaBancariaBase {
protected saldo: number = 0;
public depositar(valor: number): void { this.saldo += valor; }
public abstract sacar(valor: number): void;
}
class ContaInvestimentoBloqueada extends ContaBancariaBase {
public sacar(valor: number): void {
// Quebra a expectativa de quem consome ContaBancariaBase!
throw new Error('Saques não são permitidos nesta aplicação financeira!');
}
}
// ✅ CONFORME COM O LSP: Segregação semântica das capacidades
export interface IContaBancaria {
obterSaldo(): number;
depositar(valor: number): void;
}
export interface IContaSaqueDisponivel extends IContaBancaria {
sacar(valor: number): void;
}
export class ContaCorrente implements IContaSaqueDisponivel {
private saldo: number = 0;
public obterSaldo(): number { return this.saldo; }
public depositar(valor: number): void { this.saldo += valor; }
public sacar(valor: number): void {
if (this.saldo >= valor) this.saldo -= valor;
}
}
export class ContaInvestimentoPreFixada implements IContaBancaria {
private saldo: number = 0;
public obterSaldo(): number { return this.saldo; }
public depositar(valor: number): void { this.saldo += valor; }
// Não implementa IContaSaqueDisponivel, evitando quebras inesperadas em tempo de execução
}
5. I — Interface Segregation Principle (ISP)
O Princípio da Segregação de Interfaces estabelece que nenhum cliente deve ser forçado a depender de métodos que não utiliza. É sempre preferível criar múltiplas interfaces específicas e coesas do que uma única interface “gorda” e genérica.
// ❌ VIOLAÇÃO DO ISP: Interface forçando implementações desnecessárias
interface IDispositivoMultifuncionalGordo {
imprimir(): void;
escanear(): void;
enviarFax(): void;
grampearFolhas(): void;
}
// Uma impressora simples de mesa é forçada a lançar erros ou deixar métodos vazios:
class ImpressoraDomesticaRuim implements IDispositivoMultifuncionalGordo {
public imprimir(): void { console.log('Imprimindo...'); }
public escanear(): void { throw new Error('Não possui scanner!'); }
public enviarFax(): void { throw new Error('Não possui fax!'); }
public grampearFolhas(): void { throw new Error('Não possui grampeador!'); }
}
// ✅ CONFORME COM O ISP: Interfaces granulares e componíveis
export interface IImpressora {
imprimir(documento: string): void;
}
export interface IEscanner {
escanear(): string;
}
export interface IFax {
enviarFax(numero: string, doc: string): void;
}
// Impressora simples implementa apenas o que faz:
export class ImpressoraLaserEscritorio implements IImpressora {
public imprimir(documento: string): void {
console.log(`[Laser] Imprimindo: ${documento}`);
}
}
// Dispositivo avançado compõe as interfaces necessárias:
export class MultifuncionalEnterprise implements IImpressora, IEscanner, IFax {
public imprimir(documento: string): void { console.log('[Print] OK'); }
public escanear(): string { return 'conteudo_escaneado'; }
public enviarFax(numero: string, doc: string): void { console.log('[Fax] Enviado'); }
}
6. D — Dependency Inversion Principle (DIP)
O Princípio da Inversão de Dependência define que módulos de alto nível (regras de negócio) não devem depender de módulos de baixo nível (infraestrutura, banco de dados ou bibliotecas externas). Ambos devem depender de abstrações (interfaces).
// 1. Abstração compartilhada
export interface IServicoEmail {
enviar(para: string, assunto: string, corpo: string): Promise;
}
// 2. Módulo de Baixo Nível (Infraestrutura Concreta)
export class SendGridEmailService implements IServicoEmail {
public async enviar(para: string, assunto: string, corpo: string): Promise {
console.log(`[SendGrid API] Enviando e-mail para ${para}...`);
return true;
}
}
// 3. Módulo de Alto Nível (Regra de Negócio) dependendo apenas da Abstração
export class CadastroUsuarioUseCase {
// Injeção de Dependência pelo construtor
public constructor(
private readonly emailService: IServicoEmail
) {}
public async executar(email: string, nome: string): Promise {
console.log(`[Domínio] Registrando usuário ${nome} (${email})...`);
// O caso de uso não faz ideia se o e-mail usa SendGrid, AWS SES ou Mailgun!
await this.emailService.enviar(email, 'Bem-vindo!', `Olá ${nome}, seu cadastro está ativo.`);
}
}
Graças ao DIP, para testar
CadastroUsuarioUseCase sem gastar créditos de APIs reais nem disparar e-mails para clientes, basta injetar um mock em memória:const fakeEmailService: IServicoEmail = { enviar: async () => true };
principios-solid-demonstracao.ts
// =====================================================================
// LAB: OS 5 PRINCÍPIOS SOLID EM UMA ARQUITETURA DE PAGAMENTOS
// =====================================================================
// [S] - Single Responsibility: Entidade de Pedido puramente com dados
interface ItemPedido {
nome: string;
preco: number;
}
class Pedido {
public constructor(
public readonly id: string,
public readonly itens: ItemPedido[],
public readonly clienteEmail: string
) {}
public calcularSubtotal(): number {
return this.itens.reduce((acc, item) => acc + item.preco, 0);
}
}
// [O] - Open/Closed: Estratégias de Taxa de Envio extensíveis
interface IEstrategiaEnvio {
calcularFrete(subtotal: number): number;
}
class EnvioExpresso implements IEstrategiaEnvio {
public calcularFrete(subtotal: number): number {
return subtotal > 200 ? 15.00 : 30.00;
}
}
class EnvioEconomico implements IEstrategiaEnvio {
public calcularFrete(subtotal: number): number {
return subtotal > 200 ? 0.00 : 12.00; // Frete grátis acima de R$ 200
}
}
// [I] - Interface Segregation: Interfaces separadas para processar e estornar
interface IProcessadorPagamento {
processar(valor: number): Promise;
}
interface IProcessadorEstornavel {
estornar(transacaoId: string): Promise;
}
// [L] - Liskov Substitution: Ambos os gateways cumprem estritamente o contrato IProcessadorPagamento
class GatewayPix implements IProcessadorPagamento {
public async processar(valor: number) {
console.log(`[PIX] Gerando QR Code Instantâneo para R$ ${valor.toFixed(2)}`);
return { transacaoId: `PIX_${Date.now()}`, status: 'aprovado' as const };
}
}
class GatewayCartaoCredito implements IProcessadorPagamento, IProcessadorEstornavel {
public async processar(valor: number) {
console.log(`[Cartão] Autorizando transação de R$ ${valor.toFixed(2)} com adquirente`);
return { transacaoId: `CC_${Date.now()}`, status: 'aprovado' as const };
}
public async estornar(transacaoId: string) {
console.log(`[Cartão] Estornando transação ${transacaoId}`);
return true;
}
}
// [D] - Dependency Inversion: Checkout depende exclusivamente de abstrações
class CheckoutOrderService {
public constructor(
private readonly processador: IProcessadorPagamento,
private readonly estrategiaEnvio: IEstrategiaEnvio
) {}
public async finalizarPedido(pedido: Pedido): Promise {
const subtotal = pedido.calcularSubtotal();
const frete = this.estrategiaEnvio.calcularFrete(subtotal);
const total = subtotal + frete;
console.log(`nProcessando Pedido #${pedido.id}`);
console.log(`Subtotal: R$ ${subtotal.toFixed(2)} | Frete: R$ ${frete.toFixed(2)} | Total: R$ ${total.toFixed(2)}`);
const resultado = await this.processador.processar(total);
if (resultado.status === 'aprovado') {
console.log(`✅ Pagamento Aprovado! ID da Transação: ${resultado.transacaoId}`);
} else {
console.log('❌ Pagamento Recusado.');
}
}
}
// Simulação de Execução
async function executarDemonstracao() {
const pedidoExemplo = new Pedido('PED-8891', [
{ nome: 'Monitor Ultrawide 34"', preco: 1899.90 },
{ nome: 'Cabo Thunderbolt 4', preco: 159.00 }
], '[email protected]');
// Cenário 1: Pagamento via Pix com Envio Econômico
const checkoutPix = new CheckoutOrderService(new GatewayPix(), new EnvioEconomico());
await checkoutPix.finalizarPedido(pedidoExemplo);
// Cenário 2: Pagamento via Cartão com Envio Expresso (troca instantânea sem mudar o CheckoutOrderService!)
const checkoutCartao = new CheckoutOrderService(new GatewayCartaoCredito(), new EnvioExpresso());
await checkoutCartao.finalizarPedido(pedidoExemplo);
}
executarDemonstracao();
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE