Códice | Entradas sobre «mongodb»

Conexión persistente a MongoDB en Node.js

JavGuerra — Sun, 24 Jul 2022 00:00:00 GMT

Etiquetas: #código, #javascript, #node.js, #express, #mongodb

Esta semana tocó aprender sobre MongoDB. Una de las cuestiones que me llamaron la atención en los ejercicios que realizamos era la necesidad de abrir y cerrar la conexión a la Base de Datos (en adelante «BBDD») en cada consulta, algo que supone una sobrecarga importante para el servidor, así que me puse a investigar la manera de hacer que la conexión a la BBDD permaneciese abierta y dando servicio a través de los distintos módulos de la aplicación. Esto es lo que descubrí, con ayuda de la comunidad.

Cambiando el chip

Pasar de manejar datos embebidos en módulos como en el caso de la publicación sobre filtrado múltiple a consultar una base de datos como MongoDB presenta retos importantes. el principal es que debo establecer la conexión al servicio y esperar una respuesta. Una consulta típica a MongoDB tendría esta forma:

if (process.env.NODE_ENV !== 'production') require('dotenv').config();
const mongoClient = require('mongodb').MongoClient;

const url = `${process.env.DB_HOST}:${process.env.DB_PORT}/`;
const db_name = process.env.DB_DATABASE;
const collection = "products";

(url, function(err, database) {
    if (err) throw err;
    const db = database.db(db_name);
    db.collection(collection).find().toArray(function(err, result){
        if (err) throw err;
        console.log(result);
        database.close();
    });
});

En la primera línea, en función de si la aplicación está funcionando en local, en modo desarrollo, o bien en producción en el servidor, cargo o no el módulo dotenv que me permite tener las variables globales que luego usaré en url y db_name por ejemplo definidas en un fichero .env. Puedes ampliar conocimientos sobre este asunto en .dovenv.

Tras importar mongoClient, y definir las variables que se emplearán en la conexión (url a la BBDD, nombre de la BBDD y nombre de la colección) lanzo un mongoClient.connect() que devuelve bien un error de conexión o abre la conexión (cliente) al gestor de BBDD MongoDB. Luego, con const db = database.db(db_name); obtengo acceso a la BBDD, y seguidamente hago una consulta con db.collection(collection).find(). Una vez obtengo el resultado de la búsqueda (en este caso todos los documentos dentro de la colección de la BBDD), los muestro por consola y cierro la base de datos con database.close();.

Pero si deseo hacer otra búsqueda, o en el módulo tengo una serie de rutas, todas ellas apuntando a una consulta a la BBDD, el número de aperturas y cierres de la conexión se multiplica por el número de consultas. Esto en una página personal o con poco tráfico es sostenible, pero no lo es para grandes flujos de acceso o incluso para situaciones de picos concretos de acceso al servidor (horas de más tráfico, momentos del año donde las consultas se incrementan, por ejemplo cuando se solicitan los resultados de un evento, las notas de fin de curso, una noticia que ha tenido popularidad o alcance…).

Mantener la conexión abierta para distintas consultas en un módulo es fácil, pero, ¿cómo abrirla a través de los distintos módulos de la aplicación?

Primer acercamiento: Importar y conectar

Mi primera opción fue que si voy a emplear la conexión en distintos módulos debía extraer el proceso de conexión a un módulo a parte y luego importarlo allá donde lo necesite, y dicho y hecho:

if (process.env.NODE_ENV !== 'production') require('dotenv').config();
const MongoClient = require('mongodb').MongoClient;

const url = `${process.env.DB_HOST}:${process.env.DB_PORT}/`;
const db_name = process.env.DB_DATABASE;

const loadDB = async () => {
    try {
        const client = await MongoClient.connect(url);
        const db = client.db(db_name);
        return db;
    } catch (err) {
        console.log(err);
    }
};

module.exports = loadDB;

