🍃 2.9 · MongoDB y Mongoose: la base de datos NoSQL más popular

🎯 Objetivo del tema

🗺️ Mapa del tema

En los Temas 2.4 y 2.8 aprendiste bases de datos RELACIONALES: MySQL y PostgreSQL, donde los datos viven en tablas con esquemas fijos. Hoy conocerás el paradigma OPUESTO: MongoDB, donde los datos viven en documentos JSON flexibles, sin esquema fijo. Cada una tiene su lugar: SQL para datos estructurados y consistentes, NoSQL para datos flexibles, semi-estructurados, o de alto volumen.

2.9.1 Qué es NoSQL y cuándo usarlo

NoSQL (Not Only SQL) es un paraguas para bases de datos que NO usan el modelo relacional de tablas. Hay 4 tipos principales: documentos (MongoDB), clave-valor (Redis), columnar (Cassandra), y grafos (Neo4j). Cada una resuelve un problema distinto. La más popular y versátil es MongoDB: almacena documentos JSON flexibles, ideales para datos semi-estructurados.

2.9.2 MongoDB: documentos JSON, no tablas

MongoDB almacena datos en DOCUMENTOS JSON (en formato BSON internamente). Un documento se ve como un objeto JavaScript: { nombre: 'Ana', edad: 25, hobbies: ['leer', 'programar'] }. Los documentos similares se agrupan en COLECCIONES (equivalente a las tablas, pero sin esquema fijo). Cada documento tiene un _id único (UUID).

2.9.3 Mongoose: el ODM para Node.js

Mongoose es el ODM (Object Document Mapper) más popular para MongoDB con Node.js. Te da schemas con validación, modelos con métodos, queries con chaining, y middlewares. Es lo que necesitas para usar MongoDB con Node de forma profesional. Aprende Mongoose, no el driver nativo (que es más verboso).

// models/Usuario.js: schema y modelo de Mongoose
import mongoose from 'mongoose';

// Definir el SCHEMA (estructura y validación)
const usuarioSchema = new mongoose.Schema({
  nombre: {
    type: String,
    required: [true, 'El nombre es obligatorio'],
    trim: true,
    minlength: 2,
    maxlength: 100,
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    match: [/^\S+@\S+\.\S+$/, 'Email inválido'],
  },
  edad: {
    type: Number,
    min: [0, 'La edad no puede ser negativa'],
    max: 120,
  },
  activo: { type: Boolean, default: true },
  hobbies: [String],  // array de strings
  redes: {  // documento embebido
    twitter: String,
    github: String,
  },
  creadoEn: { type: Date, default: Date.now },
});

// Crear el MODELO (la clase con la que interactúas)
export const Usuario = mongoose.model('Usuario', usuarioSchema);

Schema y modelo con Mongoose

2.9.4 CRUD con Mongoose

Las 4 operaciones CRUD con Mongoose son muy similares a las de SQL, pero con sintaxis moderna de JavaScript. Mongoose devuelve Promises, así que puedes usar async/await. La sintaxis es limpia y potente.

import { Usuario } from './models/Usuario.js';

// CREATE: crear un usuario
const ana = await Usuario.create({
  nombre: 'Ana López',
  email: 'ana@mail.com',
  edad: 25,
  hobbies: ['leer', 'programar'],
  redes: { twitter: '@ana', github: 'anita' },
});

// READ: buscar usuarios
const todos = await Usuario.find({ activo: true });  // array
const ana   = await Usuario.findOne({ email: 'ana@mail.com' });  // un documento
const porId = await Usuario.findById('65abc...');  // por _id

// Con filtros, proyección, populate, etc.:
const adultos = await Usuario
  .where('edad').gte(18)
  .where('activo').equals(true)
  .select('nombre email')  // solo estos campos
  .sort('-creadoEn')       // descendente
  .limit(10)
  .populate('posts');      // reemplaza ObjectId con documento

// UPDATE: actualizar
const actualizado = await Usuario.findByIdAndUpdate(
  id,
  { edad: 26 },
  { new: true, runValidators: true }  // devuelve el nuevo y valida
);

// DELETE: eliminar
const eliminado = await Usuario.findByIdAndDelete(id);

CRUD completo con Mongoose

2.9.5 Modelado: embebido vs referencias

La decisión más importante en MongoDB: ¿guardo los datos EMBEBIDOS (subdocumentos) o como REFERENCIAS (ObjectId a otro documento)? Cada enfoque tiene trade-offs. La regla general: embebido para datos que SIEMPRE se leen juntos y son únicos del documento padre; referencias para datos que pueden existir independientemente o se consultan solos.

// EMBEBIDO: el comentario vive DENTRO del post
const post = {
  titulo: 'Mi primer post',
  autor: 'Ana',
  comentarios: [
    { usuario: 'Luis', texto: '¡Genial!', fecha: new Date() },
    { usuario: 'Sofía', texto: 'Me encantó', fecha: new Date() },
  ],
};
// Para obtener el post con sus comentarios: 1 query.

// REFERENCIA: los posts se guardan en su propia colección
// y el usuario solo guarda los ObjectIds
const usuario = {
  nombre: 'Ana',
  posts: [
    ObjectId('65abc123...'),  // referencia al post
    ObjectId('65def456...'),
  ],
};
// Para obtener el usuario con sus posts: 2 queries + populate
// populate('posts') reemplaza los ObjectIds con los documentos completos

Embebido vs Referencia en código

2.9.6 MongoDB Atlas: la BD en la nube gratis

MongoDB Atlas es la versión 'managed' de MongoDB en la nube: tú solo creas la BD y Atlas se encarga de backups, escalabilidad, actualizaciones, y seguridad. Tiene un plan gratuito (M0) con 512 MB de almacenamiento: suficiente para aprender, hacer proyectos pequeños, y tener tu BD accesible desde cualquier lugar del mundo sin instalar nada localmente.

Cómo conectar tu app a MongoDB Atlas

// .env (variables de entorno, NO subir a Git)
MONGODB_URI=mongodb+srv://usuario:password@cluster0.xxxxx.mongodb.net/mi_app?retryWrites=true&w=majority

// db.js: conexión con Mongoose
import mongoose from 'mongoose';

const conectarDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI);
    console.log('Conectado a MongoDB Atlas');
  } catch (error) {
    console.error('Error de conexión:', error.message);
    process.exit(1);
  }
};

export default conectarDB;

// server.js: llamar antes de iniciar Express
import conectarDB from './db.js';
conectarDB().then(() => {
  app.listen(3000, () => console.log('Servidor en puerto 3000'));
});

Conexión a MongoDB Atlas con Mongoose

📚 Contenido ampliado

Material adicional, referencias externas verificadas y ejemplos extendidos.