Recientemente migré algunas pruebas de Jest al ejecutor de pruebas de Node.js en dos de mis proyectos que usan MongoDB. En uno de esos proyectos, el tiempo de ejecución de las pruebas fue reducido de 107 segundos a 25 segundos (captura de pantalla abajo). En el otro proyecto, el tiempo de ejecución de las pruebas fue reducido cerca de un 66%.

Decidí compartirte cómo pude implementarlo. Pienso que te será de utilidad, ya que es más rentable (en términos de reducir dinero gastado en ejecutar pruebas en CI/CD), y también mejora tu experiencia de desarrollo.

Tabla de Contenidos

• Pre-requisitos
• El Ejecutor de Pruebas de Node.js
• El Servidor en memoria de MongoDB

• Cómo escribir las Pruebas
  1. Configurar el Proyecto
  2. Configurar el Esquema de Mongoose
  3. Configurar los Servicios
  4. Configurar las Pruebas
  5. Escribir las Pruebas
  6. Pasar las Pruebas
  7. Usar TypeScript (Opcional)

• Conclusión

Pre-requisitos

Para seguir esta guía, deberías de tener experiencia trabajando con Node.js, MongoDB y Mongoose (o cualquier otro mapeador de datos de objetos de MongoDB). Deberías también tener instalado Node.js (al menos la versión 20.18.2) y MongoDB (Compass la versión GUI) en tu computadora.

El Ejecutor de Pruebas de Node.js

El ejecutor de pruebas de Node.js fue introducido como una característica experimental en la versión 18 de Node.js. Se volvió disponible oficialmente en la versión 20. Te da la habilidad de:

1. Ejecutar pruebas
2. Reportar resultados de las pruebas
3. Reportar cobertura de las pruebas (todavía experimental en la versión 23)

Es una buena idea el usar el ejecutor de pruebas incorporado cuando se escriban pruebas en Node.js porque significa que tienes que usar menos dependencias externas. No necesitas instalar una librería externa (y sus dependencias entre pares) para ejecutar las pruebas.

El mejor ejecutor incorporado también es el más rápido. Basado en mi experiencia usándolo en dos proyectos (los cuales usaron Jest), vi mejoras de al menos una reducción del 66% en el tiempo que tomó ejecutar las pruebas completamente.

Y a diferencia de otros frameworks o librerías de pruebas, el ejecutor de pruebas de Node.js fue construido especialmente para proyectos de Node.js. No trata de acomodar las especificaciones de otros entornos de programación como el navegador. Las especificaciones de Node.js son su principal y única prioridad.

El Servidor en memoria de MongoDB

Para las pruebas que involucran el hacer peticiones a una base de datos, algunos desarrolladores prefieren imitar las peticiones para evitar hacer peticiones a una base de datos real. Hacen esto porque hacer una petición a una base de datos real requiere un montón de configuraciones que puede costar tiempo y recursos.

Escribir y solicitar datos usando una base de datos real es más lento comparado con escribir y solicitar datos de la memoria. Cuando se ejecutan pruebas automatizadas, usando un servidor de MongoDB real será más lento que usar un servidor de base de datos en memoria, y ahí es donde mongodb-memory-server se vuelve útil.

Según su documentación, mongodb-memory-server crea y comienza un servidor de MongoDB real de forma programática desde dentro de Node.js, pero usa una base de datos en memoria por defecto. También te permite conectar el servidor de base de datos que crea usando tu mapeador de datos de objetos preferido tales como Mongoose, Prisma, o TypeORM. En esta guía, usaremos Mongoose (v.8.9.6).

Ya que los datos almacenados por mongodb-memory-server reside en la memoria por defecto, es más rápido leer y escribir en él que cuando se usa una base de datos real. mongodb-memory-server también es más fácil de configurar. Estos beneficios lo hace una buena elección para usarlo como un servidor de base de datos para escribir pruebas.

Nota: asegúrate de instalar la versión 9.1.6 de mongodb-memory-server para seguir esta guía. La versión 10 actualmente tiene problemas con limpiar los recursos después que se hacen las pruebas. Mira este problema con el título "Node forking will include any --import from the original command".

El problema ha sido resuelto al tiempo de escribir este artículo, pero el arreglo no ha sido fusionado para las instalaciones.

Cómo escribir las Pruebas

Ahora te guiaré a través de los siguientes pasos para que comiences a escribir las pruebas:

1. Configurar el proyecto
2. Configurar el esquema de Mongoose
3. Configurar los servicios
4. Configurar las pruebas
5. Escribir las pruebas
6. Pasar las pruebas
7. Usa TypeScript (Opcional)

1. Configurar el Proyecto

Creé un repositorio de Github para facilitarte que sigas esta guía. Clona este repositorio en nodejs-test-runner-mongoose y dirígete a la rama 01-setup.

En 01-setup, las dependencias para el proyecto están el archivo package.json. Instala las dependencias usando el comando npm install para configurar el proyecto. Asegúrate de que la configuración esté completa y correcta, ejecuta el comando node . en la terminal de tu proyecto. Deberías ver tu versión de Node.js  como una salida en la terminal.

# instala las dependencias
npm install
...
# ejecuta el comando node
node .
# la salida
You are running Node.js v22.13.1

2. Configurar el Esquema de Mongoose

Configuraremos el esquema para dos colecciones (Task y User) en la rama 02-setup-schema usando Mongoose. Los archivos task/model.mjs y user/model.mjs contienen el esquema para las colecciones Task y User, respectivamente. También configuraremos una conexión de base de datos en index.mjs para asegurar que la configuración del esquema funcione correctamente.

No iré en detalle sobre los modelos y esquemas de Mongoose en este artículo porque están fuera de su alcance.

Cuando ejecutas el comando node . después de implementar los cambios en 02-setup-schema, deberías de ver un resultado similar en la consola como en el fragmento de abajo:

node .
You are running Node.js v22.13.1
Created user with id 679f1d7f73fbeaf23b2007df
Created task "Task title" for user with id "679f1d7f73fbeaf23b2007df"

Puedes ver las diferencias entre 01-setup y 02-setup-schema a través de la diferencia 01-setup <> 02-setup-schema en Github.

3. Configurar los Servicios

Luego, creamos los archivos de servicio (task/service.mjs y user/service.mjs) en la rama 03-setup-services. Ambos archivos actualmente contienen funciones vacías en el que escribiremos las pruebas más tarde. Estas funciones contendrán la lógica de negocio y también se comunicará con la base de datos. Estamos usando comentarios de JSDoc para escribir parámetros y regresar valores.

Haz clic en la diferencia de 02-setup-schema <> 03-setup-services para ver los cambios de código entre 02-setup-schema y 03-setup-services.

4. Configurar las Pruebas

En la rama 04-set-up-tests, configuramos la base de código para ejecutar las pruebas. Creamos test.setup.mjs el cual contiene el código que será ejecutado antes de que cada archivo de prueba se ejecute.

En test.setup.mjs, la función connect crea un servidor de MongoDB en memoria y lo conecta con Mongoose para ejecutar las pruebas. La función closeDatabase cierra la conexión de la base de datos y limpia todos los recursos para liberar memoria.

Las funciones connect y closeDatabase se ejecutan en el hook t.before y en el hook t.after respectivamente. Esto asegura eso, antes que un archivo test se ejecute, una conexión de base de datos se establece a través t.before. Luego de que se hayan ejecutado las pruebas del archivo, la conexión de la base de datos se cae y los recursos usados se limpian a través de t.after.

En package.json, actualizaremos el script de npm test a node --test --import ./test.setup.mjs. Este comando asegura que Módulo Es test.setup.mjs se pre-cargue y se ejecute a través del comando --import del CLI antes de que cada archivo de prueba se ejecute.

Luego crearemos los archivos de prueba con pruebas vacías en las carpetas __tests__ para user y task. Después de implementar los nuevos cambios en 04-set-up-tests, ejecutar el script test con npm run test debería de mostrar la salida similar al fragmento de abajo:

npm run test

> nodejs-test-runner-mongoose@1.0.0 test
> node --test --import ./test.setup.mjs

...

ℹ tests 8
ℹ suites 5
ℹ pass 8
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 941.768873

Todas las pruebas actualmente pasan porque no hay aserciones que fallen. Escribiremos las pruebas con aserciones en la siguiente sección.

5. Escribir Pruebas