Este módulo realiza lo mismo que en el ejemplo anterior, es decir, abre una conexión a MongoDB, pero lo hace exportando la función asíncrona loadDB para que pueda ser llamada desde otros módulos con:

const loadDB = require('../services/DB');
let db;
const collection = "products";

(async () => db = await loadDB())();

db.collection(collection).find().toArray(function(err, result){
    if (err) throw err;
    console.log(result);
});

Tras cargar loadDB, declaro la variable de ámbito global db que contendrá la conexión a la BBDD, y en la línea:

(async () => db = await loadDB())();

Ejecuto la función asíncrona loadDB() para obtener la conexión que se guardará en db, y ya puedo hacer la consulta con db.collection(collection).find().

Esta consulta podría formar parte de una ruta de express:

const express = require('express');
const router = express.Router();
const loadDB = require('../services/DB');
let db;
const collection = "products";

(async () => db = await loadDB())();

router.get('/ejemplo', (req, res) => {
    db.collection(collection).find().toArray(function(err, result){
        if (err) throw err;
        res.json(result);
    });
})

module.exports = router;

Pero claro, esta forma de proceder implica abrir una conexión por cada módulo de rutas que use la función loadDB. No es lo que busco.

Alternativa: función callback al rescate

¿Qué tal si, en vez de intentar traer a cada módulo la conexión a la BBDD llevo las rutas a la función que abre la conexión directamente mediante una función callback? Veamos…

Para que todas las rutas puedan usar la variable db que se declara cuando se lleva a cabo la conexión, podría establecer una única conexión a la base de datos desde index.js (o app.js) osea, desde el fichero principal de la aplicación Node.js, y referenciar las rutas dentro de una función callback que le pase al módulo encargado de abrir la conexión.

Esta idea fue la que me propuso ZeroBl, que se tomó el tiempo de responder a mis preguntas en un foro de Discord, y tras pasarme el código que él usa para establecer su conexión, y buscar un poco más de información en StackOverflow, el resultado fue el siguiente:

Módulo de conexión a la BBDD

if (process.env.NODE_ENV !== 'production') require('dotenv').config();
const MongoClient = require('mongodb').MongoClient;

const url = `${process.env.DB_HOST}:${process.env.DB_PORT}/`;
const db_name = process.env.DB_DATABASE;

let _db;
let _client;

const connectDB = function (callback) {
    try {
        MongoClient.connect(url, {
            useNewUrlParser: true,
            useUnifiedTopology: true
        }, function (err, client) {
            _client = client;
            _db = client.db(db_name);
            return callback(err, client);
        });
    } catch (err) {
        throw err;
    }
}

const getDB = function () {
    if (_db) return _db;
    throw 'BBDD no encontrada.';
}

const disconnectDB = function () {
    if (_db) return _client.close();
    throw 'BBDD no encontrada.';
}

module.exports = { connectDB, getDB, disconnectDB };

Como se aprecia, este módulo devuelve tres funciones: connectDB que abre la conexión, getDB que obtiene la conexión a la BBDD, y disconnectDB, que cierra la conexión a la BBDD.

A connectDB le paso un callback que se ejecutará en el ámbito donde está viva la conexión. Igual deberemos obtener la referencia a _db en cada módulo que usemos. Lo voy a explicar enseguida.

Con disconnectDB puedo cerrar la conexión a la BBDD desde cualquier parte del programa, pero también debo importarlo si queremos usarlo.

El index.js

O cualquier otro js que haga las veces de inicio de nuestra app:

if (process.env.NODE_ENV !== 'production') require('dotenv').config();
const express = require('express');
const app = express();
const port = process.env.PORT;
const mongoDB = require('./services/DB');

mongoDB.connectDB(function (err, client) {
    if (err) throw err;

    // Ej. http:localhost:3000/ejemplo
    const RouteEjemplo = require('./routes/ejemplo');
    app.use('/ejemplo', RouteEjemplo);

    // otras rutas...

    // Ej. http:localhost:3000/exit
    app.get('/exit', function (req, res) {
        client.close();
        res.end('Fin');
        process.kill(process.pid, 'SIGTERM');
    });

    app.use((req, res) => {
        res.status(404).send('Error 404: No encontrado.');
    });

    app.use((err, req, res, next) => {
        console.error(err.stack);
        const status = err.status || 500;
        res.status(status).send(`Error ${status}: ${err.message}.`);
    });

    const server = app.listen(port, function () {
        console.log(`Servidor levantado en el puerto ${port}.`);
    });

    process.on('SIGTERM', function () {
        server.close(() => console.log('Proceso terminado.'))
    });
});

Importo el módulo de mongoDB y conecto a la BBDD con:

mongoDB.connectDB(function (err, client) {
    // Función callback
});

Función a la que le paso como callback todo el manejo de rutas, e incluso levanto el servidor. Recuerda que esta función se ejecutará tras establecer la conexión en la línea:

return callback(err, client);

Al ejecutar la función obtengo dos posibles valores, o bien un error, o bien el cliente para la conexión. Esto me va a permitir hacer uso del cliente desde la misma función callback, para, por ejemplo, cerrar la conexión, como ocurre en la ruta /exit en:

client.close();

Usar una ruta para cerrar la aplicación por supuesto es un ejemplo ilustrativo, y no es la mejor forma de hacerlo. ;)

Si quiero cerrar la aplicación desde dentro de un módulo de, por ejemplo, una ruta, debo usar disconnectDB().

La ruta de ejemplo

Como dije, para poder utilizar la BBDD en las distintas rutas o en los módulos de la aplicación, debo importar la referencia a db en cada módulo con:

const mongoDB = require('../services/DB');
const db = mongoDB.getDB();

y a partir de ahí puedo usar db en todo el módulo. Así de simple.

Esto es posible porque, como hemos visto, estamos llamado a esta ruta dentro del callback que pasamos a la función que abre la conexión.

En resumen

Mediante un módulo que devuelve tres funciones podemos abrir la conexión a la BBDD (recibiendo y ejecutando un callback) obtener la referencia a la BBDD y cerrar la conexión a la BBDD.

Dentro del callback definimos las rutas (app.use) que van a hacer uso de la BBDD, y en cada módulo donde se defina la ruta o las sub-rutas, deberemos obtener la referencia a la BBDD para poder usarla.

En este enlace a StackOverflow (en inglés) podrás obtener más información y alternativas a esta solución.

Usando populate con paginate y filtrando los resultados

JavGuerra — Sat, 29 Oct 2022 00:00:00 GMT

Etiquetas: #código, #javascript, #node.js, #mongodb, #mongoose, #paginate

Si bien mongodb tiene formas de obtener resultados paginados (limit, skip), el módulo mongoose-paginate-v2 de mongoose nos ahorra tiempo y código a la hora de preparar y usar los datos paginados obtenidos de las búsquedas en nuestras bases de datos, devolviendo información complementaria muy cómoda, pero ¿cómo podemos usar la paginación cuando tenemos relaciones entre colecciones? En esta entrada explicaré cómo paginar resultados agregados entre colecciones como si usásemos aggregate en mongodb o populate en mongoose, y además cómo filtrar búsquedas agregadas y paginadas con este módulo.

El ejemplo

Imaginemos que tenemos dos colecciones en una BBDD mongodb, una de libros y otra de autores, y un dato en cada documento de la colección libros llamado autor que sirve para contener la información agregada del autor en la colección libros. En el schema, el dato autor podría tener esta forma:

    autor: { 
        ref: { type: Schema.Types.ObjectId, ref: 'Autor' },
        nombre: String
    }

La propiedad ref es la que «tenderá el puente» entre ambas colecciones, y contendrá el _id del documento a relacionar de la colección autores. La propiedad nombre contendrá, como se espera, el nombre del autor. Si bien este dato estará también en la colección autores, y puede ser redundante cuando agregamos los resultados, el dato tiene su utilidad, pues nos permite realizar el filtrado de libros por autor incluso sin realizar la agregación.

