Crea tu API REST con Node.js y MongoDB ¡Fácil!

3 minuto(s)

En esta página:

En este tutorial aprenderás paso a paso cómo construir una API RESTful desde cero utilizando Node.js, Express y MongoDB. Esta guía está pensada para ayudarte a entender cada parte del proceso y lograr una implementación funcional, escalable y profesional.

Requisitos previos

Node.js y npm instalados
MongoDB (local o Atlas)
Editor de código (Visual Studio Code, por ejemplo)
Postman o curl para probar la API

Paso 1: Crear el proyecto Node.js


mkdir api-productos 
cd api-productos 
npm init -y 
npm install express mongoose

mkdir api-productos

cd api-productos

npm init -y

npm install express mongoose

Esto creará un nuevo proyecto con package.json y las dependencias necesarias.

Paso 2: Estructura de carpetas

Organiza tu proyecto así:


api-productos/
│
├── models/
│   └── Producto.js
├── routes/
│   └── productos.js
├── db.js
├── app.js
└── package.json

api-productos/

│

├── models/

│ └── Producto.js

├── routes/

│ └── productos.js

├── db.js

├── app.js

└── package.json

Paso 3: Conectar a MongoDB

Crea el archivo db.js para manejar la conexión:


const mongoose = require('mongoose');

const conectarDB = async () =&gt; {
  try {
    await mongoose.connect('mongodb://localhost:27017/productosdb', {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });
    console.log('Conectado a MongoDB');
  } catch (error) {
    console.error('Error al conectar a MongoDB', error);
    process.exit(1);
  }
};

module.exports = conectarDB;

const mongoose = require('mongoose');

const conectarDB = async () => {

try {

await mongoose.connect('mongodb://localhost:27017/productosdb', {

useNewUrlParser: true,

useUnifiedTopology: true

});

console.log('Conectado a MongoDB');

} catch (error) {

console.error('Error al conectar a MongoDB', error);

process.exit(1);

}

};

module.exports = conectarDB;

En models/Producto.js define el esquema de producto:


const mongoose = require('mongoose');

const ProductoSchema = new mongoose.Schema({
  nombre: {
    type: String,
    required: true,
    trim: true
  },
  precio: {
    type: Number,
    required: true
  }
});

module.exports = mongoose.model('Producto', ProductoSchema);

const mongoose = require('mongoose');

const ProductoSchema = new mongoose.Schema({

nombre: {

type: String,

required: true,

trim: true

precio: {

type: Number,

required: true

}

});

module.exports = mongoose.model('Producto', ProductoSchema);

Paso 5: Crear el servidor Express

En el archivo principal app.js:


const express = require('express');
const conectarDB = require('./db');
const productosRoutes = require('./routes/productos');

const app = express();

// Conexión a la base de datos
conectarDB();

// Middleware para parsear JSON
app.use(express.json());

// Rutas
app.use('/api/productos', productosRoutes);

const PORT = 3000;
app.listen(PORT, () =&gt; {
  console.log(`Servidor corriendo en http://localhost:${PORT}`);
});

const express = require('express');

const conectarDB = require('./db');

const productosRoutes = require('./routes/productos');

const app = express();

// Conexión a la base de datos

conectarDB();

// Middleware para parsear JSON

app.use(express.json());

// Rutas

app.use('/api/productos', productosRoutes);

const PORT = 3000;

app.listen(PORT, () => {

console.log(`Servidor corriendo en http://localhost:${PORT}`);

});

Paso 6: Crear las rutas (endpoints)

En routes/productos.js agrega lo siguiente:


const express = require('express');
const router = express.Router();
const Producto = require('../models/Producto');

// Obtener todos los productos
router.get('/', async (req, res) =&gt; {
  try {
    const productos = await Producto.find();
    res.json(productos);
  } catch (error) {
    res.status(500).json({ mensaje: 'Error al obtener productos' });
  }
});

// Crear un nuevo producto
router.post('/', async (req, res) =&gt; {
  try {
    const { nombre, precio } = req.body;
    const nuevoProducto = new Producto({ nombre, precio });
    await nuevoProducto.save();
    res.status(201).json(nuevoProducto);
  } catch (error) {
    res.status(400).json({ mensaje: 'Error al crear el producto' });
  }
});

// Actualizar producto
router.put('/:id', async (req, res) =&gt; {
  try {
    const producto = await Producto.findByIdAndUpdate(req.params.id, req.body, { new: true });
    res.json(producto);
  } catch (error) {
    res.status(400).json({ mensaje: 'Error al actualizar' });
  }
});

// Eliminar producto
router.delete('/:id', async (req, res) =&gt; {
  try {
    await Producto.findByIdAndDelete(req.params.id);
    res.json({ mensaje: 'Producto eliminado' });
  } catch (error) {
    res.status(400).json({ mensaje: 'Error al eliminar' });
  }
});

module.exports = router;

const express = require('express');

const router = express.Router();

const Producto = require('../models/Producto');

// Obtener todos los productos

router.get('/', async (req, res) => {

try {

const productos = await Producto.find();

res.json(productos);

} catch (error) {

res.status(500).json({ mensaje: 'Error al obtener productos' });

}

});

// Crear un nuevo producto

router.post('/', async (req, res) => {

try {

const { nombre, precio } = req.body;

const nuevoProducto = new Producto({ nombre, precio });

await nuevoProducto.save();

res.status(201).json(nuevoProducto);

} catch (error) {

res.status(400).json({ mensaje: 'Error al crear el producto' });

}

});

// Actualizar producto

router.put('/:id', async (req, res) => {

try {

const producto = await Producto.findByIdAndUpdate(req.params.id, req.body, { new: true });

res.json(producto);

} catch (error) {

res.status(400).json({ mensaje: 'Error al actualizar' });

}

});

// Eliminar producto

router.delete('/:id', async (req, res) => {

try {

await Producto.findByIdAndDelete(req.params.id);

res.json({ mensaje: 'Producto eliminado' });

} catch (error) {

res.status(400).json({ mensaje: 'Error al eliminar' });

}

});

module.exports = router;

Paso 7: Probar la API con Postman

Una vez que tienes tu API REST creada con Node.js, Express y MongoDB, el siguiente paso es realizar pruebas de las operaciones CRUD para asegurarte de que funciona correctamente.

Estas operaciones son fundamentales en cualquier API:

Crear un nuevo producto (POST)
Leer uno o varios productos (GET)
Actualizar un producto existente (PUT)
Eliminar un producto (DELETE)

1. Crear un Producto (POST)

Método: POST
URL: http://localhost:3000/api/productos

Encabezados (Headers):

Content-Type: application/json

Body → raw → JSON:


{
  "nombre": "Laptop Lenovo",
  "precio": 699.99
}

{

"nombre": "Laptop Lenovo",

"precio": 699.99

}

Resultado esperado: Un objeto con el producto creado y su _id generado por MongoDB.

Probando la API Rest con Postman — En la pestaña Headers que está al lado izquierdo de Body coloca Content-Type: application/json

2. Listar Todos los Productos (GET)

Método: GET
URL: http://localhost:3000/api/productos

No necesitas cuerpo (body) ni headers especiales.

Resultado esperado: Un arreglo de productos como este:


[
  {
    "_id": "6638e52c1b2a789b5e8ef344",
    "nombre": "Laptop Lenovo",
    "precio": 699.99,
    "__v": 0
  },
  ...
]

[

{

"_id": "6638e52c1b2a789b5e8ef344",

"nombre": "Laptop Lenovo",

"precio": 699.99,

"__v": 0

...

]

3. Obtener un Solo Producto por ID (GET)

Método: GET
URL: http://localhost:3000/api/productos/ID_DEL_PRODUCTO

Reemplaza ID_DEL_PRODUCTO con el _id que obtuviste al crear un producto.

Resultado esperado: Un solo objeto con los datos del producto.

4. Actualizar un Producto (PUT)

Método: PUT
URL: http://localhost:3000/api/productos/ID_DEL_PRODUCTO

Encabezados (Headers):

Content-Type: application/json

Body → raw → JSON:


{
  "nombre": "Laptop Lenovo Pro",
  "precio": 749.99
}

{

"nombre": "Laptop Lenovo Pro",

"precio": 749.99

}

Resultado esperado: El producto actualizado con los nuevos datos.

5. Eliminar un Producto (DELETE)

Método: DELETE
URL: http://localhost:3000/api/productos/ID_DEL_PRODUCTO

No necesitas enviar body ni headers.

Resultado esperado: Un mensaje de confirmación como Producto eliminado.

Notas importantes

Todos los IDs que uses en las URLs deben ser válidos de MongoDB (por ejemplo, 6638e52c1b2a789b5e8ef344).
Revisa MongoDB Compass para verificar visualmente los datos creados, actualizados o eliminados.
Si usas herramientas como Thunder Client en VS Code, los pasos son similares.

Este flujo te permitirá probar completamente el funcionamiento de tu API REST y verificar que cada operación (crear, leer, actualizar, eliminar) funciona correctamente desde Postman.

Conclusión

Ahora tienes una API REST totalmente funcional usando Node.js, Express y MongoDB. Este tipo de estructura es ideal para backend de apps móviles, sitios web, sistemas administrativos, entre otros. Lo mejor es que puedes extenderla fácilmente para manejar usuarios, autenticación JWT, relaciones entre modelos y mucho más.