Mongoose: Simplificando MongoDB para Node.js
Dentro del dominio de Node.js y MongoDB, Mongoose desempeña un papel crucial como una de las bibliotecas más ampliamente aceptadas. Sirve como interfaz entre las aplicaciones JavaScript y MongoDB. Este artículo explorará Mongoose en profundidad.
Mongoose es un mapeador de documentos de objetos (ODM). La mayoría de los desarrolladores lo utilizan debido a su capacidad para simplificar la gestión de datos para MongoDB y Node.js. Mongoose proporciona capacidades de validación integradas, lo que le permite asegurarse de que los datos insertados en la base de datos cumplan con los requisitos específicos. Esto reduce el riesgo de almacenar datos no válidos o incoherentes. Con el modelo, puede crear representaciones reutilizables y orientadas a objetos de sus datos, lo que mejora la organización y la legibilidad del código. También puede desarrollar Schema para organizar los datos y controlar el acceso a MongoDB. El sistema de plugins también te permite ampliar su funcionalidad añadiendo características o comportamientos personalizados.
Instalación y configuración de Mongoose a nivel global
Para empezar, asegúrese de haber instalado MongoDB y Node.js.
A continuación, instale desde la línea de comandos usando npm:
npm install mongoose --save
Ahora que ha instalado con éxito su paquete Mongoose, podemos comenzar a configurar nuestra conexión.
Comience por crear una carpeta para su aplicación.
En la misma carpeta, cree otro archivo llamado , agregue la variable y pegue la cadena de conexión allí.
.envMONGO_URI
A continuación se muestra una descripción general del aspecto de la cadena de conexión
- Reemplácela con la contraseña de su base de datos.
<< password >> - Ahora crea una nueva carpeta, y dentro de ella un nuevo archivo, . En este archivo, escribiremos el código para conectarnos con Mongoose e importarlo a nuestro archivo .
dbconnectDB.jsapp.js
Asegúrese de almacenar la contraseña de su base de datos creada durante el proceso de configuración de MongoDB, de forma segura. Si no se protege, los piratas informáticos podrían acceder a su base de datos, lo que les permitiría manipular la información almacenada en su interés.
const mongoose = require("mongoose");
const connectDB = (URI) => {
return mongoose
.connect(URI)
.then(() => console.log("connected to the database"))
.catch((err) => console.log(err));
};
module.exports = connectDB;
La primera línea de código incluye la biblioteca Mongoose. A continuación, abro una conexión a una base de datos utilizando la función.connect()
Después de crear el archivo, cree otro archivo llamado . Aquí, importaremos nuestro archivo para conectarnos con éxito a la base de datos.connectDB.jsapp.jsconnectDB
const connectDB = require("./db/connectDB");
const start = async () => {
try {
await connectDB(process.env.MONGO_URI);
});
} catch (error) {
console.log(error);
}
};
start();
Ejecute su servidor y obtendrá un texto similar a este conectado a la base de datos de su terminal.
Ahora, ha completado la configuración de su conexión.
Clases de errores que puede encontrar al configurar su conexión Mongoose
Antes de establecer la conexión, es esencial crear el clúster de base de datos de MongoDB. Este paso es crucial para garantizar una configuración de conexión sin problemas. Si no lo hace, es posible que se produzcan errores al configurar el proceso de conexión. Para obtener información sobre cómo trabajar con MongoDB, consulte la documentación de MongoDB.
Dos clases principales de errores que pueden ocurrir con la conexión, que son los errores en la conexión inicial y los errores después de que se estableció la conexión inicial.
Error en la conexión inicial
Las razones comunes para este tipo de error incluyen:
- Cadena de conexión no válida: Aquí, la cadena de conexión utilizada para conectarse a la base de datos de MongoDB puede ser incorrecta o tener un formato incorrecto.
- Problemas de red: Varios problemas, incluidas las restricciones del firewall o la latencia de la red, pueden dificultar el establecimiento de una conexión.
- Indisponibilidad del servidor: Cuando el servidor de MongoDB está fuera de línea o es inaccesible debido a problemas de red, se producirá un error.
Para gestionar los errores en la conexión inicial, tiene dos opciones disponibles a tener en cuenta.
A continuación se muestra un ejemplo de un código.
mongoose.connect('mongodb://localhost/mongoose_guide').
catch(error => handleError(error));
// Or you can use the other option below:
try {
await mongoose.connect('mongodb://localhost/mongoose_guide');
} catch (error) {
handleError(error);
}
En el código anterior, usamos nuestras dos opciones disponibles para manejar cualquier error que pudiera encontrarse en nuestra conexión inicial.
Error después de establecer la conexión inicial
Las razones comunes para este tipo de error incluyen:
- Errores de consulta: Los errores de consulta de la base de datos pueden surgir de problemas como una sintaxis de consulta incorrecta, el uso incorrecto de métodos o el intento de operaciones en documentos inexistentes.
- Errores de validación de documentos: En los errores de validación de documentos, puede crear esquemas y aplicar reglas de validación para los documentos. Si un documento no cumple con los procedimientos de validación definidos en su esquema, se producirá un error.
const getTasksId = async (req, res) => {
try {
const { id: taskID } = req.params;
const task = await taskSchema.findById({ _id: taskID });
if (!task) {
return res.status(404).send(`Your _id : ${taskID} value is incorrect`);
}
res.status(200).json({ task });
} catch (error) {
res.status(500).json({ error });
}
};
En el código anterior, hicimos uso de nuestra opción disponible para manejar errores cuando queremos recuperar cualquier información de nuestra base de datos, y cada vez que enviamos una solicitud para obtener información de documentos inexistentes, se nos envía un mensaje de error personalizado. Para gestionar eficazmente los errores una vez que se establece la conexión inicial, es importante supervisar los eventos de error en la conexión.
La gestión eficaz de errores es esencial para crear aplicaciones fiables. El empleo de técnicas de control de errores, como bloques try-catch, detectores de eventos de error y un registro exhaustivo de la consola, puede ayudar a identificar y resolver problemas sin mucho estrés.
Trabajar con esquemas: Cómo crear esquemas personalizados
Las estructuras de datos se configuran mediante objetos JavaScript. Estas estructuras actúan como plantillas para sus datos en MongoDB. Por ejemplo, la definición de un esquema básico podría tener el siguiente aspecto:
const mongoose = require('mongoose');
const studentSchema = new mongoose.Schema({
department : String,
name: String,
degree: String,
contact: Number,
});
// below is another structure of schema
const taskSchema = new mongoose.Schema({
name: {
type: String,
required: [true, "please enter your name"],
trim: true,
maxlength: [30, "maximum character is 30"],
},
completed: {
type: Boolean,
default: false,
},
email: {
type: String,
// required: [true, "please enter your email"],
},
});
Se aceptan estrictamente algunos tipos de esquema: string, number, date, buffer, boolean, mixed, objectId, array, decimal128, map y uuid. Ahora ha creado y definido su esquema.
Cómo crear un modelo personalizado con Mongoose
Un modelo es una función constructora que representa un documento dentro de una colección de MongoDB.
Una vez que se ha definido el esquema, se le concede acceso para crear modelos basados en ese esquema. Los modelos tienen la tarea de realizar interacciones con nuestras colecciones de MongoDB cuando realizamos operaciones CRUD. Crear un modelo para nuestro esquema no debería ser un gran problema. A continuación, se muestra un ejemplo de cómo crear su modelo.
const mongoose = require('mongoose');
// Define a schema for the documents in the collection
const taskSchema = new mongoose.Schema({
name: {
type: String,
required: [true, "please enter your name"],
trim: true,
maxlength: [30, "maximum character is 30"],
},
completed: {
type: Boolean,
default: false,
},
email: {
type: String,
// required: [true, "please enter your email"],
},
});
// Create a model based on the schema
const Task = mongoose.model('Task', taskSchema)
Espero que hayas disfrutado definiendo y creando tu primer esquema y modelo, ahora vamos a ver cómo implementar las poderosas operaciones CRUD.
Énfasis en cómo realizar operaciones CRUD en Mongoose
Existe una amplia gama de métodos para realizar operaciones , , y (CRUD) en sus datos en la base de datos, mediante el uso de estas operaciones, los usuarios tienen la libertad de datos, tienen acceso a los datos en la interfaz de usuario para poder los datos y los datos.createreadupdatedeletecreatereadupdatedelete
- Uso de la operación
Create() La operación create se utiliza para crear nuevos documentos de modelo. Sin embargo, también es una abreviatura para crear uno o más documentos en la base de datos. A continuación se muestra un ejemplo de código.
const createProfile = async (req, res) => {
try {
const profile = await studentSchema.create({ department : 'Computer Science' });
res.status(201).json({ profile });
} catch (error) {
res.status(500).json({ error });
}
};
A partir del código anterior, creamos un perfil que alberga el departamento de nuestro estudiante en la base de datos.
- Mediante la operación
Read() La operación de lectura le otorga acceso para ver toda la información de la base de datos. Usando el método, podemos recuperar información en la base de datos que coincide con la consulta para obtener y leer la información almacenada en la base de datos.find()
const createProfile = async (req, res) => {
try {
const profile = await studentSchema.create({ department : 'Computer Science' });
res.status(201).json({ profile });
} catch (error) {
res.status(500).json({ error });
}
};
- Uso de la operación
Update() La operación de actualización busca primero el registro consultado en la base de datos. Recupera y luego modifica los datos de acuerdo con la elección del usuario. Puede utilizar diferentes métodos, como , , y , para actualizar los datos de nuestra base de datos. Sin embargo, en este artículo, nos centraremos solo en el método para actualizar un determinado dato proporcionando sus datos _id. A continuación se muestra un ejemplo de código.updateMany()findByIdAndUpdate()findOneAndUpdate()updateOne()findByIdAndUpdate()
const updateProfile = async (req, res) => {
const profile = await studentSchema.findOneAndUpdate(
{_id: profileID},{department:'Electrical Engineering'},{
new: true,
runValidators: true,
}
);
if (!profile) {
return res
.status(404)
.send(
`Unable to update the id, make sure you have entered the correct id`
);
}
res.status(200).json({ profile });
};
Cuando creamos información en la sección de recopilación en MongoDB, automáticamente se crea un para nosotros. Este código encuentra ese particular y actualiza el valor de nuestro departamento, inicialmente de Ciencias de la Computación a Ingeniería Eléctrica. Si no se encuentra, se nos devuelve el error._id_id_id
- Usando la operación
Delete() La operación Delete nos da muchas opciones que podemos usar para eliminar nuestra información de la base de datos. Aquí nos centraremos solo en . Echa un vistazo al código a continuación para una mejor comprensión.findByIdAndDelete()
const deleteProfile = async (req, res) => {
try {
const profile = await studentSchema.findByIdAndDelete({_id: profileID},{department:'Electrical Engineering'},);
if (!profile) {
return res
.status(404)
.send(
`in other to delete the id, please provide the correct id`
);
}
res.status(200).send(` Id has been deleted`);
} catch (error) {
res.status(500).json({ error });
}
};
Este código obtiene la información de la identificación en particular que solicitó eliminar y se asegura de que la información contenida en esa identificación en particular se elimine de la base de datos.
Consultas: Descripción de cómo ejecutar consultas de Mongoose
Al realizar nuestras operaciones CRUD anteriormente, se ha encontrado con consultas. En esta sección del artículo, explicaré brevemente con ejemplos de código, centrándome solo en algunas consultas para asegurarme de que lo entienda mejor.
find()
await studentSchema.find({ score: { $gte: 75 } }).exec()
Este código ejecuta y encuentra a todos los estudiantes con puntuaciones mayores o iguales a 75.
deleteMany()
await studentSchema.deleteMany({score: { $lt: 25 } });
Este código ejecuta y elimina a todos los estudiantes con puntuaciones inferiores a 25.
Con estos pocos ejemplos ilustrados anteriormente, creo que ha entendido cómo trabajar con consultas. Para obtener más información sobre otras opciones de consulta, visite Consultas de Mongoose.
Mongoose Plugins: Ilustrando cómo registrar un plugin global para todos los esquemas
Los plugins ofrecen una forma cómoda de reutilizar la lógica en varios esquemas. Suponiendo que tiene más de un modelo en su base de datos y desea incluir una propiedad «loadedAt» en cada uno de ellos. Al crear un complemento una vez, puede aplicarlo a todos los esquemas. A continuación se muestra una ilustración del ejemplo de código.
const mongoose = require('mongoose');
mongoose.plugin(require('./loadedAt'));
const studentSchema = new Schema({ /* ... */ });
const developerSchema = new Schema({ /* ... */ });
const Student = mongoose.model('Student', studentSchema);
const Developer = mongoose.model('Developer', developerSchema);
Nuestro complemento global ha agregado con éxito la propiedad «loadedAt» a nuestro archivo y .studentSchemadeveloperSchema
Conclusión
Después de revisar este artículo, debe estar equipado con conocimientos sobre los esquemas y modelos de Mongoose, implementarlos y ser capaz de administrar la creación y las actualizaciones de documentos mediante CRUD de manera eficiente.
A estas alturas, deberías sentirte seguro de tu comprensión de Mongoose. Para obtener más información, considere explorar las Guías de Mongoose, que exploran conceptos más avanzados como validación, población, middleware y más.