Ahora es tiempo de escribir las pruebas para las funciones en los archivos de service en la rama 05-write-tests. Estamos usando la librería de aserción de Node.js para asegurar que los valores regresados de las funciones sean lo que esperamos. Puedes ver las pruebas que hemos escrito cuando comparas las diferencias entre 04-set-up-tests y 05-write-tests.

Cuando el script tests se ejecute, todas las pruebas fallan porque no hemos escritos las funciones en los archivos de service todavía. Debería de ver una salida similar al fragmento de abajo cuando ejecutes el script test:

npm run test

> nodejs-test-runner-mongoose@1.0.0 test
> node --test --import ./test.setup.mjs

...

ℹ tests 8
ℹ suites 5
ℹ pass 0
ℹ fail 8
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 1202.031961

6. Pasar las Pruebas

En 06-pass-tests, escribimos las funciones en los archivos de service que pasen las pruebas. Solamente 6 de 7 pruebas pasan cuando el script test se ejecuta porque salteamos la prueba para la función getById en user/service.mjs con t.skip. No hemos terminado la función getById en user/service.mjs. Supuse que podríamos dejarlo como ejercicio.

Cuando ejecutas el script test, deberías obtener una salida similar en la terminal como el de abajo:

ℹ tests 7
ℹ suites 4
ℹ pass 6
ℹ fail 0
ℹ cancelled 0
ℹ skipped 1
ℹ todo 0
ℹ duration_ms 1287.564918

Puedes ver el código que escribimos para pasar las pruebas en los cambios de código entre 05-write-tests y 06-pass-tests.

7. Usa TypeScript (Opcional)

Si tu intención es ejecutar las pruebas con TypeScript, puedes cambiar a la rama 07-with-typescript. Necesitas tener Node.js >=22.6.0 instalado porque estamos usando la opción --experimental-strip-types en el test. Para configurar las pruebas que se ejecuten con TypeScript, sigue los siguientes pasos:

1. Instala TypeScript usando el comando npm install typescript --save-dev
2. Instala tsx usando el comando npm install tsx
3. Crea un archivo predeterminado tsconfig.json en la raíz del proyecto usando el comando npx tsc --init

En  package.json, actualiza el script test a esto:

"test": "node --test --experimental-strip-types --import tsx --import ./test.setup.mjs"

• --experimental-strip-types ayuda a eliminar tipos antes de cada archivo de prueba se ejecute.

Pre-cargar tsx con el --import ayuda a ejecutar el archivo de TypeScript. Sin él, el ejecutor de pruebas no será capaz de encontrar archivos importados sin la extensión .ts. Por ejemplo, user/model.ts importado con el fragmento de código de abajo no será encontrado.

  import { UserModel } from "./model";

El resto de los cambios desde 06-pass-tests a 07-with-typescript involucran actualizar los tipos, cambiar las extensiones de archivo de .mjs a .ts y actualizar las declaraciones import.

Conclusión

En esta guía, has aprendido cómo usar el ejecutor de pruebas incorporado de Node.js y por qué es frecuentemente una mejor elección sobre otras librerías y frameworks de pruebas. También has aprendido cómo usar mongodb-memory-server como un reemplazo de un servidor real de MongoDB, así también como por qué es una buena idea usarlo en vez de un servidor real de MongoDB para las pruebas.

Lo más importante, has aprendido cómo configurar y ejecutar las pruebas en Node.js usando el ejecutor de pruebas de Node.js y mongodb-memory-server. Ahora deberías de saber cómo configurar tus proyectos para que ejecuten las pruebas si usas TypeScript.

Si encuentras útil a este repositorio nodejs-test-runner-mongoose, por favor dale una estrella. Me anima mucho. Gracias.

Pero ¿por qué es eso relevante? JavaScript se volvió mucho más rápido con un nuevo entorno de ejecución de JavaScript llamado Bun, que ahora está listo para producción con su versión 1.0.

¿Cómo y por qué es más rápido que Node.js? Me vienen a la mente muchas preguntas.

Responderé algunas de esas preguntas en este artículo. Y lo haré rápidamente, ya que ahora soy más rápido, al igual que JavaScript, que se prepara con Bun 1.0.

Bun es un conjunto de herramientas rápidas todo en uno para ejecutar, crear, probar y depurar JavaScript y TypeScript, desde un único archivo hasta una aplicación full-stack.

A continuación algunas cosas que podemos hacer con Bun:

Ejecuta tu código más rápido con Bun

Ahora no necesitamos herramientas como npm, pnpm o yarn porque Bun es 17 veces mas rápido. Eche un vistazo a los datos mostrados a continuación:

Bun tarda solo 0,36 segundos en compilar su código, mientras que tarda unos 6,44 segundos en el caso de pnpm, 10,58 segundos con npm y 12,08 segundos con yarn.

Bun soporta hot reloading

Bun soporta hot reloading (recarga en caliente) desde el primer momento, por lo que no necesita herramientas como Nodemon. Actualizará automáticamente el servidor cuando se ejecute JavaScript o TypeScript.

Puede reemplazar el comando npm run con bun run para ahorrar más de 150 ms milisegundos cada vez que ejecuta un comando.

Aquí un gráfico completo:

Según el cuadro anterior, el uso de npm tarda unos 176 ms en ejecutarse, yarn tarda unos 131 ms. En el caso de pnpm, se necesitan 259 ms. Sin embargo, en el caso de Bun, se necesitan unos 7 ms. Eso es rápido, ¿no?

Bun es un empaquetador JavaScript

Bun también es un empaquetador de JavaScript con el mejor rendimiento de su clase y una API compatible con ESBuild, por lo que no necesitamos cosas como:

• ESBuild
• Webpack
• Parcel, .parcelrc
• Rollup, rollup.config.js

Bun ahora soporta Next.js, Remix, Nuxt, Astro, SvelteKit, Nest, SolidStart y Vite.

Bun es compatible con ESM y CommonJS

Otra gran característica de Bun es que podemos usar módulos ES6 y CommonJs juntos en el mismo archivo, lo que no era posible en Node.js.

Puedes usar import y require() en el mismo archivo:

import lodash from "lodash";
const _ = require("underscore");

Aparte de eso, Bun tiene soporte integrado para las API estándar web que están disponibles en los navegadores, como fetch, junto con la propia API de Bun como Bun.file() para leer un archivo de forma diferida y Bun.Write() para escribir un archivo al sistema de archivos local, que es mucho más simple que Node.js.

Ejemplo Bun.file()

const archivo = Bun.file("package.json");
const contenido = await archivo.text();

El código anterior leerá el contenido de un archivo package.json y transferirá su contenido a una nueva variable llamada contenido.

Ejemplo Bun.write()

await Bun.write("index.html", "<html/>");
await Bun.write("index.html", Buffer.from("<html/>"));
await Bun.write("index.html", Bun.file("home.html"));
await Bun.write("index.html", 
await fetch("https://ejemplo.com/"));

En el código anterior, Bun.write() escribirá la cadena "<html/>", o copiará el contenido del archivo home.html en el archivo index.html. Si tenemos que recuperar datos, obtendrá los resultados de una API web externa y escribirá el contenido en un archivo index.html.

¿Por que Bun es tan rápido?

Bun es rápido porque usa el motor JavaScriptCore, mientras que Node.js usa el motor JavaScript V8. El primero se ha optimizado para un tiempo de inicio más rápido.

Si deseas hacer las cosas más rápido, debería considerar reemplazar Node.js con Bun.

¿Cómo empezar a usar Bun?

Puedes instalar Bun en sistemas MacOS y Linux usando npm:

npm install -g bun

Ahora ya está todo listo. Para instalar un paquete npm, haz esto:

bun install <nombre-paquete>

Para iniciar una aplicación, haz esto:

bun run dev

Para todo lo que pueda necesitar solo reemplace npm con bun.

Sin embargo, Bun sólo está listo para producción en los sistemas operativos MacOS y Linux. La versión de Windows aún es experimental. Por el momento, solo se admite el entorno de ejecución de JavaScript para Windows, y no el administrador de paquetes, el empaquetador ni el entorno de pruebas. Puedes leer más al respecto aquí.

Conclusión

Este artículo muestra cómo puedes utilizar Bun como alternativa a Node.js y acelerar su tiempo de desarrollo.

También puedes ver mi vídeo sobre El asesino de Node.js está aquí — Primer vistazo a Bun 1.0 (en inglés).

Gracias por leer.

Nodemailer es un módulo de Node.js que te permite enviar emails desde tu servidor con facilidad. Sea que quieras comunicarte con tus usuarios o sólo notificarte a ti mismo cuando algo ha salido mal, una de las opciones para hacerlo es a través de un email.

Hay muchos artículos por ahí que explican cómo usar Nodemailer de forma muy básica, pero este artículo no es uno de ellos. Aquí, te mostraré la práctica más común de enviar un email desde tu backend Node.js usando Nodemaier y Gmail.

Cómo empezar con Nodemailer

Primero, necesitamos configurar nuestro boilerplate de Node.js usando Express. Para asegurarte que tienes Node y npm instalados, puedes ejecutar los siguientes comandos:

node -v 
npm -v

Si ambos de estos comandos muestran una versión, puedes continuar. De otra manera, instala lo que falta.

Crea una carpeta para tu proyecto. Usaremos el nombre nodemailerProject.

mkdir nodemailerProject

Ve dentro de la nueva carpeta creada y ejecuta:

npm init

Esto iniciará nuestro proyecto con un archivo package.json.

Lo siguiente, necesitaremos instalar Express usando:

npm install express

Dependiendo qué archivo señalaste como tu punto de entrada (por defecto es index.js), ábrelo y pega el siguiente código:

const express = require('express')
const app = express()
const port = 3000


app.listen(port, () => {
  console.log(`nodemailerProject is listening at http://localhost:${port}`)
})

Lo de arriba es lo que se necesita para empezar un simple servidor usando Express. Puedes ver que está funcionando adecuadamente ejecutando:

node index.js

Cómo instalar Nodemailer

Instala nodemailer usando el siguiente comando:

npm install nodemailer

La API de Nodemailer es bastante sencillo y nos pide que hagamos lo siguiente:

1. Crea un objeto Transporter
2. Crea un objeto MailOptions
3. Usa el método Transporter.sendMail

Para crear un objeto transporter, hacemos lo siguiente:

let transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        type: 'OAuth2',
        user: process.env.MAIL_USERNAME,
        pass: process.env.MAIL_PASSWORD,
        clientId: process.env.OAUTH_CLIENTID,
        clientSecret: process.env.OAUTH_CLIENT_SECRET,
        refreshToken: process.env.OAUTH_REFRESH_TOKEN
      }
    });

✋ Presta atención, aparte de las claves de usuario y contraseña, los cuales son tus propias credenciales para tu cuenta de gmail, las otras tres claves necesitan ser recuperadas después de configurar OAuth.

Como dijimos al principio de este artículo, estaremos usando Gmail para nuestras necesidades de envío de correo. Como habrás adivinado, Gmail tiene un alto nivel de seguridad cuando se trata de correo enviado por/a la cuenta de un usuario.

Hay varias formas que podemos superar este obstáculo (algunas mejores que las otras), y elegiremos la que nos pide configurar un proyecto en la Plataforma de Nube de Google. Necesitamos hacer eso para tener las credenciales para la seguridad de OAuth activado por Gmail.

aquí

Los próximos pasos requerirán algunas configuraciones en vez de código, así que prepárense.

Configuraciones de la Plataforma de la Nube de Google

Si no tienes una cuenta de la Plataforma de la Nube de Google, asegúrate de configurar uno como pre-requisito. Una vez que lo hayas creado, crea un nuevo proyecto haciendo clic en el menú desplegable en la esquina izquierda superior.

Selecciona la opción New Project:

En la próxima ventana, tendremos que darle a nuestro proyecto un nombre. Elige cualquiera que te guste, pero continuaremos con nuestro nombre NodemailerProject. Para la propiedad location, puedes dejarlo como No organization.

Podría tomar unos pocos segundos para que el proyecto se configure, pero luego de eso serás capaz de ver esta pantalla:

Abre el menú de navegación haciendo clic en las tres líneas punteadas en la esquina de arriba a la izquierda y selecciona APIs and Services:

Para ser capaz de usar Nodemailer y Gmail tendremos que usar OAuth2. Si no estás familiarizado con OAuth, es un protocolo para autenticación. No voy a entrar en detalles aquí, ya que no es necesario, pero si quieres entender más sobre ello, ve aquí.

Primero tendremos que configurar nuestra OAuth Consent Screen:

Si no eres un miembro del G-Suite, la única opción disponible será External for user Type.

Luego de hacer clic en crear, la próxima pantalla nos pide rellenar la información de la aplicación (nuestro servidor):

Rellena tu email en el campo User Support y también en el campo Developer Contact Information. Haz clic en Save y Continue nos traerá a la fase Scopes de esta configuración. Omite esta fase, ya que no es relevante para nosotros, y dirígete a la fase Test Users.

Aquí, añádete a ti mismo como un usuario y haz clic en Save y Continue.

Cómo configurar tus Opciones de OAuth

En esta fase crearemos nuestras credenciales de OAuth para ser usados con Nodemailer. Dirígete a la pestaña Credentials sobre OAuth Consent Screen. Haz clic en el signo más (➕) que tiene el texto Create Credentials y elige OAuth Client ID.

En el menú desplegable de tipo de Aplicación, elige Web Application:

En la sección de Authorized Redirect URIs, asegúrate de agregar OAuth2 Playground, ya que lo usaremos para obtener una de las claves que fue mencionado al principio de este artículo.

Después de hacer clic en create, te será presentado tú id y secreto de cliente. Guárdalos y nunca los expongas de ninguna manera o forma.

Obtén tu Token de Actualización de OAuth

Para obtener un token de actualización, el cual usaremos dentro del objeto transporter en Nodemailer, necesitamos dirigirnos al Playground de OAuth2. Aprobamos este URI para este propósito específico en una etapa previa.

1. Haz clic en el ícono de engranaje a la derecha (el cual es la Configuración de OAuth2) y verifica la casilla de verificación para usar tus propias Credenciales de OAuth2:

2. Mira a la parte izquierda del sitio web y verás una lista de servicios. Desplázate hacia abajo hasta que veas Gmail API v1.

3. Haz clic en Authorize APIs

Te será presentado una pantalla para iniciar sesión con cualquiera de tus cuentas Gmail. Elige la que listaste como un usuario de Prueba.

4. La próxima pantalla te hará saber que Google todavía no ha verificado esta aplicación, pero esto está bien, ya que no lo hemos entregado para verificación. Haz clic en continue.

5. En la próxima pantalla, te preguntará para conceder permiso a tu proyecto para interactuar con tu cuenta de Gmail. Házlo.

6. Una vez que esto está hecho, serás redireccionado de vuelta al Plaground de OAuth y puedes ver que hay un código de autorización en el menú a la izquierda. Haz clic en el botón azul etiquetado Exchange authorization code for tokens.

Los campos para el token de actualización y el token de acceso estarán rellenados ahora.

De vuelta al Servidor

Después de hacer todas esas configuraciones, podemos volver a nuestra aplicación e ingresar todos esos datos en la creación de transporter. Para tener todas tus credenciales de manera privada, puedes usar el paquete dotenv. No te olvides también de agregar el archivo .env que crearás en .gitignore.

Así que, ahora tenemos esto:

let transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        type: 'OAuth2',
        user: process.env.MAIL_USERNAME,
        pass: process.env.MAIL_PASSWORD,
        clientId: process.env.OAUTH_CLIENTID,
        clientSecret: process.env.OAUTH_CLIENT_SECRET,
        refreshToken: process.env.OAUTH_REFRESH_TOKEN
      }
    });

Después, crearemos el objeto mailOptions, el cual tiene los detalles de a dónde enviar el email y con qué datos.

let mailOptions = {
      from: tomerpacific@gmail.com,
      to: tomerpacific@gmail.com,
      subject: 'Nodemailer Project',
      text: 'Hi from your nodemailer project'
    };

Este objeto puede tener muchos más campos e inclusive múltiples recipientes, pero no veremos eso aquí.

Finalmente, usaremos el método sendMail:

transporter.sendMail(mailOptions, function(err, data) {
      if (err) {
        console.log("Error " + err);
      } else {
        console.log("Email sent successfully");
      }
    });

Ejecuta tu aplicación y verás tu bandeja de entrada ser rellenado con un nuevo email.

Este artículo fue inspirado de un proyecto que creé que usa Nodemailer. Si quieres verlo, ve aquí.

Si estás buscando un tutorial que te enseñe lo básico de Nodejs y la línea de comando, estás en el lugar correcto.

Puedes usar JavaScript para construir casi cualquier software (web, móvil, bots, etcétera). La razón es que las computadoras ya no dependen en los buscadores solamente para entender código de JavaScript.

Node.js es usado para ejecutar aplicaciones backend que son escritos en JavaScript.

Te enseñare cómo construir una aplicación de línea de comando que puede leer, escribir, editar y eliminar datos usando Node.js. No requerirá conectar a bases de datos externos como MySQL, MongoDB, PostgreSQL, etcétera. Puedes ver el proyecto aquí.

Al final de este artículo, serías capaz de configurar un proyecto básico de Node, manipular archivos, usar módulos, navegar promesas, recoger entradas, etcétera.

También agregué videos para mejorar tu aprendizaje.

Prerequisitos

No necesitas ningún conocimiento de programación previo para entender este tutorial.

Cómo funcionará el Proyecto Finalizado

La aplicación que vamos a construir será capaz de hacer lo siguiente:

• Chequear si existe una base de datos
• Recuperar datos de una base de datos
• Agregar nuevos datos a la base de datos
• Actualizar la base de datos con nuevos datos
• Remover datos de la base de datos

Cómo Instalar Node y NPM

Por favor ve a la página de Nodejs y descarga la versión recomendada para todos los usuarios. Instálalo después de que la descarga esté completa.

Usa los comandos debajo para chequear si la instalación fue exitosa:

• Para Node

node -v

• Para npm

npm -v

La instalación es exitosa si cada comando regresa un número de versión.

Cómo Configurar un Proyecto de Node.js

Los pasos de abajo te ayudarán a configurar tu proyecto:

Abre la terminal o CMD y crea el directorio del proyecto:

mkdir node_CLI_app

Navega hacia el directorio:

cd node_CLI_app

Inicializa el proyecto:

npm init	

Traerá algunas preguntas. Presionar el botón Enter para cada indicación.

Un nuevo archivo (package.json) debería haber sido agregado en el directorio de tu proyecto. Usaremos el archivo para agregar código externo (módulo) al proyecto.

Agregar la siguiente línea antes de la llave (}) para habilitar import de ES6:

"type": "module"

¡Eso completa la configuración del proyecto!

Cómo Instalar Dependencias

Recordarás que el archivo package.json es para agregar código externo al proyecto. Este código externo también es llamado Dependencias, Módulos, o Paquetes. Está escrito por otros programadores (usualmente gratis) para ayudar a otros construir aplicaciones más rápido. Encontrarás muchos de estos en la página de npm.

Necesitamos dos (2) paquetes para este proyecto: inquirer y uuid. Te mostraré cómo puedes instalarlos en esta sección.

La instalación de paquetes sigue este patrón:

npm install <nombre_de_paquete>

Podemos instalar más de un paquete a la vez separando los nombres de los paquetes con un espacio:

npm install <nombre_de_paquete_1> <nombre_de_paquete_2> <nombre_de_paquete_3>

El comando install puede ser reemplazado con i para conveniencia.

Así que ejecuta el siguiente comando para instalar los paquetes:

npm i inquirer uuid

Tu archivo package.json debería tener las siguientes líneas de código agregadAs cuando la instalación esté completa:

  "dependencies": {
    "inquirer": "^9.1.4",
    "uuid": "^9.0.0"
  }

Los números de versión podrían diferir, pero no hay problema.

También notarás que un archivo (package.lock.json) y una carpeta (node_modules) han sido agregados. No tienes que preocuparte por ellos. Sólo ten en mente que te ayudan a gestionar código externo que agregamos.

¡Eso completa la instalación de dependencias!

Cómo crear un Nuevo Archivo desde la Terminal

Puedes crear un archivo desde la terminal usando el siguiente comando:

• En Mac:

touch <nombre_archivo>

• En Windows:

echo.><nombre_archivo>

También puedes crear mas de un archivo a la vez separando los archivos con un espacio. Así es como generaremos los archivos para este proyecto:

touch agregarDatos.js quitarDatos.js recuperarDatos.js actualizarDatos.js consultarBD.js bdArchivoChequeo.js

Cada uno de esos archivos jugarán un rol único en la aplicación.

• agregarDatos.js agrega datos a la Base de Datos. También fabrica el archivo de la Base de Datos si éste no existe.
• quitarDatos.js quita datos seleccionados.
• recuperarDatos.js busca todos los datos.
• actualizarDatos.js edita los datos.
• consultarBD.js chequea si la Base de Datos existe y ejecuta una función que se le pasa.
• bdArchivoChequeo.js confirma si el archivo de la Base de Datos ha sido creado.

Hay un archivo más que no creamos: el archivo de la base de datos (bd.json). Lo auto-generaremos usando nuestro código.

Cómo Comprobamos si un Archivo existe

Node.js provee un módulo integrado para manipular archivos – file system (fs). Uno de los métodos que el módulo contiene es el método existsSync. Regresa true o false dependiendo en si el archivo ha sido creado. Lo usaré para verificar si el archivo bd.json está en el proyecto. Vea el código de abajo:

  import fs from "fs";
  import { exit } from "process";  
  
  if (fs.existsSync("bd.json")) {
    console.log("El archivo existe!");
    exit(1);
  }

El método exit termina un proceso.

Así es como queremos hacer en el archivo bdArchivoChequeo.js. Sin embargo, queremos invertir el resultado agregando un ! antes del método fs.existsSync así:

  import fs from "fs";
  import { exit } from "process";  
  
  if (!fs.existsSync("bd.json")) {
    console.log("El archivo no existe!");
    exit(1);
  }

Esto será necesario cuando se construye otras funcionalidades como actualizar y eliminar datos.

Así que, ¿cómo ganarán acceso esos archivos a este código? Es a través de una estructura modular. Eso implica empaquetar este código y hacerlo accesible a través de otros archivos en el proyecto. El comando export lo hace posible:

import fs from "fs";
import { exit } from "process";

export default function dbFileCheck() {
  if (!fs.existsSync("bd.json")) {
    console.log("La Base de Datos está vacía. ¡Crea algún dato!");
    exit(1);
  }
}

El código de arriba pone el código en una función (bdArchivoChequeo) y lo exporta usando el comando export. Esta función ahora puede ser importado y usado en otros archivos dentro de este proyecto.

Ten en cuenta que la palabra clave default es necesario para el primer export de un archivo.

Cómo Consultar la Base de Datos

Otro método que file system tiene es el método readFile. Regresa el contenido de cualquier archivo que se le pase.

El método readFile toma dos parámetros: el archivo a ser leído y una función callback que regresa el resultado de la operación.

Usaremos el siguiente código para recuperar datos desde nuestra base de datos:

import fs from "fs";

fs.readFile("bd.json", function (err, datos) {
  if (err) {
    console.log(err);
  }
  console.log(datos.toString());
});

El código de arriba importa el módulo file system e intenta leer el archivo de la base de datos. Si hay un error, regresará el error. Si no hay errores, regresará los datos que obtuvo.

El método .toString() adjuntado a los datos regresados (datos.toString()) es porque los datos recuperados es del tipo buffer por defecto, lo cual no es legible.

Abre tu proyecto en un editor de código y pega ese código dentro del archivo consultarBD.js.

Ejecuta el comando de abajo para ver si está funcionando:

node consultarBD

El comando de arriba ejecutará cada código en el consultarBD.js. La extensión .js es opcional. Lo regresará de todas maneras.

El resultado de esa operación será un error porque no tenemos el archivo.

Puedes crear el archivo bd.json, agregar algún contenido, y verificar la salida.

Pero no queremos que nuestra app intente leer el archivo de la base de datos si este no ha sido generado. Así que utiliza el método existsSync para verificar si el archivo ha sido creado. Mira cómo lo uso en el código debajo:

    import fs from "fs";

    if (fs.existsSync("bd.json")) {
      fs.readFile("bd.json", function (err, datos) {
        if (err) {
          console.log(err);
        }
        console.log(datos.toString());
      });
    } else {
      console.log("¡Datos no disponibles!");
    }

El código de arriba verífica si el archivo existe pasando el nombre del archivo (bd.json) al método fs.existsSync. Si es verdadero, entonces lee el archivo. Si es falso, regresa una cadena.

