📂 Crear colecciones (Collection)

En MongoDB, una colección es el contenedor de documentos (equivalente a una tabla en SQL). Aunque MongoDB crea colecciones automáticamente al insertar el primer documento, hay situaciones en las que crear la colección explícitamente ofrece ventajas: definir validadores, opciones (capped, size), índices iniciales, configuración de particionado (sharding), etc. Aquí tienes una guía paso a paso y ejemplos para una tienda online.

🔧 Herramientas a utilizar

mongosh — consola interactiva (línea de comandos).
MongoDB Compass — GUI oficial (crear colecciones, validadores, índices visualmente).
Driver oficial de Node.js o Mongoose — para crear/usar colecciones desde tu aplicación.
Atlas (si usas la nube) — creación desde UI o mediante la consola/CLI.

1️⃣ Conceptos rápidos antes de crear

Colección normal: almacenamiento dinámico, sin límite predeterminado.
Colección capped: tamaño fijo, comportamiento FIFO, útil para logs o colas.
Validadores/JSON Schema: permiten garantizar estructura mínima.
Índices: mejoran lecturas; se pueden crear al crear la colección o después.
TTL index: índice que elimina documentos después de X segundos (útil para sesiones, tokens).
Sharding: particionado horizontal para colecciones muy grandes (requiere replica set y sharding habilitado).

2️⃣ Crear colección con `mongosh` — paso a paso

Ejemplo: colección products y orders para una tienda online.

// Conectar con mongosh y seleccionar DB
mongosh
use tiendaDB

// 1) Crear colección simple (se crea automáticamente al insertar, pero lo hacemos explícito)
db.createCollection("products")

// 2) Crear colección con validador JSON Schema (estructura mínima garantizada)
db.createCollection("products", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "price", "sku", "stock"],
      properties: {
        name: { bsonType: "string" },
        price: { bsonType: "double" },
        sku: { bsonType: "string" },
        stock: { bsonType: "int" },
        categories: { bsonType: "array" }
      }
    }
  },
  validationLevel: "moderate" // o "strict"
})

// 3) Colección capped (logs)
db.createCollection("eventLogs", { capped: true, size: 10485760 }) // 10 MB

// 4) Índice TTL en 'createdAt' para eliminar sesiones tras 24h (86400s)
db.sessions.createIndex({ "createdAt": 1 }, { expireAfterSeconds: 86400 })

Nota: createCollection permite opciones; si prefieres, simplemente inserta el primer documento y MongoDB creará la colección por ti.

3️⃣ Crear y configurar colecciones con MongoDB Compass

Abrir Compass y conectar a mongodb://localhost:27017 o a tu cluster Atlas.
Seleccionar la base de datos (o crear nueva → Create Database).
Click en Create Collection → escribe el nombre (ej. products).
(Opcional) En Settings añade Validation con JSON Schema.
Crear índices desde la pestaña Indexes.

4️⃣ Ejemplos prácticos — estructura recomendada para la tienda online

Algunas colecciones útiles y su propósito:

products: catálogo de productos (name, sku, price, stock, categories, images, attributes).
usuarios: datos de clientes (nombre, email, passwordHash, direccion, roles).
orders: pedidos (referencia al usuario, array de items, totals, estado, createdAt).
carts: carritos temporales (userId o sessionId, items).
sessions: sesiones de usuario (sessionId, userId, createdAt) - usar TTL index.
eventLogs: logs de eventos (capped collection recomendable).

// Ejemplo: insertar un producto mínimo
db.products.insertOne({
  name: "Camiseta básica",
  sku: "CAM-001",
  price: 19.99,
  stock: 120,
  categories: ["ropa","hombre"],
  createdAt: new Date()
})

// Ejemplo: insertar un pedido
db.orders.insertOne({
  userId: ObjectId("..."),
  items: [
    { productId: ObjectId("..."), qty: 2, price: 19.99 }
  ],
  total: 39.98,
  status: "pending",
  createdAt: new Date()
})

5️⃣ Índices recomendados por colección

products: { sku: 1 } (único), { price: 1 } si buscas por precio, { "categories": 1 }.
usuarios: { email: 1 } (único), { createdAt: -1 }.
orders: { userId: 1, createdAt: -1 }, { status: 1 }.
sessions: TTL index en createdAt.

// Crear índice único en sku
db.products.createIndex({ sku: 1 }, { unique: true })

// Índice compuesto en orders
db.orders.createIndex({ userId: 1, createdAt: -1 })

6️⃣ TTL y colecciones capped — cuándo usarlas

TTL index: elimina documentos después de X segundos — ideal para tokens temporales, sesiones.
Capped collection: tamaño fijo, escrituras rápidas y orden FIFO — ideal para logs o colas de eventos donde solo interesa lo más reciente.

// TTL en sessions (ejemplo 24 horas)
db.sessions.createIndex({ "createdAt": 1 }, { expireAfterSeconds: 86400 })

// Crear capped collection para logs (5 MB)
db.createCollection("logsApp", { capped: true, size: 5242880 })

7️⃣ Sharding: cuándo shardear una colección y ejemplo

Sharding es para colecciones muy grandes que exceden la capacidad de un solo servidor. Requiere:

Replica set habilitado.
Sharding activado en el cluster.

Elige la shard key con cuidado (debe distribuir uniformemente y usarse en consultas frecuentes).

// Habilitar sharding (en mongos) y shardear
sh.enableSharding("tiendaDB")
db.products.createIndex({ sku: 1 })              // índice necesario
sh.shardCollection("tiendaDB.products", { sku: 1 })

Consejo: evita shard keys con valores con poca cardinalidad (ej. booleanos) o monotonía (ej. timestamps) que causan hot shards.

8️⃣ Crear y usar colecciones desde Node.js (ejemplo mínimo)

// npm install mongodb
const { MongoClient } = require("mongodb");

async function run() {
  const client = new MongoClient("mongodb://localhost:27017");
  await client.connect();
  const db = client.db("tiendaDB");

  // Crear colección explicitamente (opcional)
  await db.createCollection("products");

  const products = db.collection("products");
  await products.insertOne({ name: "Zapatos", sku: "ZAP-100", price: 49.99, stock: 30, createdAt: new Date() });

  const p = await products.findOne({ sku: "ZAP-100" });
  console.log(p);

  await client.close();
}

run().catch(console.error);

9️⃣ Crear modelos/colecciones con Mongoose

// npm install mongoose
const mongoose = require("mongoose");

async function main(){
  await mongoose.connect("mongodb://localhost:27017/tiendaDB");

  const productSchema = new mongoose.Schema({
    name: { type: String, required: true },
    sku: { type: String, required: true, unique: true },
    price: { type: Number, required: true },
    stock: { type: Number, default: 0 },
    categories: [String],
    createdAt: { type: Date, default: Date.now }
  });

  const Product = mongoose.model("Product", productSchema); // crea colección 'products' automáticamente

  const p = await Product.create({ name: "Gorra", sku: "GOR-01", price: 9.99 });
  console.log("Creado:", p._id);
}

main().catch(console.error);

🔐 Buenas prácticas y consideraciones

Nombrar colecciones en plural o según convención del equipo (products, orders).
Definir validaciones básicas para evitar documentos incorrectos.
Crear índices basados en consultas reales, no por suposiciones.
Usar TTL para datos temporales (sessions, tokens).
Evaluar embedding vs referencing: embed si accedes siempre al subdocumento con el padre; referenciar si subdocumentos crecen sin límite o se comparten.
Para gran escala, planificar shard key con datos de cardinalidad alta y buen patrón de acceso.

🔁 Resumen práctico (checklist)

Decide si crear la colección explícitamente o dejar que se cree al insertar el primer documento.
Define validadores/JSON Schema si necesitas restricción mínima.
Crea índices importantes inmediatamente (ej. sku, email).
Considera TTL/capped collections para casos específicos.
Si esperas gran volumen, planifica sharding y replica sets con antelación.
Documenta convención de nombres y estructura esperada para el equipo.

← Volver al índice

📂 Crear colecciones (Collection)