Una búsqueda haciendo uso de populate tendría esta forma:

Libro.find( filtro ).populate( 'autor.ref' ).exec();

donde filtro es un objeto que contendrá los criterios de búsqueda, y autor.ref es la necesaria referencia para poder llevar a cabo la agregación de datos de la colección autores en libros.

Si queremos emplear el módulo mongoose-paginate-v2 para paginar los resultados de la búsqueda, esta quedaría de la siguiente forma:

Libro.paginate(filtro, { page, limit });

donde page indica la página de resultados a obtener y limit el número de resultados por página.

Pero sólo nos devolverá los datos de la colección autores, sin agregar los datos de la colección libros. ¿Cómo se haría esto?

Agregando y paginando

Hemos visto que paginate acepta dos parámetros, los criterios de búsqueda (filtro) y las opciones (page, limit). Otra opción que podemos añadir a paginate es populate. Para hacer una búsqueda agregada como la del ejemplo, usaríamos:

Libro.paginate(filtro, { page, limit, populate: 'autor.ref' });

de esta forma podemos obtener un resultado con la información de ambas colecciones.

La opción populate permite también otras opciones. Imaginemos que en la agregación queremos obviar el dato nombre de la colección autores que ya tenemos en la colección libros. Podemos pasarle a populate un objeto de la siguiente forma:

Libro.paginate(filtro, { page, limit, populate: {path: 'autor.ref', select: '-nombre'}' });

donde select: '-nombre', que va con un signo menos (-) delante, indica que ese dato no será requerido. Véase también que, para incluir la referencia a la colección, dentro del objeto se usa path: 'autor.ref'.

Puedes obtener más información sobre las opciones de populate en el manual on-line.

Filtrando

Decía más arriba que nos puede interesar hacer un filtrado en la búsqueda sobre nuestra base de datos por el nombre del autor, que es un dato dentro de otro dato, pero antes recordaré cómo buscar por uno o varios datos de la colección.

const filtro = {};
if (titulo) filtro.titulo = { $regex: `.*${titulo}.*` };
if (precio) filtro.precio = { $lte: precio };

Este código creará un objeto filtro que permitirá que busquemos en la colección libros por título y precio, ya que, si estos datos de búsqueda existen, con filtro.titulo y filtro.precio añadimos ambas propiedades al objeto filtro que usaremos en la búsqueda de la forma en que hemos visto en todos los ejemplos anteriores. (Nota: entiéndase que podríamos tener libros con el mismo título y distinto precio según la editorial o la colección editorial).

Con { $regex: `.*${titulo}.*/` } buscamos por la expresión regular dada, en cambio con $lte: precio buscamos por un valor igual o menor al proporcionado. Ver más información sobre operadores de búsqueda en mongodb en el manual on-line.

Esto permitirá que:

Libro.paginate(filtro, { page, limit, populate: {path: 'autor.ref', select: '-nombre'}' });

devuelva aquellos documentos de la colección libros que tengan coincidencias con el filtro indicado, es decir, que contengan en el título el texto titulo indicado y cuyo precio sea igual o menor al precio indicado.

Consulta sobre datos anidados

Teniendo claro lo anterior, acceder al dato nombre dentro de autor no es complicado, pero para referenciar el dato tendremos que usar lo siguiente:

const filtro = {};
if (nombre) filtro["autor.nombre"] = { $regex: `.*${nombre}.*` };

Uso aquí los corchetes [] porque para poder usar el filtro en mongodb debo pasarle la propiedad al objeto filtro de esta forma: { "autor.nombre" : { $regex: `.*${nombre}.*` } } como se indica en la sección consulta sobre documentos incrustados/anidados del manual online.

Este filtro devolverá aquellos documentos de la colección libros que, dentro del dato autor, contengan el nombre dado dentro del dato anidado nombre.

Enlaces

Generar enlaces dinámicos de imágenes almacenadas en MongoDB

JavGuerra — Sun, 06 Nov 2022 00:00:00 GMT

Etiquetas: #código, #javascript, #node.js, #mongodb, #imágenes

Las bases de datos a menudo contienen referencias a recursos que no son almacenados en su misma estructura. Un claro ejemplo de ello son las fotografías o imágenes que acompañan a los productos de un catálogo. En tal caso, guardar la información es sencillo, es suficiente con almacenar la ruta completa al recurso en un campo de tipo String, pero, ¿que ocurre si, presumiblemente, nuestros datos van a cambiar de ubicación, o van a correr en distintas instancias o en diferentes hospedajes? En ese caso, lo recomendable es almacenar la información del nombre del recurso en la BBDD, y entonces tendremos dos alternativas para generar el enlace completo: modificar los datos de la BBDD mediante un script para que la url al recurso sea la adecuada cada vez que cambiamos de ubicación los datos, o bien generar la ruta al recurso de forma dinámica, al vuelo, cuando se realizan las consultas. Vamos a ver aquí la segunda.

El ejemplo

Partimos de la siguiente premisa. En las variables globales del sistema tenemos almacenadas la ruta y el puerto del servidor donde están ubicadas las imágenes, que es la información susceptible de cambiar de lugar. Tal vez estos datos estén disponibles mediante dotenv.

Tomemos como referencia el ejemplo de la entrada anterior. Dos colecciones relacionadas, libros y autores, y en las que queremos incluir un dato en cada documento de la colección libros con la foto de portada del libro, y un dato con la foto del autor en cada documento de la colección autores. Algo como:

libro: {
    portada: 'don-quijote.png',
}

autor: {
    foto: 'cervantes.jpg',
}

obviamente, tanto la colección libros como la conección autores tendrán otros datos, no sólo la portada o la foto.

La ruta

Para poder acceder a la portada del libro, necesitamos completar la ruta a la imagen. En este ejemplo usaremos el dominio lalibreria2022.com al que se accede por el porto 80. Esta información la tenemos almacenada en un fichero .env de nuestra aplicación de la siguiente forma:

HOST='https://lalibreria2022.com'
PORT=80

Y asumo que las portadas se almacenan en una carpeta llamada portadas, y las fotos en otra llamada fotos. De esta forma, para acceder a la imagen don-quijote.png debemos completar la siguiente ruta:

HOST + ':' + PORT + '/' + 'portadas' + '/' + 'don-quijote.png'

y obtendríamos:

https://lalibreria2022.com:80/portadas/don-quijote.png

Alterando los resultados

Cuando llevamos a cabo las búsquedas de información sobre la BBDD, esta nos devolverá, como ya sabemos, el nombre del recurso (‘don-quijote.png’), pero queremos que la BBDD devuelva dinámicamente la ruta antes mencionada. Para ello hay que recorrer el resultado obtenido y hacer cambios sobre los datos. Un forEach() es suficiente.

const insertarRutas = datos => {
    const url = process.env.HOST + ':' + process.env.PORT + '/';
    datos.forEach( elemento => elemento.portada = url + 'portadas/' + elemento.portada );
    return data;
}

Tras cada búsqueda, aplicando esta función al resultado, recorro todos los documentos de la colección (datos) y cambio el valor del dato portada en cada documento.

También con resultados agregados

Cuando llevamos a cabo consultas agregadas, el proceso es similar. En una consulta donde obtenemos los libros y las referencias a sus respectivos autores, debemos repetir el proceso también para el dato foto de la colección autores, pero hay que tener en cuenta lo siguiente:

{: .box-note} Nota: Cuando recorremos una colección agregada lo hacemos sobre una colección y sobre referencias a otra colección, es decir, si hay varios libros de un mismo autor, aunque los datos del autor se muestren en varios libros agregados, solo están almacenados una vez.

Esto tiene importancia porque, al realizar el cambio de la ruta de la foto del autor, estaríamos cambiándola tantas veces como libros existan, y generando entonces una url errónea con rutas repetidas. Si tenemos dos libros de Cervantes, la ruta a la foto podría verse así:

https://lalibreria2022.com:80/fotos/https://lalibreria2022.com:80/fotos/cervantes.jpg

Para evitar esto, debemos implementar el siguiente código, en el que se incluyen ambos casos, el de la portada del libro y el de la foto del autor:

const insertarRutas = datos => {
    const url = process.env.HOST + ':' + process.env.PORT + '/';
    datos.forEach(elemento => {
        elemento.portada = url + 'portadas/' + elemento.portada;
        if (!elemento.autor.ref.foto.includes(url)) 
             elemento.autor.ref.foto = url + 'fotos/' + elemento.autor.ref.foto;
    });
    return data;
}

Con el condicional (if) me aseguro de que la foto no contiene ya la ruta completa, y si no es así, la completa.

Enlaces

Usando populate con paginate y filtrando los resultados

Tienda 8 bits

JavGuerra — Fri, 18 Nov 2022 00:00:00 GMT

Etiquetas: #portfolio, #web, #formación, #becas, #node.js, #express, #react, #mongodb, #javascript, #accesibilidad, #responsive

Durante el año 2022 cursé el Bootcamp de Desarrollo Web Full Stack que Becas Santander llevó a cabo en colaboración con Fundación Universia, Indra y The Bridge.

El día 17 de noviembre finalizó la formación con un acto de entrega de diplomas on-line en el que tuve ocasión de mostrar mi proyecto final «Tienda 8 bits» junto con Alex, otro de mis compañeros, quien también expuso su proyecto.

A parte de los compañeros y los profesores, asistieron al evento Alejandra Cuenca y Diego Díaz por parte de The Bridge, Cristina Soriano por Minsait/Indra, y Beatriz Arribas y Carlos Sánchez por Universia.

Video

El evento se llevó a cabo de forma presencial y on-line, y de él he rescatado el video de mi presentación que comparto a continuación.

Descripción técnica

Back end

Tecnologías empleadas: Node.js + Express + MongoDB + Mongoose
Módulos: compression, cors, helmet, dotenv, nodemon, mongoose-paginator-v2

Características destacadas de la API:

Emplea módulos ESM.
Está preparada para el versionado de la API.
Está preparada para el uso de BBDD MongoDB local o en remoto (config.js).
Preserva la seguridad del acceso a la API con el uso del módulo helmet.
Devuelve las rutas de los enlaces a las fotos y logos dinámicamente.
Cuenta con documentación de la API.

Front end

Tecnologías empleadas: React + Vite, axios, react-router-dom, react-hook-form
Módulos propios: setSpin, inactiveBtn, compareTwoObjects

Características destacadas de la App:

El diseño es adaptable (responsive) según el dispositivo.
CSS propio. No usa frameworks.
Es accesible (revisado con el complemento WAVE).
Utiliza fuentes de Google Font en los títulos para preservar la accesibilidad.
Implementa el protocolo Open Graph para la correcta inserción de la web en RRSS.
Es compatible con Progessive Web Aplication (PWA) a través de fichero manifest.json, por lo que la página puede ser instalada en dispositivos móviles como una web app.
Ha sido probada con los navegadores web Firefox y Chrome.
Tratamiento de imágenes con software libre: Gimp e InkScape.

Fuentes

Wikipedia
Enciclopedia «Mi Computer», editorial Delta, 1984.

Licencias

Sobre el código fuente: GNU GENERAL PUBLIC LICENSE Version 3
Sobre el contenido de la web: (CC) BY-SA 3.0
Sobre las fotos: Son propiedad de sus respectivos autores.
Sobre las fuentes de letra: Google Fonts
Sobre los iconos: Heroicons
Material usado sin ánimo de lucro bajo criterios didácticos y formativos.

Acceder a la aplicación

Enlaces

Artículos informativos elaborados por el autor relacionados con esta práctica: