Padrões de Projeto no TypeScript: Factory, Singleton e Repository Pattern com Tipagem Estática
Eleve a arquitetura de suas aplicações TypeScript compreendendo como os Padrões de Projeto (Design Patterns) do GoF ganham poder e elegância com tipagem estática, interfaces e genéricos: aprenda a construir Factory Methods com mapeamento exaustivo, Singletons thread-safe e o indispensável Repository Pattern para isolamento de dados corporativos.
📑 Índice do Conteúdo
1. O Papel dos Design Patterns no Ecossistema TypeScript
Os Padrões de Projeto (Design Patterns) imortalizados em 1994 pelo livro clássico do Gang of Four (Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides) nasceram para resolver problemas recorrentes de engenharia de software orientada a objetos. Em linguagens sem tipagem estática como o JavaScript tradicional, a implementação desses padrões frequentemente parecia burocrática ou frágil, já que a ausência de interface e tipagem forçava os desenvolvedores a confiarem em convenções verbais e documentação.
No TypeScript, os Design Patterns encontram o seu ambiente ideal. O casamento entre contratos estritos (interface e abstract class), tipos genéricos reutilizáveis (<T>) e tipos literais de união permite que a arquitetura não apenas fique organizada, mas seja garantida em tempo de compilação pelo próprio compilador tsc.
- Factory Pattern (Criacional): Encapsula a lógica de instanciação complexa, desacoplando o consumidor da classe concreta e garantindo exaustividade via Discriminated Unions.
- Singleton Pattern (Criacional): Assegura que uma classe possua apenas uma instância global compartilhada, muito utilizado em pools de conexões e gerenciadores de configuração.
- Repository Pattern (Estrutural/Arquitetural): Isola completamente as regras de negócio da infraestrutura de persistência (SQL, NoSQL, APIs ou memória), viabilizando testes unitários sem banco de dados.
2. Factory Method Pattern com Tipagem Exaustiva
O objetivo do padrão Factory Method é criar objetos sem expor a lógica de instanciação direta com new ao chamador, referenciando o objeto criado através de uma interface comum. No TypeScript, podemos elevar a Factory adicionando verificação estática de tipos literais.
Imagine um serviço corporativo de notificações multicanal (E-mail, SMS e Push Notification). Cada canal tem sua própria classe com lógicas de envio e payloads específicos, mas todos devem obedecer à mesma interface base:
// 1. Contrato da Notificação
export interface NotificacaoResultado {
sucesso: boolean;
destinatario: string;
timestamp: Date;
codigoRastreio: string;
}
export interface INotificacao {
enviar(destinatario: string, mensagem: string): Promise;
}
// 2. Implementações Concretas
export class EmailNotificacao implements INotificacao {
public async enviar(destinatario: string, mensagem: string): Promise {
console.log(`[SMTP-TLS] Enviando e-mail para ${destinatario}: "${mensagem}"`);
return {
sucesso: true,
destinatario,
timestamp: new Date(),
codigoRastreio: `EMAIL-${Math.random().toString(36).substring(2, 9).toUpperCase()}`
};
}
}
export class SmsNotificacao implements INotificacao {
public async enviar(destinatario: string, mensagem: string): Promise {
console.log(`[SMS-GATEWAY] Enviando SMS para ${destinatario}: "${mensagem}"`);
return {
sucesso: true,
destinatario,
timestamp: new Date(),
codigoRastreio: `SMS-${Math.random().toString(36).substring(2, 9).toUpperCase()}`
};
}
}
export class PushNotificacao implements INotificacao {
public async enviar(destinatario: string, mensagem: string): Promise {
console.log(`[FCM-APNS] Enviando Push para token ${destinatario}: "${mensagem}"`);
return {
sucesso: true,
destinatario,
timestamp: new Date(),
codigoRastreio: `PUSH-${Math.random().toString(36).substring(2, 9).toUpperCase()}`
};
}
}
// 3. Tipos Suportados e Factory Estrita
export type CanalNotificacao = 'email' | 'sms' | 'push';
export class NotificacaoFactory {
public static criar(canal: CanalNotificacao): INotificacao {
switch (canal) {
case 'email':
return new EmailNotificacao();
case 'sms':
return new SmsNotificacao();
case 'push':
return new PushNotificacao();
default: {
// Checagem de exaustividade com never
const canalInvalido: never = canal;
throw new Error(`Canal de notificação não suportado: ${canalInvalido}`);
}
}
}
}
3. Singleton Pattern: Construtor Privado e Gestão de Estado Global
O Singleton garante que uma classe tenha uma única instância durante todo o ciclo de vida da aplicação e fornece um ponto global de acesso a ela. No TypeScript, isso é obtido tornando o construtor private e expondo um método estático getInstance().
export interface ConfiguracaoAmbiente {
nodeEnv: 'development' | 'production' | 'test';
portaHttp: number;
bancoDadosUrl: string;
apiKeyGateway: string;
}
export class GerenciadorConfiguracao {
// 1. Instância única armazenada estaticamente
private static instancia: GerenciadorConfiguracao | null = null;
private readonly config: ConfiguracaoAmbiente;
// 2. Construtor privado impede "new GerenciadorConfiguracao()" de fora
private constructor() {
console.log('[Config] Inicializando variáveis de ambiente do sistema...');
this.config = {
nodeEnv: 'production',
portaHttp: 8080,
bancoDadosUrl: 'postgresql://app_user:[email protected]:5432/producao',
apiKeyGateway: 'sec_prod_live_987654321'
};
}
// 3. Método estático de acesso com Lazy Loading seguro
public static obterInstancia(): GerenciadorConfiguracao {
if (!GerenciadorConfiguracao.instancia) {
GerenciadorConfiguracao.instancia = new GerenciadorConfiguracao();
}
return GerenciadorConfiguracao.instancia;
}
public obter(chave: K): ConfiguracaoAmbiente[K] {
return this.config[chave];
}
}
// Consumo:
const config1 = GerenciadorConfiguracao.obterInstancia();
const config2 = GerenciadorConfiguracao.obterInstancia();
console.log(config1 === config2); // true (mesmíssima referência de memória!)
Singletons clássicos carregam estado global compartilhado entre testes, o que pode causar testes “fantasmas” que quebram dependendo da ordem de execução. Em sistemas enterprise com Clean Architecture e NestJS/Fastify, prefere-se usar Injeção de Dependências (DI) com escopo Singleton gerenciado pelo contêiner em vez de Singletons estáticos manuais.
4. Repository Pattern Genérico: Isolamento da Camada de Persistência
O Repository Pattern atua como uma coleção em memória de objetos de domínio. Ele medeia a fronteira entre as regras de negócio da aplicação e a camada de mapeamento de dados (banco de dados, ORMs como Prisma/TypeORM ou APIs REST), permitindo que a regra de negócio trabalhe apenas com entidades tipadas, sem se importar com comandos SQL ou drivers de persistência.
A beleza da implementação em TypeScript reside no uso de Generics com Constraints para criar uma interface de repositório reutilizável:
// 1. Entidade Base com ID
export interface EntidadeBase {
id: TID;
criadoEm: Date;
atualizadoEm?: Date;
}
// 2. Contrato Genérico de Repositório (CRUD)
export interface IRepository {
buscarPorId(id: TID): Promise;
listarTodos(): Promise;
salvar(entidade: T): Promise;
remover(id: TID): Promise;
}
// 3. Entidade de Domínio Específica
export interface Usuario extends EntidadeBase {
nome: string;
email: string;
ativo: boolean;
}
// 4. Contrato Específico estendendo o Genérico
export interface IUsuarioRepository extends IRepository {
buscarPorEmail(email: string): Promise;
}
// 5. Implementação Concreta em Memória (Excelente para testes unitários rápidos!)
export class InMemoryUsuarioRepository implements IUsuarioRepository {
private readonly dados = new Map();
public async buscarPorId(id: string): Promise {
const usuario = this.dados.get(id);
return usuario ? { ...usuario } : null;
}
public async listarTodos(): Promise {
return Array.from(this.dados.values()).map(u => ({ ...u }));
}
public async buscarPorEmail(email: string): Promise {
for (const usuario of this.dados.values()) {
if (usuario.email.toLowerCase() === email.toLowerCase()) {
return { ...usuario };
}
}
return null;
}
public async salvar(entidade: Usuario): Promise {
const registro: Usuario = {
...entidade,
atualizadoEm: new Date()
};
this.dados.set(entidade.id, registro);
return { ...registro };
}
public async remover(id: string): Promise {
return this.dados.delete(id);
}
}
5. Injeção de Dependência no Serviço de Aplicação
Veja como o serviço de domínio consome a interface IUsuarioRepository e a NotificacaoFactory sem nunca saber se o banco de dados é PostgreSQL, MongoDB ou se os dados estão na memória:
export class UsuarioService {
// Injeção de Dependência via Construtor: depende de abstração, não de classe concreta
public constructor(
private readonly usuarioRepo: IUsuarioRepository
) {}
public async registrarUsuario(nome: string, email: string): Promise {
// 1. Validação de regra de negócio
const existente = await this.usuarioRepo.buscarPorEmail(email);
if (existente) {
throw new Error(`O e-mail "${email}" já está cadastrado no sistema.`);
}
// 2. Criação da entidade
const novoUsuario: Usuario = {
id: `usr_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
nome,
email,
ativo: true,
criadoEm: new Date()
};
// 3. Persistência desacoplada
const salvo = await this.usuarioRepo.salvar(novoUsuario);
// 4. Notificação via Factory
const notificacao = NotificacaoFactory.criar('email');
await notificacao.enviar(email, `Olá ${nome}, sua conta enterprise foi ativada com sucesso!`);
return salvo;
}
}
- 100% Testável: Você pode testar a lógica de
UsuarioServiceem milissegundos passando umInMemoryUsuarioRepositorysem abrir conexões reais de banco de dados nem disparar e-mails reais. - Princípio Aberto/Fechado (OCP): Para migrar de PostgreSQL para MongoDB, basta criar um
MongoUsuarioRepository implements IUsuarioRepositorysem alterar uma única linha deUsuarioService.
padroes-de-projeto-enterprise.ts
// =====================================================================
// LAB: PADRÕES DE PROJETO NO TYPESCRIPT (FACTORY, SINGLETON & REPOSITORY)
// =====================================================================
interface IEntidade {
id: string;
criadoEm: Date;
}
interface IRepositoryGenerico {
buscarPorId(id: string): Promise;
salvar(item: T): Promise;
listar(): Promise;
}
// 1. Entidade de Domínio
interface Produto extends IEntidade {
nome: string;
preco: number;
categoria: 'software' | 'hardware' | 'servico';
}
// 2. Repositório em Memória Tipado
class ProdutoRepositoryEmMemoria implements IRepositoryGenerico {
private readonly banco = new Map();
public async buscarPorId(id: string): Promise {
const item = this.banco.get(id);
return item ? { ...item } : null;
}
public async salvar(item: Produto): Promise {
this.banco.set(item.id, { ...item });
return { ...item };
}
public async listar(): Promise {
return Array.from(this.banco.values());
}
}
// 3. Factory para Criação com Regras de Negócio
class ProdutoFactory {
public static criar(
nome: string,
preco: number,
categoria: 'software' | 'hardware' | 'servico'
): Produto {
if (preco console.log(` -> [${p.id}] ${p.nome} (R$ ${p.preco.toFixed(2)}) - ${p.categoria.toUpperCase()}`));
const recuperado = await repo.buscarPorId(prod1.id);
console.log('nBusca por ID:', recuperado?.nome === prod1.nome ? '✅ Sucesso!' : '❌ Falha!');
}
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