Ahora que tenemos ese código limpio, queremos hacerlo aún más robusto.

Siendo que estamos construyendo una aplicación CRUD, debemos tener acceso y hacer un seguimiento de los datos regresados. Para lograr eso, he introducido una nueva variable en el código de abajo:

    import fs from "fs";

    let info = [];
    if (fs.existsSync("bd.json")) {
      fs.readFile("bd.json", function (err, datos) {
        if (err) {
          console.log(err);
        }
        info = JSON.parse(datos.toString());
        console.log(info);
      });
    } else {
      console.log("¡Datos no disponibles!");
    }

El código de arriba ahora tiene una variable, info. Hace un seguimiento de los datos regresados. Pasé los datos a través del método JSON.parse para convertir los datos de una cadena a un arreglo.

Ahora podemos manipular el info según lo consideremos. Tenemos que exportar el código y aceptar una función para hacer esto posible. Esa función tomará la variable info como entrada y luego usarlo cuando sea requerido.

import fs from "fs";

export default async function consultarBD(funcionExterna) {
  try {
    let info = [];

    if (fs.existsSync("bd.json")) {
      await fs.readFile("bd.json", function (err, datos) {
        info = JSON.parse(datos.toString());
        console.log(info);

        if (err) {
          console.log(err);
          return;
        }

        if (funcionExterna && !err) {
          funcionExterna(info);
          return;
        }
      });
    } else {
      if (funcionExterna) {
        funcionExterna(info);
        return;
      }
    }
  } catch (error) {
    console.error(`Algo ocurrió: ${error.message}`);
  }
}

Este código toma una función y lo ejecuta solamente si no hay errores. Sin embargo, habrá una excepción – cuando se agreguen datos. En ese caso, la base de datos será creado.

El bloque try...catch... ayuda a recoger errores, y las palabras claves async await son usados cuando se ejecuta código que tomará mucho tiempo en correr.

El consultarBD.js ya no regresará ninguna salida cuando ejecutemos el comando node consultarBD. Pero está bien. Lo dispararemos desde otros archivos.

Cómo Agregar Datos a un Archivo

En esta sección, te enseñaré cómo agregar datos al almacén. El archivo para esta sección es el archivo agregarDatos.js.

Empezaremos por importar todos los módulos necesarios:

import inquirer from "inquirer";
import fs from "fs";
import { v4 as uuidv4 } from "uuid";
import consultarBD from "./consultarBD.js";

Siguiente, crea el boilerplate para la función:

export default async function agregarDatos(info) {
  try {
    
  } catch (error) {
    console.log("¡Algo salió mal!", error);
  }
}

Esto es similar a lo que hemos hecho antes de ahora. Todo el código que escribiríamos luego irá dentro del bloque try.... El arreglo info pasado a la función viene del archivo consultarBD.

La primera cosa por hacer en el bloque try... es recolectar los datos que serán almacenados. Usaremos inquirer para hacer eso con el código de abajo:

const respuestas = await inquirer.prompt([
      {
        type: "input",
        name: "nombre",
        message: "¿Cómo te llamas?",
      },
      {
        type: "number",
        name: "telefono",
        message: "¿Cuál es tu teléfono?",
      },
      {
        type: "list",
        name: "edad",
        message: "¿Eres un adulto?",
        choices: [
          { name: "S", value: "Adulto" },
          { name: "N", value: "Menor" },
        ],
      },
    ]);

El paquete inquirer ayuda en la construcción de interfaces de línea de comandos interactivos. Contiene un método llamado prompt usado para pedir datos. Toma un arreglo de preguntas en formato de objeto. Cada objeto debe tener las claves name, type y message.

La clave choices es opcional. Es usado cuando hay una lista de opciones.

Así que el código de arriba recolecta tres (3) entradas (nombre, teléfono, y edad) y los almacena en una variable llamada respuestas.

Luego, asignamos a este conjunto de entradas un ID único llamando la función uuidv4() y empujar todo dentro del arreglo info:

    const datos = {
      id: uuidv4(),
      nombre: answers.nombre,
      telefono: answers.telefono,
      edad: answers.edad,
    };
    info.push(datos);

Finalmente, verificamos si el archivo de la base de datos existe. Actualizaremos la base de datos con los nuevos datos si el archivo ha sido creado o crearlo y agregar los nuevos datos si es falso.

    if (fs.existsSync("bd.json")) {
      crearDetalles(info);
    } else {
      fs.appendFile("bd.json", "[]", (err) => {
        if (err) {
          console.log("No se pudo crear bd.json", err);
          return;
        }
        crearDetalles(info);
      });
    }

La función crearDetallesserá usado para sobreescribir los datos de la base de datos. Lo crearé en un momento.

En el bloque else (si el archivo no existe), creé el archivo usando el método appendFile del sistema. Este método es usado para crear un archivo si no está allí todavía y agregar o adjuntar datos al final del archivo.

Estoy adjuntando [] al archivo. Así que el nuevo archivo creado tendrá sólo [] dentro. Llamé a la función crearDetalles luego para agregar los datos coleccionados desde el CLI.

Por favor escribe el siguiente código para la función crearDetalles la función de agregarDatos abajo:

async function crearDetalles(info) {
  await fs.writeFile("bd.json", JSON.stringify(info), function (err) {
    if (err) {
      console.log(err);
    }
    console.log("¡Guardado!");
  });
}

Esta función usa el método writeFile del sistema de archivos para sobreescribir la base de datos con datos actuales. Estoy usando JSON.stringify para convertir la variable info a una cadena porque es el formato aceptable cuando se escribe a un archivo. Eso también explica por qué usé JSON.parse para convertirlo al tipo original cuando lo recuperé en la sección previa.

writeFile es diferente desde appendFile porque writeFile sobreescribe un archivo mientras que appendFile agrega al contenido existente. Son similares en tanto que ambos métodos creará el archivo si este no ha sido creado.

Lo último para hacer en este archivo es invocar o llamar a la función. La manera de hacerlo es escribir su nombre seguido de abrir y cerrar paréntesis de esta manera:

agregarDatos();

Esto podría funcionar bien, pero no haría lo que queremos. Necesitamos pasar la función como un argumento dentro de consultarBD de esta manera:

consultarBD(agregarDatos);

Ahora, el agregarDatos será capaz de comunicarse con la función consultarBD.

Cómo Testear el Archivo agregarDatos

Ejecuta el comando de abajo para testear si el archivo agregarDatos funciona como se espera:

node agregarDatos

Te mostrará mensajes para responder. Completa las respuestas. Después de eso, tu pantalla debería parecerse como el mío:

También debería haber auto-generado un archivo db.json con los datos que agregaste.

Y eso es todo para el archivo agregarDatos!

Cómo Recuperar Datos

Esta sección te muestra cómo obtener el contenido de la base de datos. Todo lo que necesitas para lograr esta funcionalidad es el código de abajo:

import consultarBD from "./consultaBD.js";

consultarBD();

Lo que el código hace es importar la función consultarBD e invocarla. Pega el código en el archivo recuperarDatos.js y ejecuta el archivo con:

node recuperarDatos

Regresará una salida similar a esto:

Te preguntarás: ¿por qué no llamé esta función en el archivo consultarBD? La razón es que el archivo realiza más que sólo recuperar datos. Llamar la función consultarBD en su archivo alterará el resultado de los otros archivos.

Cómo Editar Datos

Esta sección ahora se enfocará en cómo actualizar datos. El patrón a seguir aquí es:

• Recoger el ID del usuario.
• Buscar al usuario.
• Regresar los datos del usuario si el usuario existe, y establecerlo como la opción por defecto.
• Pedir por información actualizada. El valor inicial será guardada si el usuario presiona la tecla Enter.
• Finalmente, sobrescribir la base de datos con la información actualizada.

Hagámoslo...

Navega dentro del archivo actualizarDatos.js y pega el siguiente código:

import inquirer from "inquirer";
import fs from "fs";
import consultarBD from "./consultarBD.js";
import bdArchivoChequeo from "./bdArchivoChequeo.js";

export default async function actualizarDatos(info) {
  bdArchivoChequeo();

  try {
    
  } catch (error) {
    console.log("Algo salió mal!", error);
  }
}

Este es el código para la función actualizarDatos. Lo nuevo aquí es la función bdArchivoChequeo (hecho hace unos momentos atrás) para terminar una operación si la base de datos no ha sido creada.

El resto del código estará dentro del bloque try....

Lo primero es recoger el ID del usuario con este código:

    const respuestas = await inquirer.prompt([
      {
        type: "input",
        name: "registroID",
        message: "Ingresa Registro ID",
      },
    ]);

El segundo es buscar al usuario:

    let actual;

    info.forEach((elemento) => {
      if (elemento.id === respuestas.registroID) {
        actual = elemento;

        actualizarDetalles(actual, info);
      }
    });

El código de arriba busca a través de los usuarios (info) y coloca al usuario hallado en la variable actual. Finalmente, la función actualizarDetalles es llamado para recoger la información actualizada y sobrescribir la base de datos con los nuevos datos.

Cómo construir la función actualizarDetalles

Esta parte mostrará cómo hacer un seguimiento de los datos iniciales de un usuario mientras se recogen nuevos datos. Actualizará la base de datos con los nuevos datos después.

El siguiente código es la estructura para la función:

async function actualizarDetalles(actual, info) {
  try {
    
  } catch (error) {
    console.log("¡Algo salió mal!", error);
  }
}

Este código va debajo de la operación actualizarDatos.

El código de abajo va dentro del bloque try.... Es para recoger información actualizada del usuario.

  const devoluciones = await inquirer.prompt([
      {
        type: "input",
        default: actual.nombre,
        name: "nombre",
        message: "¿Cuál es tu nombre?",
      },
      {
        type: "number",
        default: actual.telefono,
        name: "telefono",
        message: "¿Cuál es tu teléfono?",
      },
      {
        type: "list",
        default: actual.edad,
        name: "edad",
        message: "¿Eres un adulto?",
        choices: [
          { name: "S", value: "Adulto" },
          { name: "N", value: "Menor" },
        ],
      },
    ]);

La clave default es nuevo. Retiene dato que será usado si el usuario no provee una. Hace un seguimiento de los datos actuales del usuario para este código. Así, el usuario puede presionar el botón Enter en vez de ingresar el valor anterior otra vez.

Los detalles del usuario debería ser actualizado respectivamente usando este código:

    actual.nombre = devoluciones.nombre;
    actual.telefono = devoluciones.telefono;
    actual.edad = devoluciones.edad;

Finalmente, sobrescribir la base de datos con el nuevo valor:

await fs.writeFile("bd.json", JSON.stringify(info), function (err) {
      if (err) {
        console.log(err);
      }
      console.log("actualizado");
    });

Llama la función actualizarDatos para traer todo junto:

consultarBD(acutalizarDatos)

Cómo testear el archivo actualizarDatos

Ejecuta el comando debajo para ver cómo actúa la función actualizarDatos:

node actualizarDatos

Te mostrará un mensaje pidiendo un ID. Ingresa el ID de cualquier registro en la base de datos.

Luego te mostrará un mensaje por información actualizada sobre el usuario. Rellena la información y presiona Enter por cualquier detalle que no necesite una actualización. La terminal debería lucir así al final:

Eso concluye para el archivo actualizarDatos. Los registros pueden ser actualizados ahora.

Cómo Eliminar Datos

Una aplicación CRUD no puede ser completado sin la parte de DELETE (ELIMINAR). Ese será el enfoque aquí. Tomará un poco de las secciones anteriores. Así no será mucho para captar.

Empezarás por escribir el siguiente código en el archivo removerDatos.js:

import inquirer from "inquirer";
import fs from "fs";
import consultarBD from "./consultarBD.js";
import bdArchivoChequeo from "./bdArchivoChequeo.js";

export default async function removerDatos(info) {
  bdArchivoChequeo();

  try {
    const respuestas = await inquirer.prompt([
      {
        type: "input",
        name: "registroID",
        message: "Ingresa el ID del Registro",
      },
    ]);

    let datosRestantes = [];
    info.forEach((elemento) => {
      if (elemento.id !== respuestas.registroID) {
        datosRestantes.push(elemento);
      }
    });

    fs.writeFile("bd.json", JSON.stringify(datosRestantes), function (err) {
      if (err) {
        console.log(err);
      }
      console.log("¡Eliminado!");
    });
  } catch (error) {
    console.log("¡Algo salió mal!", error);
  }
}

Primero, el código de arriba recoge un ID.

Luego, usa el ID para buscar los datos de la base de datos y retiene solamente los datos con un ID distinto en el arreglo datosRestantes.

Finalmente, sobrescribe la base de datos con los datos actualizados.

Llama la función removerDatos al final para poner todo junto de esta manera:

consultarBD(removerDatos)

Ahora intenta testear el archivo usando este comando:

node removerDatos

Esta es mi salida:

Conclusión

La mejor manera para aprender a programar es haciendo. Y algunos de los mejores proyectos es construir aplicaciones CRUD porque cubren lo básico de lo que un proyecto profesional requiere. Esto es lo que he hecho en este tutorial.

Te he enseñado lo básico de Node.js construyendo una aplicación que crea, lee, actualiza, y elimina registros. Cubrí conceptos tales como leer archivos, escribir a archivos, bucles, sentencias condicionales, módulos y operaciones del CLI.

Todos los archivos para este tutorial están en GitHub.

Ahora tienes todo lo básico necesario para empezar a construir aplicaciones usando Node.js. Algo que me gustaría que intentaras es actualizar o eliminar más de un registro a la vez.

Tengo otros tutoriales en Node.js, y te sugiero que los sigas en este orden para hacer crecer tus habilidades:

• Cómo Construir un Servidor Seguro con Node.js y Express y Subir Imágenes con Cloudinary
• Cómo Construir y Desplegar una App Backend con Express, Postgres, Github, y Heroku
• Cómo Construir una App de Autenticación Full-Stack con React, Express, MongoDB, Heroku y Netlify

¡Feliz día construyendo!

Mongoose es una biblioteca de modelado de datos orientada a objetos (ODM) para MongoDB y Node.js. Administra las relaciones entre los datos, proporciona validación de esquemas y se utiliza para traducir entre objetos en el código y la representación de esos objetos en MongoDB.

MongoDB es una base de datos de documentos NoSQL sin esquema. Significa que puede almacenar documentos JSON en él, y la estructura de estos documentos puede variar,  porque que no se aplica como las bases de datos SQL. Esta es una de las ventajas de usar NoSQL, ya que acelera el desarrollo de aplicaciones y reduce la complejidad de las implementaciones.

A continuación se muestra un ejemplo de cómo se almacenan los datos en Mongo vs. SQL Database:

Terminologías

Colecciones

Las "colecciones" en Mongo son equivalentes a las tablas en las bases de datos relacionales. Pueden contener varios documentos JSON.

Documentos

Los "documentos" son equivalentes a registros o filas de datos en SQL. Si bien una fila de SQL puede hacer referencia a datos en otras tablas, los documentos de Mongo generalmente combinan eso en un documento.

Campos

Los "campos" o atributos son similares a las columnas de una tabla SQL.

Esquema

Si bien Mongo no tiene esquema, SQL define un esquema a través de la definición de la tabla. Un "esquema" de Mongoose es una estructura de datos del documento (o la forma del documento) que se aplica a través de la capa de aplicación.

Modelos

Los "modelos" son constructores de orden superior que toman un esquema y crean una instancia de un documento equivalente a los registros en una base de datos relacional.

Ejemplo
Aquí hay un pequeño fragmento de código para ilustrar parte de la terminología anterior:

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

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

En el código anterior, puppySchema se define la forma del documento. Este tiene dos campos nombre y edad, name ,age.

Usamos SchemaType para name como un String mientras que para la variable age empleamos Number (debido a que la edad denota un número específico). Observa que cuando definimos SchemaType para un campo, por medio de usar un objeto con la propiedad  type igual a la de name. O bien, puedes aplicar SchemaType directamente al campo age.

También observa que SchemaType para name tiene la opción required ajustada a un valor booleano true. Para usar opciones como required y lowercase en un campo, necesitas emplear un objeto específico que te ayude a definir el SchemaType.

En la parte inferior del fragmento, puppySchema se compila en un modelo llamado  Puppy, que luego se puede usar para construir documentos en una aplicación.

Empezando

Instalación de Mongodb

Antes de comenzar, configuremos Mongo. Puedes elegir entre una de las siguientes opciones (estamos usando la opción n.º 1 para este artículo):

