<h2>Repository Pattern com TypeScript: Abstrações e Implementações</h2>
<p>O Repository Pattern é um padrão de design que funciona como uma camada de abstração entre a lógica de negócio e a camada de acesso a dados. Seu objetivo é centralizar todas as operações de persistência, consulta e manipulação de dados em um único lugar, isolando a aplicação dos detalhes de implementação do banco de dados. Quando você trabalha com TypeScript, essa abstração ganha ainda mais força graças ao sistema de tipos robusto da linguagem, permitindo criar interfaces contratadas e reutilizáveis.</p>
<p>Em termos práticos, o padrão funciona assim: em vez de sua camada de negócio chamar diretamente métodos do banco de dados (como queries SQL ou métodos de um ORM), você cria um repositório que encapsula essas chamadas. Isso significa que se você precisar trocar de banco de dados ou mudar a forma como os dados são recuperados, apenas o repositório muda, não toda sua aplicação. Além disso, fica muito mais fácil escrever testes unitários, pois você pode criar mocks e stubs dos repositórios sem precisar de um banco de dados real.</p>
<h2>Entendendo a Abstração e a Interface</h2>
<h3>Por que Abstrair?</h3>
<p>A abstração é o coração do Repository Pattern. Sem ela, você teria repositórios concretos espalhados por toda a aplicação, cada um acoplado a uma tecnologia específica. Uma interface bem definida garante que qualquer implementação de repositório siga um contrato, independentemente de usar MongoDB, PostgreSQL, MySQL ou até um arquivo JSON. Isso é o que chamamos de inversão de controle: sua lógica de negócio não conhece os detalhes, apenas a interface.</p>
<h3>Criando uma Interface Genérica</h3>
<p>Vamos começar definindo uma interface genérica que serve como base para qualquer repositório:</p>
<pre><code class="language-typescript">export interface IRepository<T> {
create(entity: T): Promise<T>;
findById(id: string): Promise<T | null>;
findAll(): Promise<T[]>;
update(id: string, entity: Partial<T>): Promise<T | null>;
delete(id: string): Promise<boolean>;
}</code></pre>
<p>Esta interface usa generics, permitindo que qualquer tipo <code>T</code> seja persistido. Os métodos retornam <code>Promise</code> porque operações de banco de dados são assíncronas. Note que <code>findById</code> retorna <code>T | null</code> porque o registro pode não existir, e <code>update</code> aceita <code>Partial<T></code> porque nem sempre você atualiza todos os campos.</p>
<p>Agora vamos criar uma entidade exemplo para trabalhar com:</p>
<pre><code class="language-typescript">export interface User {
id: string;
name: string;
email: string;
createdAt: Date;
}</code></pre>
<h2>Implementações Concretas do Padrão</h2>
<h3>Repositório com PostgreSQL</h3>
<p>A primeira implementação usa o Prisma, um ORM moderno e type-safe. Observe como a classe implementa a interface e encapsula completamente a interação com o banco:</p>
<pre><code class="language-typescript">import { PrismaClient } from '@prisma/client';
import { IRepository } from './IRepository';
import { User } from './User';
export class PostgresUserRepository implements IRepository<User> {
constructor(private prisma: PrismaClient) {}
async create(entity: User): Promise<User> {
return this.prisma.user.create({
data: {
id: entity.id,
name: entity.name,
email: entity.email,
createdAt: entity.createdAt,
},
});
}
async findById(id: string): Promise<User | null> {
return this.prisma.user.findUnique({
where: { id },
});
}
async findAll(): Promise<User[]> {
return this.prisma.user.findMany();
}
async update(id: string, entity: Partial<User>): Promise<User | null> {
return this.prisma.user.update({
where: { id },
data: entity,
});
}
async delete(id: string): Promise<boolean> {
const result = await this.prisma.user.delete({
where: { id },
});
return !!result;
}
}</code></pre>
<h3>Repositório com MongoDB</h3>
<p>Agora implementamos a mesma interface com MongoDB usando o Mongoose. Veja como a interface permanece idêntica, mas a implementação é completamente diferente:</p>
<pre><code class="language-typescript">import mongoose, { Model } from 'mongoose';
import { IRepository } from './IRepository';
import { User } from './User';
export class MongoUserRepository implements IRepository<User> {
constructor(private model: Model<User>) {}
async create(entity: User): Promise<User> {
const created = new this.model(entity);
return created.save();
}
async findById(id: string): Promise<User | null> {
return this.model.findById(id).exec();
}
async findAll(): Promise<User[]> {
return this.model.find().exec();
}
async update(id: string, entity: Partial<User>): Promise<User | null> {
return this.model.findByIdAndUpdate(id, entity, { new: true }).exec();
}
async delete(id: string): Promise<boolean> {
const result = await this.model.findByIdAndDelete(id).exec();
return !!result;
}
}</code></pre>
<h3>Repositório em Memória para Testes</h3>
<p>Uma das grandes vantagens do padrão fica evidente aqui: podemos criar um repositório que apenas mantém dados em memória, perfeito para testes automatizados:</p>
<pre><code class="language-typescript">import { IRepository } from './IRepository';
import { User } from './User';
export class InMemoryUserRepository implements IRepository<User> {
private users: Map<string, User> = new Map();
async create(entity: User): Promise<User> {
this.users.set(entity.id, entity);
return entity;
}
async findById(id: string): Promise<User | null> { return this.users.get(id) || null;
}
async findAll(): Promise<User[]> {
return Array.from(this.users.values());
}
async update(id: string, entity: Partial<User>): Promise<User | null> {
const user = this.users.get(id);
if (!user) return null;
const updated = { ...user, ...entity };
this.users.set(id, updated);
return updated;
}
async delete(id: string): Promise<boolean> {
return this.users.delete(id);
}
}</code></pre>
<h2>Integração com a Camada de Negócio</h2>
<h3>Serviço de Usuário</h3>
<p>Agora criamos um serviço que usa o repositório sem conhecer sua implementação. Isso é inversão de dependência: o serviço depende da abstração, não da implementação concreta:</p>
<pre><code class="language-typescript">import { IRepository } from './IRepository';
import { User } from './User';
export class UserService {
constructor(private userRepository: IRepository<User>) {}
async registerUser(name: string, email: string): Promise<User> {
const newUser: User = {
id: this.generateId(),
name,
email,
createdAt: new Date(),
};
return this.userRepository.create(newUser);
}
async getUserProfile(id: string): Promise<User | null> {
return this.userRepository.findById(id);
}
async updateUserEmail(id: string, newEmail: string): Promise<User | null> {
return this.userRepository.update(id, { email: newEmail });
}
async deleteUser(id: string): Promise<boolean> {
return this.userRepository.delete(id);
}
private generateId(): string {
return user_${Date.now()}_${Math.random().toString(36).substr(2, 9)};
}
}</code></pre>
<h3>Testando o Serviço</h3>
<p>Com a abstração em lugar, escrever testes se torna trivial. Usamos o repositório em memória:</p>
<pre><code class="language-typescript">import { InMemoryUserRepository } from './InMemoryUserRepository';
import { UserService } from './UserService';
describe('UserService', () => {
let userService: UserService;
let userRepository: InMemoryUserRepository;
beforeEach(() => {
userRepository = new InMemoryUserRepository();
userService = new UserService(userRepository);
});
it('should register a new user', async () => {
const user = await userService.registerUser('João Silva', 'joao@example.com');
expect(user.name).toBe('João Silva');
expect(user.email).toBe('joao@example.com');
expect(user.id).toBeDefined();
});
it('should retrieve user by id', async () => {
const registered = await userService.registerUser('Maria', 'maria@example.com');
const retrieved = await userService.getUserProfile(registered.id);
expect(retrieved).toEqual(registered);
});
it('should update user email', async () => {
const user = await userService.registerUser('Pedro', 'pedro@example.com');
const updated = await userService.updateUserEmail(user.id, 'newemail@example.com');
expect(updated?.email).toBe('newemail@example.com');
});
it('should delete user', async () => {
const user = await userService.registerUser('Ana', 'ana@example.com');
const deleted = await userService.deleteUser(user.id);
expect(deleted).toBe(true);
const found = await userService.getUserProfile(user.id);
expect(found).toBeNull();
});
});</code></pre>
<h2>Injeção de Dependência e Factory Pattern</h2>
<h3>Configurando os Repositórios</h3>
<p>Em uma aplicação real, você não instancia repositórios manualmente em todos os lugares. Use um container de injeção de dependência ou um factory pattern. Aqui está um exemplo simples:</p>
<pre><code class="language-typescript">import { PrismaClient } from '@prisma/client';
import { IRepository } from './IRepository';
import { User } from './User';
import { PostgresUserRepository } from './PostgresUserRepository';
import { MongoUserRepository } from './MongoUserRepository';
import { InMemoryUserRepository } from './InMemoryUserRepository';
export class RepositoryFactory {
static createUserRepository(env: 'postgres' | 'mongo' | 'memory'): IRepository<User> {
switch (env) {
case 'postgres':
const prisma = new PrismaClient();
return new PostgresUserRepository(prisma);
case 'mongo':
// Assumindo que a conexão já está feita
const userModel = require('./models/userModel').default;
return new MongoUserRepository(userModel);
case 'memory':
return new InMemoryUserRepository();
default:
throw new Error(Repositório desconhecido: ${env});
}
}
}</code></pre>
<h3>Usando o Factory em sua Aplicação</h3>
<pre><code class="language-typescript">const env = process.env.DB_TYPE || 'postgres';
const userRepository = RepositoryFactory.createUserRepository(env as any);
const userService = new UserService(userRepository);
// A aplicação funciona igual, independentemente do banco
const newUser = await userService.registerUser('João', 'joao@example.com');</code></pre>
<h2>Extensões Avançadas do Padrão</h2>
<h3>Repositório com Filtros e Paginação</h3>
<p>Em aplicações reais, você precisa de mais do que CRUD básico. Vamos expandir a interface:</p>
<pre><code class="language-typescript">export interface PageOptions {
page: number;
limit: number;
}
export interface PageResult<T> {
data: T[];
total: number;
page: number;
totalPages: number;
}
export interface IRepository<T> {
create(entity: T): Promise<T>;
findById(id: string): Promise<T | null>;
findAll(): Promise<T[]>;
findWithPagination(options: PageOptions): Promise<PageResult<T>>;
findByFilter(filter: Partial<T>, options: PageOptions): Promise<PageResult<T>>;
update(id: string, entity: Partial<T>): Promise<T | null>;
delete(id: string): Promise<boolean>;
}</code></pre>
<p>Agora implementamos em PostgreSQL:</p>
<pre><code class="language-typescript">export class PostgresUserRepository implements IRepository<User> {
constructor(private prisma: PrismaClient) {}
async findWithPagination(options: PageOptions): Promise<PageResult<User>> {
const skip = (options.page - 1) * options.limit;
const [data, total] = await Promise.all([
this.prisma.user.findMany({
skip,
take: options.limit,
orderBy: { createdAt: 'desc' },
}),
this.prisma.user.count(),
]);
return {
data,
total,
page: options.page,
totalPages: Math.ceil(total / options.limit),
};
}
async findByFilter(filter: Partial<User>, options: PageOptions): Promise<PageResult<User>> {
const skip = (options.page - 1) * options.limit;
const [data, total] = await Promise.all([
this.prisma.user.findMany({
where: {
...(filter.name && { name: { contains: filter.name, mode: 'insensitive' } }),
...(filter.email && { email: { contains: filter.email, mode: 'insensitive' } }),
},
skip,
take: options.limit,
orderBy: { createdAt: 'desc' },
}),
this.prisma.user.count({
where: {
...(filter.name && { name: { contains: filter.name, mode: 'insensitive' } }),
...(filter.email && { email: { contains: filter.email, mode: 'insensitive' } }),
},
}),
]);
return {
data,
total,
page: options.page,
totalPages: Math.ceil(total / options.limit),
};
}
// ... outros métodos
}</code></pre>
<h3>Exemplo de Uso com Filtros</h3>
<pre><code class="language-typescript">const userService = new UserService(userRepository);
// Buscar página 1 com 10 itens
const page1 = await userRepository.findWithPagination({ page: 1, limit: 10 });
// Buscar usuários cujo nome contém "João"
const filtered = await userRepository.findByFilter(
{ name: 'João' },
{ page: 1, limit: 5 }
);
console.log(Total de usuários: ${filtered.total});
console.log(Total de páginas: ${filtered.totalPages});
console.log(Usuários na página 1:, filtered.data);</code></pre>
<h2>Conclusão</h2>
<p>O Repository Pattern com TypeScript oferece três benefícios fundamentais que você aprendeu neste artigo: <strong>abstração da camada de dados</strong> que permite trocar implementações sem alterar a lógica de negócio, <strong>testabilidade garantida</strong> pela facilidade de criar repositórios mock em memória, e <strong>manutenibilidade a longo prazo</strong> através de interfaces bem definidas que funcionam como contratos. A tipagem forte do TypeScript potencializa esses benefícios, prevenindo erros em tempo de compilação e oferecendo autocompletar robusto. Use o padrão com inteligência: em aplicações pequenas pode ser over-engineering, mas em sistemas médios a grandes traz organização e flexibilidade que economiza horas de refatoração no futuro.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://www.typescriptlang.org/docs/handbook/2/objects.html" target="_blank" rel="noopener noreferrer">TypeScript Handbook - Interfaces</a></li>
<li><a href="https://www.prisma.io/docs/" target="_blank" rel="noopener noreferrer">Prisma Documentation</a></li>
<li><a href="https://docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design" target="_blank" rel="noopener noreferrer">Microsoft: Repository Pattern</a></li>
<li><a href="https://martinfowler.com/eaaCatalog/repository.html" target="_blank" rel="noopener noreferrer">Martin Fowler: Repository</a></li>
<li><a href="https://en.wikipedia.org/wiki/Design_Patterns" target="_blank" rel="noopener noreferrer">Design Patterns: Elements of Reusable Object-Oriented Software - Gang of Four</a></li>
</ul>
<p><!-- FIM --></p>