Conecta tu proyecto a MongoDB con Express y Node.js

Hay varias maneras de utilizar MongoDB, para este tutorial, utilizaremos la versión online llamada Atlas.

Una vez creada nuestra cuenta, crearemos un proyecto:

Figura 01

Figura 01

En nuestro caso, lo llamaremos mongo-connection:

Figura 02

Figura 02

Luego “Next” y click en “Create”.

Continuamos con la creación del cluster:

Figura 03

Figura 03

Seleccionamos la versión gratuita y dejamos la configuración recomendada:

Figura 04

Figura 04

Terminamos con “Create Deployment”.

Luego creamos nuestro usuario y contraseña:

Figura 05

Figura 05

Es de suma importancia guardar dichas credenciales.

Luego establecemos desde que IPs queremos conectarnos, estableceremos que desde cualquier IP con la siguiente configuración (0.0.0.0/0), esta configuración la establecemos con fines educativos, pero no es recomendable mantener esta configuración en etapa de producción por motivos de seguridad:

Figura 06

Figura 06

Nos dirigimos a cluster y hacemos click en Connect:

Figura 07

Figura 07

Figura 08

Figura 08

Seleccionaremos la opción Drivers:

Figura 09

Figura 09

Nos muestra la url que utilizaremos para nuestra conexión, la cual varía de acuerdo a los datos ingresados previamente, pero se verá algo similar a esto:

mongodb+srv://<user>:<db_password>@cluster0.jdpbmkc.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0

Debes reemplazar el <user> y el <db_password> por los obtenidos en el paso anterior.

El resto de las configuraciones las dejaremos tal cual nos la entrega la interfaz.

Ahora que tenemos preparado mongo para conectarnos, continuamos con la creación de nuestro proyecto.

Creamos un directorio en nuestra máquina, e inicializamos un proyecto con pnpm (npm, yarn o el gestor que utilicen).

En mi caso utilizo Windows y Powershell:

❯ mkdir mongo-connection
❯ cd .\mongo-connection\
❯ pnpm init

Figura 10

Figura 10

Instalamos las dependencias que utilizaremos. Usaremos dotenv para manejar las variables de entorno, Express para la gestión de rutas y la creación de nuestro servidor, y mongoose para la creación de schemas y la conexión a nuestra base de datos:

❯ pnpm add dotenv express mongoose

Una vez instaladas nuestras dependencias, abrimos el proyecto con nuestro editor a elección, en mi caso, Visual Studio Code:

❯ code .

Primero, crearemos un archivo en la raíz del proyecto, llamado .env, el cual contendrá nuestras credenciales y el puerto donde correremos nuestra app:

MONGODB_URI =
  'mongodb+srv://<user>:<db_password>@cluster0.jdpbmkc.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0'
PORT = 3001

Cabe destacar que nunca debemos almacenar nuestras credenciales directamente en el código.

Creamos un directorio llamado “models”, el cual contendrá nuestra conexión a la base de datos y la definición de nuestros modelos y schemas.

En nuestro ejemplo, crearemos un archivo llamado employee.js que contendrá nuestro ejemplo.

Hasta el momento, nuestro proyecto debe verse algo como esto:

Figura 11

Figura 11

Continuamos con la conexión a nuestra base de datos, primero importando mongoose:

const mongoose = require('mongoose')

Estableceremos las queries de manera NO estricta, de esta manera podremos agregar valores que no están definidas en el schema (esto lo podrás configurar de acuerdo a las necesidades de cada situación, por defecto esta propiedad viene establecida en “true”):

mongoose.set('strictQuery', false)

Luego, recuperamos el valor almacenado en las variables de entorno definidas en el archivo .env, para establecer la conexión:

const url = process.env.MONGODB_URI

Para comprobar que estamos accediendo a la variable de entorno, agregaremos un console.log (es recomendable usar un logger como winston o morgan para depurar en proyectos más grandes):

console.log('Connecting to ', url)

Establecemos la conexión:

mongoose.connect(url)

mongoose.connect(url), devuelve una promesa, por lo que en caso de que sea exitosa la conexión, mostraremos un mensaje, al igual que si ocurre un error, quedando de la siguiente manera:

mongoose
  .connect(url)
  .then(() => {
    console.log('Connected to MongoDB')
  })
  .catch((error) => {
    console.log('Error connecting to MongoDB', error.message)
  })

Ahora que tenemos la conexión configurada, crearemos el schema de employee, donde definiremos las características de los datos que almacenará. Utilizaremos mongoose.Schema, el cual recibe un objeto con la definición de los datos:

const employeeSchema = mongoose.Schema({
  name: {
    type: String,
    minLength: 3,
    required: true,
  },
})

En este caso, definimos solo un campo, “name”, el cual debe tener un length mínimo de 3, y lo establecemos como obligatorio con el parámetro required: true.

Finalmente, exportamos nuestro Schema, para utilizarlo en nuestro backend:

module.exports = mongoose.model('Employee', employeeSchema)

El archivo debe verse de esta manera:

Figura 12

Figura 12

Para crear nuestro servidor y manejar las rutas, creamos un archivo en la raíz del proyecto, llamado index.js.

Primero configuramos dotenv para tener acceso a las variables definidas en el archivo .env:

require('dotenv').config()

Luego agregamos express e inicializamos nuestra app:

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

Luego importamos el schema que creamos previamente:

const Employee = require('./models/employee')

Primero, definiremos una solicitud POST que nos permitirá agregar un employee, pero para poder agregar datos a través de el “body” de la request, debemos agregar un middleware para manejar datos json:

app.use(express.json())

app.use, nos permite agregar middlewares, los cuales son funciones que se ejecutan entre la recepción de una solicitud HTTP y la respuesta final que se envía al cliente. El middleware que utilizaremos permite que express procese el cuerpo de las solicitudes HTTP.

Ahora estableceremos la ruta para agregar un employee:

app.post('/api/employees', (request, response) => {})

app.post, define una ruta HTTP para manejar solicitudes POST. Las solicitudes POST se utilizan normalmente para enviar datos al servidor.

'/api/employees', es el “path” o ruta en la que la aplicación escucha solicitudes.

Y como segundo parámetro, el método app.post, recibe un callback o handler de la ruta, el cual define que sucederá cuando se reciba una solicitud POST.

Dentro de este callback, definiremos la lógica que nos permitirá almacenar los datos en la base de datos, pero primero verificaremos que la solicitud contenga los datos requeridos, por lo que recuperamos los datos del “body” de la request y analizamos el campo requerido:

const body = request.body
if (!body.name) {
  return response.status(400).json({
    error: 'name missing',
  })
}

De esta manera, si el cuerpo de la solicitud no contiene el campo “name”, respondemos con un código de estado 400 y enviamos un mensaje de error.

Una vez corroboramos que el cuerpo contenga los datos, creamos una instancia del schema “Employee” que importamos previamente:

const employee = new Employee({
  name: body.name,
})

Y guardamos en la base de datos con el método save(), el cual responde con una promesa. Usamos el método then() para mostrar los datos guardados, y en caso de error, lo manejaremos con catch():

employee.save()

        .then(savedEmployee => {
            response.json(savedEmployee)
        })
        .catch(error => response.json(error))

Ahora que tenemos definido nuestro primer método, para probarlo debemos configurar nuestro servidor, por lo que primer obtenemos el PORT definido en las variables de entorno y le indicamos a Express que se inicie en modo escucha en ese puerto:

const PORT = process.env.PORT
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`)
})

El archivo completo debiese verse de esta manera:

Figura 13

Figura 13

Para iniciar nuestra aplicación, la ejecutamos con el comando node:

❯ node .\index.js

Tenemos éxito!, ya estamos conectados a mongo, pero ahora nos resta probar nuestro método para agregar employees, para eso utilizaremos una extensión de VSCode, llamada “REST Client”.

REST Client es una extensión de Visual Studio Code que permite enviar y probar solicitudes HTTP directamente desde el editor, lo que resulta muy útil para verificar nuestras rutas y APIs

Creamos un directorio llamado requests, donde almacenaremos las request para probar la API.

Creamos un archivo llamado “addEmployee.rest”, el cual contiene lo siguiente:

POST http://localhost:3001/api/employees
Content-Type: application/json

{
    "name": "testName"
}

Primero indicamos que haremos una solicitud POST e indicamos la ruta que definimos previamente.

Luego especificamos que el contenido que enviaremos es de tipo json.

Y finalmente el cuerpo de nuestra solicitud, la cual contiene el campo y la información que enviaremos al servidor.

Con la extensión REST Client, aparecerá un botón con el mensaje “Send Request” y nos mostrará el resultado de nuestra request:

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 60
ETag: W/"3c-qSeu+Ejm2zqrlaepwez1jeo33ok"
Date: Fri, 28 Mar 2025 01:23:58 GMT
Connection: close

{
  "name": "testName",
  "_id": "67e5fa2ecb027378f0cbe0f4",
  "__v": 0
}

Nos responde con los datos enviados, y además, con el “_id” que genera MongoDB.

Que ocurriría si enviamos la request sin los datos:

POST http://localhost:3001/api/employees
Content-Type: application/json

{
}

El servidor responde con el error que definimos previamente:

HTTP/1.1 400 Bad Request
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 24
ETag: W/"18-Rd21ciojplJ2YI7SChpnkwHGh2I"
Date: Fri, 28 Mar 2025 01:25:16 GMT
Connection: close

{
  "error": "name missing"
}

Podemos corroborar que estos datos llegaron al servidor, en el menú de la barra izquierda de la página cloud.mongodb.com, llamado “Clusters” y luego “Browse Collections”:

Figura 14

Figura 14

Ahora crearemos una ruta para acceder a estos datos, esta vez utilizaremos app.get:

app.get('/api/employees', (request, response) => {
  Employee.find({})
    .then((employee) => {
      response.json(employee)
    })
    .catch((error) => response.json(error))
})

Con el método find({}), le indicamos a mongo que devuelva todos los datos contenidos, con then(), mostramos la información obtenida, y con catch, capturamos cualquier error que pueda suceder en la petición.

Probamos esta nueva ruta con un archivo .rest (debemos reiniciar el servidor para que los cambios tengan efecto):

GET http://localhost:3001/api/employees
Obtenemos lo siguiente:
HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 62
ETag: W/"3e-tZp02z4Zml3TO2o3BXGpCQKBWk4"
Date: Fri, 28 Mar 2025 01:35:14 GMT
Connection: close

[

  {
    "_id": "67e5fa2ecb027378f0cbe0f4",
    "name": "testName",
    "__v": 0
  }
]

Ahora crearemos un método para obtener solo 1 employee, según su ID:

app.get('/api/employees/:id', (request, response, next) => {
  Employee.findById(request.params.id)
    .then((employee) => {
      response.json(employee)
    })
    .catch((error) => response.json(error))
})

Esta vez utilizamos el método de MongoDB findById(), el cual nos permite obtener un resultado según su ID, el cual obtenemos de la ruta con request.params.id que recupera el valor ingresado en :id, mostramos la información como json y capturamos los errores.

Para probar nuestro método, debemos agregar otro valor a nuestra base de datos con el método anterior (recuerden reiniciar el servidor después de cada cambio):

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 186
ETag: W/"ba-3kgbSiUobkLdUIKBDH2S4aOcAHg"
Date: Fri, 28 Mar 2025 01:42:28 GMT
Connection: close

[

  {
    "_id": "67e5fa2ecb027378f0cbe0f4",
    "name": "testName",
    "__v": 0
  },
  {
    "_id": "67e5fe175f52b277e6a2a3ef",
    "name": "testName2",
    "__v": 0
  },
  {
    "_id": "67e5fe7de5fcc2685c539ed8",
    "name": "testName3",
    "__v": 0
  }
]

Ahora que tenemos más de un valor, probamos nuestro método:

GET http://localhost:3001/api/employees/67e5fa2ecb027378f0cbe0f4
Obtenemos la información del employee id 67e5fa2ecb027378f0cbe0f4:
HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 60
ETag: W/"3c-o2knJLZpaFYp1p9OPVY0w/g1Q3k"
Date: Fri, 28 Mar 2025 01:42:56 GMT
Connection: close

{
  "_id": "67e5fa2ecb027378f0cbe0f4",
  "name": "testName",
  "__v": 0
}

Continuamos con la actualización de un employee:

app.put('/api/employees/:id', (request, response, next) => {
  const body = request.body
  const employee = {
    name: body.name,
  }
  Employee.findByIdAndUpdate(request.params.id, employee)
    .then((updatedEmployee) => {
      response.json(updatedEmployee)
    })
    .catch((error) => next(error))
})

A diferencia de los métodos anteriores, esta vez utilizamos el método PUT para actualizar los valores.

Obtenemos los valores del body con const body = request.body, almacenamos el contenido en la variable employee y utilizamos el método findByIdAndUpdate(), el cual recibe la id del employee, desde los parámetros de la request, con request.params.id y los nuevos datos. Mostramos los nuevos valores y capturamos los errores con catch.

Probamos nuestro método con un archivo .rest:

PUT http://localhost:3001/api/employees/67e5fa2ecb027378f0cbe0f4
Content-Type: application/json

{
    "name": "nameUpdated"
}

Recibimos el employee actualizado:

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 64
ETag: W/"40-WsQw6RUzE0I5m05vPqT4oTotOqk"
Date: Fri, 28 Mar 2025 01:51:40 GMT
Connection: close

{
  "_id": "67e5fa2ecb027378f0cbe0f4",
  "name": "nameUpdated",
  "__v": 0
}

Ahora solo nos resta la eliminación de employees:

app.delete('/api/employees/:id', (request, response) => {
  Employee.findByIdAndDelete(request.params.id)
    .then(() => {
      response.status(204).end()
    })
    .catch((error) => response.json(error))
})

Utilizamos el método findByIdAndDelete(), el cual recibe el ID del employee que queremos eliminar, el cual obtenemos de la request con request.params.id, respondemos con un código 204, seguido del método end() que indica el fin del proceso.

No existe convención con respecto al código de respuesta en caso de eliminación, pero optamos por el 204, ya que su definición dice que se utiliza cuando el servidor procesa con éxito una solicitud, pero no tiene contenido que devolver.

Probamos el método con un archivo .rest:

DELETE http://localhost:3001/api/employees/67e5fa2ecb027378f0cbe0f4

Obtenemos lo siguiente:

HTTP/1.1 204 No Content
X-Powered-By: Express
Date: Fri, 28 Mar 2025 01:59:31 GMT
Connection: close

Comprobamos que se haya eliminado con la request para obtener todos los employees:

GET http://localhost:3001/api/employees
HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: application/json; charset=utf-8
Content-Length: 125
ETag: W/"7d-0j7gMontN18rhR9fF5UXE5RLiec"
Date: Fri, 28 Mar 2025 02:00:17 GMT
Connection: close

[

  {
    "_id": "67e5fe175f52b277e6a2a3ef",
    "name": "testName2",
    "__v": 0
  },
  {
    "_id": "67e5fe7de5fcc2685c539ed8",
    "name": "testName3",
    "__v": 0
  }
]

Vemos que el employee fue eliminado con éxito.

El código completo debiese verse de la siguiente manera:

Figura 15

Figura 15

De todas maneras, el código completo esta disponible en este repositorio:

https://github.com/wh01s17/mongo-connection

¡Y eso es todo por esta vez! En este tutorial, creamos un CRUD simple utilizando Node.js, Express y MongoDB. Este proyecto básico es un excelente punto de partida que puedes personalizar y expandir según las necesidades de tu aplicación. Ya sea añadiendo más funcionalidades, mejorando las validaciones o integrando nuevas herramientas, tienes una base sólida para seguir construyendo.

Gracias por leer, ¡nos vemos en la próxima entrega!