This article is only available in Spanish.
Abstract Factory: control total de tus bases de datos
Tu servicio funciona con PostgreSQL, y un cliente lo necesita sobre MySQL. Empiezas a llenar el código de if (db === 'mysql'): uno para la conexión, otro para los placeholders ($1 frente a ?), otro para el RETURNING que MySQL no tiene. Tarde o temprano alguien usa la conexión de uno con el SQL del otro.
El problema es que conexión y queries son una familia: tienen que ir siempre juntas.
El patrón
Abstract Factory define una fábrica que crea todos los objetos de una familia. Cada base de datos tiene su fábrica, y el resto del código solo conoce la interfaz.
interface Connection {
query<T>(sql: string, params: unknown[]): Promise<T[]>;
}
interface UserQueries {
findById(id: string): { sql: string; params: unknown[] };
}
interface DatabaseFactory {
createConnection(): Connection;
createUserQueries(): UserQueries;
}
class PostgresFactory implements DatabaseFactory {
createConnection() { return new PostgresConnection(process.env.DATABASE_URL); }
createUserQueries(): UserQueries {
return { findById: (id) => ({ sql: 'SELECT * FROM users WHERE id = $1', params: [id] }) };
}
}
class MysqlFactory implements DatabaseFactory {
createConnection() { return new MysqlConnection(process.env.DATABASE_URL); }
createUserQueries(): UserQueries {
return { findById: (id) => ({ sql: 'SELECT * FROM users WHERE id = ?', params: [id] }) };
}
}
PostgresConnection y MysqlConnection envuelven el driver de cada base de datos.
El repositorio no sabe con qué base de datos habla:
class UserRepository {
private readonly connection: Connection;
private readonly queries: UserQueries;
constructor(factory: DatabaseFactory) {
this.connection = factory.createConnection();
this.queries = factory.createUserQueries();
}
async findById(id: string) {
const { sql, params } = this.queries.findById(id);
const [user] = await this.connection.query(sql, params);
return user ?? null;
}
}
La decisión se toma una sola vez, al arrancar:
const factory = process.env.DB_ENGINE === 'mysql' ? new MysqlFactory() : new PostgresFactory();
const users = new UserRepository(factory);
Lo que ganas
- Imposible mezclar familias: conexión y SQL salen de la misma fábrica.
- Un solo
ifen todo el proyecto, en el arranque. - Tests sin base de datos: una
InMemoryFactorydevuelve una conexión falsa con datos en memoria.
Cuándo no usarlo
- Si solo tienes una base de datos y no hay planes reales de cambiarla: es abstracción que pagas sin usar.
- Si ya usas un ORM o query builder (Prisma, Knex, Drizzle…) que soporta ambas bases de datos: ellos ya hacen este trabajo.
- Si la familia tiene un solo objeto: una función fábrica normal basta.
¿Te interesa cómo separar dos dimensiones que varían a la vez? Eso es el patrón Bridge.