Padrões de Projeto no TypeScript: Factory e Repository
⚡ Curso de TypeScript • Web-ZoneWare

Padrões de Projeto no TypeScript: Factory, Singleton e Repository Pattern com Tipagem Estática

Lição 46 de 50

Padrões de Projeto no TypeScript: Factory, Singleton e Repository Pattern com Tipagem Estática

⚡ Módulo 6 • Aula 46 de 50

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.

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.

🏛️

Três Pilares Essenciais no TypeScript Corporativo:

  • 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:

TypeScript 69 linhas
// 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().

TypeScript 40 linhas
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!)
⚠️

Alerta de Arquitetura: Singletons e Testes Unitários
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:

TypeScript 62 linhas
// 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:

TypeScript 32 linhas
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;
    }
}
✨

Ganhos Imediatos de Arquitetura:

  • 100% Testável: Você pode testar a lógica de UsuarioService em milissegundos passando um InMemoryUsuarioRepository sem 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 IUsuarioRepository sem alterar uma única linha de UsuarioService.

TypeScript 5.0+
padroes-de-projeto-enterprise.ts
TypeScript 55 linhas
// =====================================================================
// 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();
🛠️ Laboratório Prático & Prática Imediata

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.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground 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
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima