La mejor base de datos para Node.js

Node.js se lleva bien con prácticamente cualquier base de datos. Todas las bases de datos populares tienen un driver mantenido en npm, y todos trabajan con Promises y async/await. Por eso la pregunta "cuál es la mejor base de datos para Node.js" tiene menos que ver con Node y más con tu proyecto: la forma de los datos, las garantías que necesitas y cuántos procesos van a acceder a la base de datos.

Esta guía compara las cinco opciones más comunes del ecosistema (PostgreSQL, MySQL, MongoDB, Redis y SQLite) desde el punto de vista de quien escribe JavaScript. Para cada una verás el driver, un ejemplo y las trampas que aparecen en el día a día.

¿Qué criterios importan al elegir?#

Cinco criterios resuelven casi todos los casos:

1. Forma de los datos. Usuarios, pedidos e inventarios relacionados entre sí piden una base de datos relacional. Configuraciones y perfiles con campos que varían de un elemento a otro encajan con documentos.
2. Transacciones. Si dos escrituras tienen que ocurrir juntas o no ocurrir (restar un saldo y sumar otro), prefiere una base de datos con transacciones maduras.
3. Patrón de acceso. Leer por clave exacta en milisegundos, como una sesión o un cooldown, es trabajo de Redis. Los informes que cruzan tablas son trabajo de SQL.
4. Cuántos procesos acceden. Un solo proceso puede usar un archivo local (SQLite). Varios procesos, varias aplicaciones o réplicas piden un servidor de base de datos al que se accede por la red.
5. Calidad del driver. Las cinco bases de datos de esta guía tienen drivers maduros en npm. Este criterio pesa más en bases de datos menos populares.

Si todavía estás eligiendo una base de datos en general, sin centrarte en Node.js, mira qué base de datos elegir.

PostgreSQL con Node.js#

PostgreSQL es relacional, tiene transacciones completas, extensiones y el tipo jsonb, que guarda JSON con soporte de índices. Eso permite mezclar columnas fijas con un campo flexible en la misma tabla, lo que cubre buena parte de los casos en los que alguien elegiría una base de datos de documentos.

El driver más usado es pg (node-postgres). Su documentación recomienda crear un único pool para la aplicación y usar pool.query siempre que puedas, porque así el driver devuelve la conexión al pool por su cuenta:

// npm install pg
import pg from "pg";

// Un pool para toda la aplicación, creado una vez
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });

export async function buscarUsuario(email) {
  // $1 es un parámetro: el driver envía el valor por separado, sin riesgo de inyección SQL
  const { rows } = await pool.query(
    "SELECT id, nombre, creado_en FROM usuarios WHERE email = $1",
    [email],
  );
  return rows[0] ?? null;
}

export async function contarUsuarios() {
  const { rows } = await pool.query("SELECT count(*) AS total FROM usuarios");
  return Number(rows[0].total); // count(*) es int8 y llega como string
}

Ventajas: transacciones e integridad, jsonb para datos flexibles, las columnas json/jsonb llegan como objetos JavaScript y las fechas llegan como Date.

Desventajas y trampas: el driver devuelve int8 (incluido el resultado de count(*)) como string, porque un entero de 64 bits puede superar el rango seguro de Number. Abrir un Client nuevo en cada petición en lugar de usar el pool agota las conexiones del servidor; si ya te ha pasado, mira el error "too many connections".

MySQL con Node.js#

MySQL también es relacional, muy popular en los hostings y en el ecosistema PHP, con tutoriales y herramientas de sobra. En Node.js, el driver más usado es mysql2, que tiene API con Promises (mysql2/promise), pool de conexiones y prepared statements.

Ventajas: conocido si vienes de PHP o de un hosting compartido, transacciones con el motor InnoDB, amplio soporte en ORMs.

Desventajas: menos tipos avanzados que PostgreSQL, y algunas diferencias de comportamiento entre versiones y modos SQL. Para un proyecto nuevo sin restricciones, la diferencia práctica suele ser pequeña. La comparación detallada está en PostgreSQL o MySQL.

MongoDB con Node.js#

MongoDB guarda documentos parecidos a JSON en colecciones, sin esquema obligatorio. En Node.js, un documento llega como objeto JavaScript, lo que hace muy cómodo el primer contacto. El driver oficial es el paquete mongodb; Mongoose es una capa popular encima de él que añade esquemas y validación.

// npm install mongodb
import { MongoClient } from "mongodb";