1.Descarga la versión más apropiada de MongoDB version para tu sistema operativo del Website de MongoDB, y sigue las correspondientes instrucciones de instalación.

2.Crea una base de datos sandbox gratuita mediante una suscripción en mLab.

3. Instala Mongo usando Docker si prefieres usar Docker.

Naveguemos a través de algunos de los conceptos básicos de Mongoose implementando un modelo que representa datos para una libreta de direcciones simplificada.
Estoy usando Visual Studio Code, Node 8.9 y NPM 5.6. Enciende tu IDE favorito, crea un proyecto en blanco y ¡comencemos! Usaremos la sintaxis ES6 limitada en Node, por lo que no configuraremos Babel.

NPM Install

Vayamos al archivo del proyecto para darle un inicio.

npm init -y

Instalamos Mongoose junto con una biblioteca de validación con el siguiente comando:

npm install mongoose validator

El comendo anterior instalará la última versión de las bibliotecas. La sintaxis de Mongoose en este artículo es específica desde Mongoose v5 en adelante.

Conección a la Base de Datos

Crea un archivo  ./src/database.js bajo la raíz del proyecto.

A continuación, añadiremos una clase simple con un método que se conecta a la base de datos.
La cadena de conexión variará según los detalles de tu instalación.

let mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
const database = 'fcc-Mail';      // REPLACE WITH YOUR DB NAME

class Database {
  constructor() {
    this._connect()
  }
  
_connect() {
     mongoose.connect(`mongodb://${server}/${database}`)
       .then(() => {
         console.log('Database connection successful')
       })
       .catch(err => {
         console.error('Database connection error')
       })
  }
}

module.exports = new Database()

La llamada require(‘mongoose’) retorna un objeto Singleton. Lo que significa que la primera vez que llames require(‘mongoose’), está creando una instancia de la clase Mongoose y devolviéndola. En llamadas posteriores, devolverá la misma instancia que se creó y se le devolvió la primera vez debido a cómo funciona la importación/exportación de módulos en ES6.

De manera similar, hemos convertido nuestra clase de base de datos en un singleton al devolver una instancia de la clase en la declaración module.exports porque solo necesitamos una única conexión a la base de datos.

ES6 hace que sea muy fácil para nosotros crear un patrón singleton (instancia única) debido a cómo funciona el cargador de módulos al almacenar en caché la respuesta de un archivo previamente importado.

Esquema Mongoose vs. Modelo

Un modelo Mongoose es un contenedor en el esquema Mongoose. Un esquema Mongoose define la estructura del documento, valores predeterminados, validadores, etc., mientras que un modelo Mongoose proporciona una interfaz a la base de datos para crear, consultar, actualizar, eliminar registros, etc.

La creación de un modelo Mongoose consta principalmente de tres partes:

1. Referenciando Mongoose

let mongoose = require('mongoose')

Esta referencia será la misma que se devolvió cuando nos conectamos a la base de datos, lo que significa que las definiciones de esquema y modelo no necesitarán conectarse explícitamente a la base de datos.

2. Definiendo el esquema

Un esquema define las propiedades del documento a través de un objeto donde el nombre de la clave corresponde al nombre de la propiedad en la colección.

let emailSchema = new mongoose.Schema({
  email: String
})

Aquí definimos una propiedad llamada correo electrónico con un tipo de esquema String que se asigna a un validador interno que se activará cuando el modelo se guarde en la base de datos. Fallará si el tipo de datos del valor no es un String.

A nivel general, los siguientes tipos de esquemas están permitidos en Mogoose:

• Array (Arreglo)
• Boolean (Booleano)
• Buffer
• Date (Fecha)
• Mixto (Genérico/ tipo de dato flexible)
• Number (Número)
• ObjectId
• String

Mixed y ObjectId están definidas mediante require(‘mongoose’).Schema.Types.

3. Exportando un modelo

Necesitamos llamar al constructor del modelo en la instancia de Mongoose y pasarle el nombre de la colección y una referencia a la definición del esquema.

module.exports = mongoose.model('Email', emailSchema)

Resumamos el código de arriba en ./src/models/email.js . Esto a fin de definir los contenidos de un modelo de email básico:

let mongoose = require('mongoose')

let emailSchema = new mongoose.Schema({
  email: String
})

module.exports = mongoose.model('Email', emailSchema)

La definición de un esquema debe ser simple, pero su complejidad generalmente se basa en los requisitos de la aplicación. Los esquemas se pueden reutilizar y también pueden contener varios esquemas secundarios.

En el ejemplo anterior, el valor de la propiedad de correo electrónico es un tipo de valor simple. Sin embargo, también puede ser un tipo de objeto con propiedades adicionales.
Podemos crear una instancia del modelo que definimos anteriormente y llenarlo usando la siguiente sintaxis:

let EmailModel = require('./email')

let msg = new EmailModel({
  email: 'ada.lovelace@gmail.com'
})

Mejoremos el esquema de correo electrónico para hacer que la propiedad de correo electrónico sea un campo único y obligatorio y convertir el valor a minúsculas antes de guardarlo. También podemos agregar una función de validación que garantizará que el valor sea una dirección de correo electrónico válida. Haremos referencia y usaremos la biblioteca de validación instalada anteriormente.

let mongoose = require('mongoose')
let validator = require('validator')

let emailSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    validate: (value) => {
      return validator.isEmail(value)
    }
  }
})

module.exports = mongoose.model('Email', emailSchema)

Operaciones Básicas

Mongoose tiene una API flexible y proporciona muchas formas de realizar una tarea. No nos centraremos en las variaciones porque están fuera del alcance de este artículo, pero recuerde que la mayoría de las operaciones se pueden realizar de más de una forma, ya sea sintácticamente o mediante la arquitectura de la aplicación.

Crear un registro

Vamos a crear una instancia del modelo de correo electrónico y guardarlo en la base de datos:

let EmailModel = require('./email')

let msg = new EmailModel({
  email: 'ADA.LOVELACE@GMAIL.COM'
})

msg.save()
   .then(doc => {
     console.log(doc)
   })
   .catch(err => {
     console.error(err)
   })

El resultado es un documento que se devuelve al guardar correctamente:

{ 
  _id: 5a78fe3e2f44ba8f85a2409a,
  email: 'ada.lovelace@gmail.com',
  __v: 0 
}

Se devuelven los siguientes campos (los campos internos tienen un prefijo con un guión bajo):

1. El campo _id es generado automáticamente por Mongo y es una clave principal de la colección. Su valor es un identificador único para el documento.
2. El valor del campo email es devuelto. Observa que está en minúsculas porque especificamos el lowercase:true atribuido en el esquema.
3. __v es la propiedad versionKey establecida en cada documento cuando Mongoose lo crea por primera vez. Su valor contiene la revisión interna del documento.

Si intentas repetir la operación de guardar anterior, obtendrás un error porque hemos especificado que el campo de correo electrónico debe ser único.

Obtener un registro

Intentemos recuperar el registro que guardamos en la base de datos anteriormente. La clase modelo expone varios métodos estáticos y de instancia para realizar operaciones en la base de datos. Ahora intentaremos encontrar el registro que creamos previamente usando el método de búsqueda y pasar el correo electrónico como término de búsqueda.

EmailModel
  .find({
    email: 'ada.lovelace@gmail.com'   // search query
  })
  .then(doc => {
    console.log(doc)
  })
  .catch(err => {
    console.error(err)
  })

El documento devuelto será similar al que se mostró cuando creamos el registro:

{ 
  _id: 5a78fe3e2f44ba8f85a2409a,
  email: 'ada.lovelace@gmail.com',
  __v: 0 
}

Actualizar Registro

Modifiquemos el registro anterior cambiando la dirección de correo electrónico y agregando otro campo, todo en una sola operación. Por motivos de rendimiento, Mongoose no devolverá el documento actualizado, por lo que debemos pasar un parámetro adicional para solicitarlo:

EmailModel
  .findOneAndUpdate(
    {
      email: 'ada.lovelace@gmail.com'  // search query
    }, 
    {
      email: 'theoutlander@live.com'   // field:values to update
    },
    {
      new: true,                       // return updated doc
      runValidators: true              // validate before update
    })
  .then(doc => {
    console.log(doc)
  })
  .catch(err => {
    console.error(err)
  })

El documento devuelto contendrá el correo electrónico actualizado:

{ 
  _id: 5a78fe3e2f44ba8f85a2409a,
  email: 'theoutlander@live.com',
  __v: 0 
}

