Mongoose para MongoDB - Guía Básica

En este artículo, veremos cómo empezar con Mongoose, una biblioteca ODM (Data Modeling) para interactuar con bases de datos MongoDB en Node.js.

Vamos a explicar los conceptos básicos de como funciona MongoDB y que son sus principales caracteristicas. Después vamos a profundizar en el uso de Mongoose para crear esquemas, modelos y bases de datos relacionadas en un entorno de desarrollo Node.js

Y finalmente, vamos a explorar algunas de las opciones más populares de servicios cloud o manuales para configurar tu base de datos MongoDB, para que puedas usarla sin problema alguno.

Definición y Uso

Mongoose es una biblioteca ODM (Data Modeling) utilizada en Node.js para interactuar con bases de datos MongoDB. Se utiliza principalmente para definir modelos de datos, validación y manipulación de documentos en la base de datos.

Para crear un modelo de datos en MongoDB, debemos usar la clase Mongoose.Schema. Este es el primer paso indispensable al momento de crear una conexión entre nuestra aplicación y la base de datos. El siguiente paso implicaría instanciar o crear un nuevo objeto llamado 'modelo' a partir del esquema definido.

Terminologías MongoDB vs SQL

Aunque MongoDB es una base de datos NoSQL y SQL es un lenguaje relacionales, muchos desarrolladores son conscientes del concepto básico de tablas, filas y columnas en SQL. En cambio, MongoDB usa colecciones, documentos y campos.

Colecciones vs Tablas

Una colección en MongoDB es similar a una tabla en SQL, pero con algunas diferencias clave:

• La estructura de los datos no está definida por adelantado, como sucede con las tablas en SQL.
• No hay un número determinado de columnas y campos que siempre deben existir.

Documentos vs Filas

Un documento es similar a una fila en SQL, pero también tiene estructura. Un documento MongoDB puede tener:

• Diferentes campos y valores, dependiendo de la información que se quiera almacenar.
• También puede tener subdocumentos o documentos anidados.

Campos vs Columnas

Los campos en un documento son similares a las columnas de una tabla en SQL, pero con algunas diferencias clave:

• Los campos no tienen que ser de un tipo específico, como números enteros.
• Pueden tener cualquier valor o contenido.

Ejemplo de Esquema Mongoose

Para crear un esquema para un modelo de datos llamado Puppy, podemos utilizar la clase SchemaType y objetos específicos como required.

```javascript
const mongoose = mongoose;
const Schema = mongoose.Schema;

// Definir el esquema del modelo de datos Puppy
const puppySchema = new Schema({
name: {
type: String,
required: true
},
breed: {
type: String,
required: true
},
age: {
type: Number,
required: true
}
});

// Crear un modelo de datos Puppy a partir del esquema
const Puppy = mongoose.model('Puppy', puppySchema);
```

En este ejemplo, el esquema puppySchema define las propiedades de un documento de MongoDB que representa a un perro. Las propiedades se definen utilizando objetos específicos como required, que garantiza que esos campos siempre estén presentes en los documentos.

Instalación y Configuración del Entorno

Para empezar, es necesario instalar MongoDB, que puede ser hecho de varias maneras.

Descargar Directamente

Si prefieres trabajar directamente sin servicios como Mongoose, puedes descargar la versión más reciente desde el sitio web oficial de MongoDB y seguir sus instrucciones para la instalación manual.

Usando Servicios en Línea

Alternativamente, existen servicios como mLab que te permiten subir tu base de datos a la nube sin tener que preocuparte por instalar MongoDB localmente. Aunque esta opción puede ser más rápida y fácil, es importante recordar que el Mongoose trabaja con bases de datos locales y en la nube.

Crear un Entorno con Docker

Una tercera opción consiste en utilizar herramientas como Docker para crear un entorno completo e independiente donde puedes instalar MongoDB sin tener que preocuparte por la configuración del sistema host. Esto puede ser especialmente útil cuando trabajas en proyectos colaborativos o necesitas reproducir el mismo ambiente de desarrollo y producción.

