Volver al blog

Abstract Factory: control total de tus bases de datos

Serie: Patrones de Diseño

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 if en todo el proyecto, en el arranque.
  • Tests sin base de datos: una InMemoryFactory devuelve 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.