Operaciones CRUD de Node.js con Mongoose y MongoDB Atlas

Antes de sumergirnos en las principales operaciones y funcionalidades de Mongoose, tengamos una breve idea de lo que realmente es y cómo hace que nuestro proyecto Node.js sea más flexible y fácil de usar.

MongooseJs: Mongoose es básicamente un paquete que sirve como mediador entre la aplicación NodeJS y el servidor MongoDB. Es un mapeador de documentos de objetos (ODM) que nos permite definir objetos con un esquema fuertemente tipado que se asigna a un documento MongoDB. Mongoose admite todas las operaciones CRUD: creación, recuperación, actualización y eliminación.

Requisitos previos: dado que usaremos Express para configurar nuestro servidor básico, le recomendamos leer algunos artículos sobre documentos express y express oficiales. Otros requisitos incluyen MongoDB Atlas y Postman.

Instalación: Instale mongoose y express module a través de npm usando el siguiente comando:

npm install express mongoose --save

Configuración de MongoDB Atlas: 

• Configure una cuenta.
• Cree un nuevo clúster.
• Vaya a Acceso a la base de datos y presione «Agregar nuevo usuario». Agregue un nombre de usuario y una contraseña, si genera automáticamente una contraseña, asegúrese de copiarla, la necesitaremos más adelante.
• Incluya en la lista blanca su dirección IP. Presione «Agregar dirección IP actual» y confirme.
• Vaya a Clústeres, si la creación de su clúster está lista, presione Conectar, «Conectar su aplicación» y copie la URL que le proporciona.

Configuración de Postman: Usaremos Postman para administrar nuestras requests. Una vez que se haya descargado, presione la opción «Crear una solicitud». Cada vez que creamos un nuevo punto final de API, configuraremos otra solicitud para él. Esto lo ayudará a administrar todo para que no tenga que copiar y pegar requests HTTP en todas partes.

Configuración del servidor: Aquí, configuraremos nuestro servidor en el puerto 3000 y llamaremos a la función express que devuelve un objeto de servidor en una aplicación llamada variable. Luego iniciamos el oyente diciendo app.listen con la dirección del puerto. Finalmente, creamos la ruta /api que se activará una vez que se reciba la solicitud localhost:3000/api desde el navegador. 

Nombre del archivo: Servidor.js

const express=require('express');
const bodyParser=require('body-parser');
const api = require('./api');
 
const port=3000;
const app=express();
  
app.listen(port, function() {
    console.log("Server is listening at port:" + port);
});
 
// Parses the text as url encoded data
app.use(bodyParser.urlencoded({extended: true}));
 
// Parses the text as json
app.use(bodyParser.json());
 
app.use('/api', api);

Servidor ejecutándose en el puerto deseado

Salida de muestra para verificar el funcionamiento de la ruta api

Esquema: El esquema es una representación de la estructura de los datos. Nos permite decidir exactamente qué datos queremos y qué opciones queremos que tengan los datos como objeto.

Nombre de archivo: Studentschema.js 

var mongoose=require('mongoose');
 
var StudentSchema = new mongoose.Schema({
    StudentId:Number,
    Name:String,
    Roll:Number,
    Birthday:Date,
    Address:String
});
 
module.exports = mongoose.model(
    'student', StudentSchema, 'Students');

Se crea un esquema denominado “StudentSchema” que acepta los campos Id, Name, Roll, Birthday, Address.

Los modelos básicamente proporcionan una lista de métodos predefinidos que se utilizan para manipular los datos para insertar, actualizar, eliminar y recuperar de la colección de la base de datos.

Con ese patrón básico, usaremos el método mongoose.model para que se pueda usar con datos reales y exportarlo para que podamos usarlo en api.js.

Enrutamiento avanzado y conexiones MongoDB: 

Nombre de archivo: api.js Cuando realiza una solicitud a localhost:3000/api, express buscará la ruta api y ejecutará el archivo api.js.

var mongoose = require('mongoose');
var express = require('express');
var router = express.Router();
var StudentModel = require('./studentschema');
 
// Connecting to database
var query = 'mongodb+srv://Username:<password>'
    + '@student.tuufn.mongodb.net/College?'
    + 'retryWrites=true&w=majority'
 
const db = (query);
mongoose.Promise = global.Promise;
 
mongoose.connect(db, { useNewUrlParser : true,
useUnifiedTopology: true }, function(error) {
    if (error) {
        console.log("Error!" + error);
    }
});
 
module.exports = router;

La base de datos es Colegio y la colección dentro de la base de datos en Estudiantes.

Un vistazo a la base de datos de Mongo

OPERACIONES CRUD 

• Crear: configuraremos una solicitud de publicación para ‘/ guardar’ y crearemos un nuevo objeto de estudiante con nuestro modelo y le pasaremos los datos de solicitud de Postman.

Una vez hecho esto, usaremos .save() para guardarlo en la base de datos.

router.get('/save', function(req, res) {
    var newStudent = new StudentModel({StudentId:101, 
        Name:"Sam", Roll:1, Birthday:2001-09-08});

    newStudent.save(function(err, data) {
        if(err) {
            console.log(error);
        }
        else {
            res.send("Data inserted");
        }
    });
});

Se crea una nueva instancia del estudiante utilizando StudentModel y la referencia se almacena en la variable newStudent. Usando la variable nuevoEstudiante guardamos el documento del nuevo estudiante en la colección de la base de datos.

Para lograr esto, en Postman haremos una solicitud GET localhost:3000/api/save

Nota: Incluso podemos insertar nuevos documentos sin codificar los campos como se hizo anteriormente. Para eso, necesitamos cambiar la solicitud de GET a POST y usar el middleware body-parser para aceptar los datos del nuevo estudiante. Esto asegura que podamos insertar detalles de tantos estudiantes como necesitemos.

router.post('/save', function(req, res) {
var newStudent = new StudentModel();
   newStudent.StudentId = req.body.StudentId;
   newStudent.Name = req.body.Name;
   newStudent.Roll = req.body.Roll;
   newStudent.Birthday = req.body.Birthday;
   
   newStudent.save(function(err, data){
       if(err){
           console.log(error);
       }
       else{
           res.send("Data inserted");
       }
   });
});

• Recuperar: para recuperar registros de una colección de base de datos hacemos uso de la función .find().

router.get('/findall', function(req, res) {
   StudentModel.find(function(err, data) {
       if(err){
           console.log(err);
       }
       else{
           res.send(data);
       }
   });  
});

En Postman, hacemos una nueva solicitud GET con la URL localhost:3000/api/findall y presionamos enviar. Realiza nuestra solicitud HTTP GET y devuelve documentos de todos los estudiantes de nuestra colección de base de datos.

• Para recuperar un solo registro o el primer documento coincidente hacemos uso de la función findOne(). 

router.get('/findfirst', function(req, res) {
    StudentModel.findOne({StudentId:{$gt:185}}, 
    function(err, data) {
        if(err){
            console.log(err);
        }
        else{
            res.send(data);
        }
    });  
});

En Postman, hacemos una nueva solicitud GET con la URL localhost:3000/api/findfirst y presionamos enviar. Realiza nuestra solicitud HTTP GET y devuelve el primer documento que coincide con la condición StudentId:$gt:185 ($gt significa mayor que ).

• Borrar: Para borrar un registro de la base de datos, hacemos uso de la función .remove(). Acepta una condición que es el parámetro según el cual realiza el borrado. Aquí la condición es Id:188.

router.get('/delete', function(req, res) {
    StudentModel.remove({StudentId:188}, 
    function(err, data) {
        if(err){
            console.log(err);
        }
        else{
            res.send(data);
        }
    });  
});

• También podemos usar el método .findByIdAndDelete() para eliminar fácilmente un registro de la base de datos. Cada objeto creado con Mongoose recibe su propio _id, y podemos usarlo para apuntar a elementos específicos con una solicitud DELETE. 

router.post('/delete', function(req, res) {
    StudentModel.findByIdAndDelete((req.body.id), 
    function(err, data) {
        if(err){
            console.log(err);
        }
        else{
            res.send(data);
            console.log("Data Deleted!");
        }
    });  
});

• Actualización: al igual que con la solicitud de eliminación, usaremos el _id para apuntar al elemento correcto. .findByIdAndUpdate() toma la identificación del objetivo y los datos de solicitud con los que desea reemplazarlo.

router.post('/update', function(req, res) {
    StudentModel.findByIdAndUpdate(req.body.id, 
    {Name:req.body.Name}, function(err, data) {
        if(err){
            console.log(err);
        }
        else{
            res.send(data);
            console.log("Data updated!");
        }
    });  
});

Cómo recuperar el último registro de la colección de la base de datos: Para recuperar el último registro necesitamos dos funciones básicas: 

• .sort() – Acepta un parámetro según el cual ordena los datos en orden descendente (-1) o ascendente (1).
• .limit() – Decide la cantidad de documentos necesarios para recuperar.

Ejemplo: Supongamos que quiero obtener el registro del estudiante que más recientemente ingresó al Colegio. El siguiente fragmento de código hace este trabajo por nosotros…

Fragmento de código que recupera los datos más recientes

NOTA : limit() no debe usarse sin .sort(), ya que puede causar errores más adelante que son difíciles de rastrear. Esto se debe a que, de lo contrario, no podemos garantizar el orden del resultado. Obtendríamos diferentes registros en la parte superior de los resultados, lo que no es deseable. Para que una consulta sea determinista, deben dar los mismos resultados cada vez que se ejecutan.