Con una de estas opciones, estás listo para empezar a explorar cómo Mongoose interactúa con MongoDB.

Creación de un Proyecto Node con Mongoose

1. Creación del Proyecto de Node.js

Empezamos creando un proyecto básico en Node.js, lo cual es bastante sencillo, solo necesitaremos ejecutar el comando npm init -y.

Luego, tenemos que instalar Mongoose mediante npm con el siguiente comando: npm install mongoose. Es importante recordar que también podemos utilizar yarn para realizar esta tarea.

A continuación, debemos instalar joi, una biblioteca de validaciones para JavaScript. Para ello ejecutamos los siguientes comandos en nuestra terminal:

```bash
npm install joi

yarn add joi
```

2. Creando un modelo con Mongoose

Ahora es momento de crear nuestro primer modelo. Deberemos instanciar el objeto mongoose mongoose, que nos permitirá interactuar con MongoDB, y luego crearemos una colección en la cual guardaremos nuestros datos.

Para ello debemos configurar la conexión a nuestra base de datos de MongoDB y utilizar la clase Schema para definir nuestro esquema.

```javascript
const express = require('express');
require('dotenv').config();
const app = express();
app.use(express.json());
const mongoose = require('mongoose');

mongoose.connect(process.env.DB_URL).then(() => {
console.log("Conexión a la base de datos exitosa.")
}).catch((error) => {
console.log("Error: ", error);
});

const puppySchema = new mongoose.Schema({
name: String,
age: Number
});
```

Conección a la Base de Datos

Para establecer una conexión con MongoDB, debemos importar Mongoose y crear un objeto que represente nuestra base de datos mediante el método connect().

```javascript
const mongoose = require('mongoose');
const databaseUrl = 'mongodb://localhost:27017/mydatabase';
//const databaseUrl = 'mongodb+srv://username:password@clusterurl.com/database?retryWrites=true&w=majority'; // para conexión a clusters remotos

mongoose.connect(databaseUrl, {
useNewUrlParser: true,
useUnifiedTopology: true
})
.then(() => console.log('Connected to MongoDB'))
.catch(err => console.error('Could not connect to MongoDB', err));
```

En caso de que tengas un esquema ya configurado para una colección llamada "Puppy", puedes acceder a la base de datos y realizar operaciones de creación, lectura, actualización y eliminación sobre ella.

```javascript
const puppySchema = new mongoose.Schema({
name: String,
breed: String,
});

const Puppy = mongoose.model('Puppy', puppySchema);
```

Ahora que tienes una conexión a la base de datos y un esquema definido para tus datos, puedes seguir avanzando en tu proyecto.

Manejo de Errores y Excepciones

En la práctica del desarrollo de aplicaciones Node.js, es común encontrar situaciones donde se producen errores en el manejo de datos o excepciones al interactuar con bases de datos MongoDB mediante Mongoose. Al igual que cualquier otro framework o biblioteca, Mongoose no es ajeno a esta realidad y requiere una estrategia para manejarlos eficientemente.

Existen principalmente dos tipos de errores que podemos esperar en este contexto:

• Errores lógicos: Esto podría incluir problemas como campos obligatorios que se omiten durante el registro, tipos de datos incompatibles o restricciones de validación no cumplidas. Asegúrate de configurar las propiedades adecuadamente dentro del esquema Mongoose para evitar esta situación.
• Errores relacionados con la base de datos: Estos podrían incluir problemas como fallos en la conexión a MongoDB, errores al ejecutar operaciones CRUD o conflictos por concurrentes acceso. Cuando utilices métodos de Mongoose como save() o update(), ten cuidado de manejar cualquier excepción que pueda generarse.

Al abordar este tipo de problemas es importante recordarte:

• No te desanimes: Manejando los errores y excepciones adecuadamente hará que tu aplicación sea más resiliente y proporcionará una experiencia mejorada para el usuario.
• Prueba y mejora: Pruebas son esenciales para garantizar que tus aplicaciones funcionen como se espera. Identifica los problemas, resuelve y haz que sean menos frecuentes.

La siguiente sección mostrará cómo manejar algunos de estos escenarios en un proyecto de ejemplo utilizando Mongoose.

Operaciones CRUD con Mongoose

Las operaciones de tipo Creación (C), Lectura (R), Actualización (U) y Eliminación (D) son las acciones básicas que cualquier aplicación puede realizar sobre su modelo de datos.

1. Crear un Nuevamente documento en la base de datos

Cuando deseamos insertar un nuevo objeto o registro a una colección de MongoDB, podemos utilizar el método insert() de Mongoose en conjunto con el esquema correspondiente:

```javascript
// El archivo de configuración de Mongoose contiene el modelo: const Puppy = mongoose.model('Puppy', puppySchema);

let newDog = {
name: "Bella",
age: 3,
};

const createdDoc = await Puppy.create(newDog);
console.log(createdDoc); // Verificamos que la operación ha sido exitosa.
```

2. Obtener una colección completa de documentos

Para acceder a todos los registros dentro de una colección, puedes utilizar el método find() del modelo correspondiente:

javascript
const allDogs = await Puppy.find().then((dogs) => console.log(dogs)).catch(console.error); // Obtenemos y mostramos toda la información.


3. Actualizar un Documento Existente

Si deseas modificar algún valor de una colección, puedes hacerlo a través del método updateOne():

javascript
const updatePuppy = await Puppy.updateOne({ age: 5 }, { $set: { name: "Guay", } });
console.log(updatePuppy); // Verificamos que la operación ha sido exitosa.


4. Eliminar un Documento de la Base de Datos

Para eliminar registros específicos puedes utilizar el método deleteOne():

javascript
const delDog = await Puppy.deleteOne({ name: "Calle" });
console.log(delDog); // Verificamos que la operación ha sido exitosa.


5. Eliminar todos los Documentos de un Modelo

Si deseas eliminar todos los documentos almacenados en una colección, puedes utilizar el método deleteMany() del modelo correspondiente:

javascript
const allDogs = await Puppy.deleteMany().then((dogs) => console.log(dogs)).catch(console.error); // Obtenemos y mostramos toda la información.


Estas operaciones representan las acciones de CRUD (Create, Read, Update, Delete) más comunes que se pueden realizar en MongoDB utilizando Mongoose.

Conclusión

Al finalizar esta guía, se espera que tengas una comprensión básica sobre cómo utilizar la herramienta de Mongoose para interactuar con bases de datos MongoDB desde Node.js. A lo largo del camino, exploramos conceptos clave como definir esquemas y crear conexiones a bases de datos. Este conocimiento te permitirá empezar a usar Mongoose en tus proyectos, incluso aunque no hayas trabajado antes con este framework.

Con el conocimiento básico adquirido en esta guía, puedes comenzar a crear tus propios modelos y manipular la información almacenada en MongoDB de una forma más estructurada. Es importante recordar que mongoose, al ser un modelo de datos flexible, te permite ampliar su funcionalidad según las necesidades específicas de tu proyecto.

Recuerda, esta guía es solo el comienzo de tu viaje con Mongoose. A medida que sigas practicando y aprendiendo más sobre Node.js, MongoDB y la herramienta en sí misma, podrás explorar características avanzadas y realizar tareas mucho más complejas de manera efectiva.

Al finalizar esta guía, te invito a explorar otros recursos y a seguir aprendiendo acerca del funcionamiento de Mongoose y como funciona la base de datos MongoDB.

Si quieres conocer otros artículos parecidos a Mongoose para MongoDB - Guía Básica puedes visitar la categoría Programacion.