// El cliente mantiene un pool interno: crea uno y reutilízalo
const client = new MongoClient(process.env.MONGODB_URI);
const configs = client.db("mibot").collection("configs");

// Guarda o actualiza la configuración de un servidor de Discord
export async function guardarConfig(guildId, config) {
  await configs.updateOne({ guildId }, { $set: config }, { upsert: true });
}

export async function leerConfig(guildId) {
  return configs.findOne({ guildId });
}

Ventajas: ideal cuando lees y escribes el objeto entero de una vez (configuración por servidor de un bot, perfiles con campos opcionales, catálogos con atributos distintos). Cambiar la forma de los datos no exige migración.

Desventajas: sin esquema, la validación queda en tus manos (en el código, en Mongoose o en reglas de la base de datos). Las relaciones y las transacciones entre varios documentos existen, pero pesan más que en una base de datos relacional. El paso a paso de la conexión está en cómo conectar MongoDB a Node.js.

Redis con Node.js#

Redis guarda los datos en memoria, con acceso por clave, y responde muy rápido. Rara vez es la única base de datos: su papel clásico es ser la segunda, junto a PostgreSQL o MongoDB, para caché, sesiones, colas, contadores y límites de peticiones. El cliente oficial en npm es el paquete redis (node-redis):

// npm install redis
import { createClient } from "redis";

const redis = await createClient({ url: process.env.REDIS_URL })
  .on("error", (err) => console.error("Error en Redis", err))
  .connect();

// Cooldown de 10 segundos por usuario: NX solo escribe si la clave todavía no existe
export async function enCooldown(userId) {
  const resultado = await redis.set(`cooldown:${userId}`, "1", {
    expiration: { type: "EX", value: 10 },
    condition: "NX",
  });
  return resultado === null; // null = la clave ya existía
}

Ventajas: latencia muy baja, expiración automática de claves, estructuras listas para usar (listas, conjuntos, hashes).

Desventajas: los datos tienen que caber en memoria, y lo que no se haya persistido puede perderse en una caída. No lo uses como base de datos principal para datos que no puedes perder. Más en qué es Redis.

¿Y SQLite?#

SQLite es una base de datos entera dentro de un archivo, sin servidor. En Node.js hay dos caminos: el paquete better-sqlite3, muy usado, y el módulo nativo node:sqlite, incluido en las versiones recientes de Node (consulta en la documentación de tu versión su nivel de estabilidad).

Ventajas: cero configuración, ideal para prototipos, scripts, herramientas de línea de comandos y bots pequeños de un solo proceso.

Desventajas: un escritor a la vez, y el archivo vive en el disco de esa máquina. Si ejecutas varias réplicas, o si otro servicio necesita leer los mismos datos, pasa a una base de datos cliente-servidor.

¿Qué base de datos elegir en cada escenario?#

Si tienes dudas, empieza por PostgreSQL. Si ya usas TypeScript y quieres tipos generados a partir del esquema, un ORM como Prisma o Drizzle encima de PostgreSQL o MySQL es un buen añadido, pero no un requisito. Una vez elegida, el siguiente paso es alojar la aplicación Node.js y la base de datos en el mismo lugar, para mantener baja la latencia.

Cómo hacerlo en Square Cloud#

Square Cloud ofrece hosting de MongoDB, PostgreSQL, MySQL y Redis a partir del plan Standard (el Hobby no incluye bases de datos). Creas la base de datos en el panel, eligiendo nombre, memoria y motor, y se aprovisiona en segundos en el mismo datacenter que tus aplicaciones, con una latencia media de alrededor de 1 ms entre ellas.

En la práctica: copia la URL de conexión completa que te entrega el panel (se muestra una vez al crearla; restablecer la contraseña la muestra de nuevo) a una variable de entorno de tu aplicación Node.js, como DATABASE_URL o MONGODB_URI. Descarga el certificado: TLS es obligatorio, el driver tiene que confiar en la CA descargada y, en PostgreSQL y MongoDB, también presentar el certificado .pem. En Redis, la URL usa rediss://. Mantén un único pool para todo el proceso, ya que cada base de datos acepta hasta 512 conexiones y no hay pooler delante.

PostgreSQL es el nativo, sin extensiones, y Redis tiene persistencia. Puedes tomar snapshots manuales cuando quieras, y todo plan que incluye bases de datos tiene también un snapshot automático diario. Un snapshot se puede restaurar en la misma base de datos, en otra del mismo motor o en una nueva, o descargar como .zip. Mira las opciones en Bases de datos.