Borrar registro Record

Usaremos findOneAndRemove para borrar un registro. Este retorna el documento original que ha sido removido:

EmailModel
  .findOneAndRemove({
    email: 'theoutlander@live.com'
  })
  .then(response => {
    console.log(response)
  })
  .catch(err => {
    console.error(err)
  })

Ayudas

Hemos analizado algunas de las funciones básicas anteriores conocidas como operaciones CRUD (Crear, Leer, Actualizar, Eliminar), pero Mongoose también brinda la capacidad de configurar varios tipos de métodos auxiliares y propiedades. Estos se pueden utilizar para simplificar aún más el trabajo con datos.

Creemos un esquema ./src/models/user.js con los camposfirstName y lastName:

let mongoose = require('mongoose')

let userSchema = new mongoose.Schema({
  firstName: String,
  lastName: String
})

module.exports = mongoose.model('User', userSchema)

Propiedad Virtual

Una propiedad virtual no se conserva en la base de datos. Podemos agregarlo a nuestro esquema como ayuda para obtener y establecer valores.

Creemos una propiedad virtual fullName que puede ser empleada para asignar valores en firstName y lastName y recuperarlos como un valor combinado cuando se lea:

userSchema.virtual('fullName').get(function() {
  return this.firstName + ' ' + this.lastName
})

userSchema.virtual('fullName').set(function(name) {
  let str = name.split(' ')
  
  this.firstName = str[0]
  this.lastName = str[1]
})

Las devoluciones de llamada para get y set (en el código) deben usar la palabra clave function, ya que necesitamos acceder al modelo a través de la palabra clave this. El uso de funciones de flecha gruesa cambiará a lo que thisse refiere.

Ahora podemos definir firstName y lastName asignándole un valor a fullName:

let model = new UserModel()

model.fullName = 'Thomas Anderson'

console.log(model.toJSON())  // Output model fields as JSON
console.log()
console.log(model.fullName)  // Output the full name

El resultado del código anterior es el siguiente:

{ _id: 5a7a4248550ebb9fafd898cf,
  firstName: 'Thomas',
  lastName: 'Anderson' }
  
Thomas Anderson

Métodos de instancia

Podemos crear métodos auxiliares personalizados en el esquema y acceder a ellos a través de la instancia del modelo. Estos métodos tendrán acceso al objeto modelo y se pueden usar de manera bastante creativa. Por ejemplo, podríamos crear un método para encontrar a todas las personas que tienen el mismo nombre que la instancia actual.

En este ejemplo, vamos a crear una función para devolver las iniciales del usuario actual. Agreguemos un método auxiliar personalizado llamado getInitials al esquema:

userSchema.methods.getInitials = function() {
  return this.firstName[0] + this.lastName[0]
}

Se podrá acceder a este método a través de una instancia de modelo:

let model = new UserModel({
  firstName: 'Thomas',
  lastName: 'Anderson'
})

let initials = model.getInitials()

console.log(initials) // This will output: TA

Métodos estáticos

Similar a los métodos de instancia, podemos crear métodos estáticos en el esquema. Vamos a crear un método para recuperar todos los usuarios en la base de datos:

userSchema.statics.getUsers = function() {
  return new Promise((resolve, reject) => {
    this.find((err, docs) => {
      if(err) {
        console.error(err)
        return reject(err)
      }
      
      resolve(docs)
    })
  })
}

Usando getUsers en la clase Modelo devolverá todos los usuarios en la base de datos:

UserModel.getUsers()
  .then(docs => {
    console.log(docs)
  })
  .catch(err => {
    console.error(err)
  })

Agregar instancias y métodos estáticos es un buen enfoque para implementar una interfaz para las interacciones de la base de datos en colecciones y registros.

Middleware

En este contexto Middleware son funciones que se ejecutan en etapas específicas de una canalización. Mongoose admite middleware para las siguientes operaciones:Aggregate

• Document
• Model
• Query

Por ejemplo, los modelos tienen funciones pre y post que toman dos parámetros:

1. Tipo de evento (‘init’, ‘validate’, ‘save’, ‘remove’)
2. Una devolución de llamada que se ejecuta con la referencia this a la instancia del modelo.

Probemos un ejemplo agregando dos campos llamados createdAt y updatedAt a nuestro esquema:

let mongoose = require('mongoose')

let userSchema = new mongoose.Schema({
  firstName: String,
  lastName: String,
  createdAt: Date,
  updatedAt: Date
})

module.exports = mongoose.model('User', userSchema)

Cuando model.save() es llamado, existe un evento pre(‘save’, …) y un evento post(‘save’, …) que es activado. Para el segundo parámetro, puedes pasar una función que se llama cuando se activa el evento. Estas funciones llevan un parámetro a la siguiente función en la cadena de middleware.

Agreguemos un gancho pre-guardado y establezcamos valores para createdAt and updatedAt:

userSchema.pre('save', function (next) {
  let now = Date.now()
   
  this.updatedAt = now
  // Set a value for createdAt only if it is null
  if (!this.createdAt) {
    this.createdAt = now
  }
  
  // Call the next function in the pre-save chain
  next()    
})

Creemos y guardemos nuestro modelo:

let UserModel = require('./user')

let model = new UserModel({
  fullName: 'Thomas Anderson'
}

msg.save()
   .then(doc => {
     console.log(doc)
   })
   .catch(err => {
     console.error(err)
   })

Deberías ver los valores para createdAt y updatedAt cuando el registro que has creado se imprime:

{ _id: 5a7bbbeebc3b49cb919da675,
  firstName: 'Thomas',
  lastName: 'Anderson',
  updatedAt: 2018-02-08T02:54:38.888Z,
  createdAt: 2018-02-08T02:54:38.888Z,
  __v: 0 }

Complementos (Plugins)

Supongamos que queremos rastrear cuándo se creó un registro y cuándo se actualizó por última vez en cada colección de nuestra base de datos. En lugar de repetir el proceso anterior, podemos crear un complemento y aplicarlo a cada esquema.

Creemos un archivo ./src/model/plugins/timestamp.js replicando la funcionalidad anterior como un módulo reusable:

module.exports = function timestamp(schema) {

  // Add the two fields to the schema
  schema.add({ 
    createdAt: Date,
    updatedAt: Date
  })

  // Create a pre-save hook
  schema.pre('save', function (next) {
    let now = Date.now()
   
    this.updatedAt = now
    // Set a value for createdAt only if it is null
    if (!this.createdAt) {
      this.createdAt = now
    }
   // Call the next function in the pre-save chain
   next()    
  })
}

Para usar este complemento, simplemente lo pasamos a los esquemas que debería tener esta funcionalidad:

let timestampPlugin = require('./plugins/timestamp')

emailSchema.plugin(timestampPlugin)
userSchema.plugin(timestampPlugin)

Construcción de Consultas

Mongoose tiene una API muy abundante que maneja muchas operaciones complejas compatibles con MongoDB. Considera una consulta en la que podamos crear componentes de consulta de forma incremental.
En este ejemplo, vamos a:

1.Buscar todos los usuarios
2.Omitir los primeros 100 registros
3.Limitar los resultados a 10 registros
4.Ordenar los resultados por el campo firstName
5.Seleccionar el nombre
6.Ejecutar esa consulta

UserModel.find()                   // find all users
         .skip(100)                // skip the first 100 items
         .limit(10)                // limit to 10 items
         .sort({firstName: 1}      // sort ascending by firstName
         .select({firstName: true} // select firstName only
         .exec()                   // execute the query
         .then(docs => {
            console.log(docs)
          })
         .catch(err => {
            console.error(err)
          })

Cierre

Apenas hemos arañado la superficie explorando algunas de las capacidades de Mongoose. Es una abundante biblioteca llena de funciones útiles y potentes que hacen que sea un placer trabajar con modelos de datos en la capa de aplicación.
Si bien puede interactuar con Mongo directamente usando Mongo Driver, Mongoose simplificará esa interacción al permitirle modelar relaciones entre datos y validarlos fácilmente.

Dato curioso: Mongoose fue creado por Valeri Karpov, ¡Un ingeniero increíblemente talentoso! Él acuñó el término The MEAN Stack.

Si este artículo te ha sido útil, sígueme en Twitter:

También te puede gustar mi taller en youtube: Cómo construir una API REST con Node | expreso | Mongo