Crear servidor con NodeJS y Express
Bien sabemos que al momento de programar una aplicación en NodeJS a veces suele ser bastante tedioso ya que tenemos que construirlo todo nosotros mismos. Para ahorrarnos ese tiempo existe ExpressJS. ExpressJS es un framework con una infraestructura web rápida, minimalista y flexible para NodeJS que nos proporciona increibles características como middlewares, entre otras cosas.
Empecemos con la creación de un servidor para una API con sus rutas y controladores.
1. Creación del proyecto 👏
Para realizar la creación del proyecto es necesario tener NodeJS instalado en nuestra computadora. Si no lo tienes y/o no sabes como hacerlo, tengo un artículo "guía" para instalarlo:
Primero que nada crearemos el proyecto (estaré utilizando VSCode como editor de código). En este ejemplo crearé una carpeta llamada 📁 API_EXPRESS. Dentro de dicha carpeta crearemos un archivo el cual va a ser el punto inicial de la aplicación llamado 📄 server.js.

Luego abrimos la linea de comandos, powershell de windows o lo que utilicen para ver la consola y nos posicionamos en el directorio creado (en VSCode el atajo para la terminal sería CTRL + SHIFT + ñ).

Al estar posicionado en el directorio crearemos el 📄 package.json. La manera más fácil y rápida de hacerlo es escribiendo en la consola lo siguiente y luego presionamos ENTER:
npm init -yCon éste comando se creará rápidamente un archivo de configuración de los paquetes de Node.


Como último paso de este punto instalaremos Express. Nuevamente en la terminal escribimos los siguiente
npm install express --savey presionamos ENTER.


Con esto ya tendremos instalado Express en nuestra aplicación y veremos que se creara un carpeta llamada 📁 node_modules en el directorio raíz. Si miramos nuevamente el archivo 📄 package.json veremos que se agregó Express como dependencia.

2. Configurar el servidor 📌
Una vez realizado el paso anterior, ahora nos toca hacer la configuración del servidor. Para ello, en el archivo 📄 server.js importaremos express, lo asignaremos a una constante llamada app, colocaremos en otra constante llamada PORT el valor del puerto a escuchar y lo iniciaremos:
// (📄 _server.js_)
const express = require('express');
const app = express();
const PORT = process.env.PORT || 5000;
app.listen(PORT, () =>
console.log(`Servidor corriendo en el puerto: ${PORT} `)
);También agregaremos la siguiente linea de código luego de la constante app para 'parsear la aplicacion' a formato JSON (ésto es propio de Express):
// (📄 _server.js_)
app.use(express.json());
A continuación iremos nuevamenta a la consola y ejecutaremos el comando npm start para iniciar el servidor. De esta manera ya tendremos configurado nuestro servidor en Node con Express.
Para iniciar la aplicación ejecutamos
npm start.
Para detener la aplicación simplemente presionamos las teclas CTRL + C (control + C).


Ya solo nos falta, como siguientes pasos, configurar las rutas y los controladores.
3. Configuración de rutas 🚏
Para las rutas crearemos una carpeta en el directorio raíz de la aplicación llamada 📁 routes, dentro de esa carpeta crearemos un archivo llamado 📄 routes.js.

Como paso siguiente en ese archivo importaremos express tal y como lo hicimos en el archivo server.js para poder usar el método Router():
// (📄 _routes.js_)
const express = require('express');
const router = express.Router();Ahora que ya tenemos todo eso estamos listos para crear nuestra ruta la cual recibe una función con la petición y la respuesta. En este caso retornaremos un JSON como respuesta:
// (📄 _routes.js_)
// Método GET
router.get('/', (req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: GET' },
});
});Lo que hicimos es que cuando se reciba una petición con el método GET nuestra aplicación ejecute la función asignada. En Express, si queremos realizar un GET, POST, PUT, DELETE, etc, solo tenemos que especificar el método de la siguiente manera:
// (📄 _routes.js_)
// Método POST
router.post('/', (req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: POST' },
});
});
// Método PUT
router.put('/:param', (req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: PUT' },
});
});
// Método DELETE
router.delete('/:param', (req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: DELETE' },
});
});De esa manera estaríamos especificando los métodos y devolviendo la respuesta con un status 200 (success). En el caso del PUT y el DELETE, después del '/' (slash) agregamos un parámetro, eso veremos más adelante en los controladores. Por último lo que tenemos que hacer es exportar las rutas creadas para poder importarlas en el server.js:
// (📄 _routes.js_)
module.exports = router;El archivo 📄 routes.js quedaría de la siguiente manera:

Ahora volvamos al archivo 📄 server.js e importemos la ruta creada:
// (📄 _server.js_)
const routes = require('./routes/routes.js');Justos después de la constante app usaremos nuestra ruta la cual recibe como parámetros la dirección a donde apunta y nuestra ruta:
// (📄 _server.js_)
app.use('/api', routes);
Si ejecutamos nuestra aplicación desde la consola con el comando npm start, nos vamos al 🌎 navegador (o si usamos Postman) y accedemos a http://localhost:5000/api obtendremos la respuesta:


(📌 Postman - Petición Método GET)

(📌 Postman - Petición Método PUT con parámetro)

En el caso de que queramos manejar las rutas y métodos de usuarios, haríamos el mismo procedimiento, por ejemplo si queremos manejar las rutas y métodos de la Autenticación de la aplicacción, creamos en la carpeta 📁 routes el archivo 📄 auth.js y allí definimos las rutas y sus métodos. Los nombres no necesariamente tienen que ser esos, podemos poner el nombre que queramos.
Con esto ya tenemos nuestra primera ruta configurada, pero, ¿que pasaría si en nuestra función tenemos mucha lógica?, nuestro archivo de rutas sería muy extenso y tedioso a la hora de buscar lineas de código. Para eso vamos a crear los controladores los cuales van a tener todas las funciones, así, nuestro archivo 📄 routes.js quedará más limpio y fácil de entender a medida que nuestra aplicación crece.
4. Creación de los controladores 🚦
Para la implementación de los controladores crearemos en la raíz de la aplicación una carpeta llamada 📁 controllers y dentro (siguiendo el ejemplo) crearemos un archivo llamado 📄 controllers.js.
Haciendo un paréntesis, los nombres pueden ser los que queramos, si por ejemplo queremos manejar los usuarios, podríamos definir usuarios.js ó users.js, etc. Otra opción para que nos quede más claro que hace cada archivo es colocar, después del nombre, su especificación para que nos sea más fácil entender o interpretar. Ejemplo, volvemos a los usuarios, en vez de colocar el nombre users.js colocamos users.controllers.js para tener un mayor panorama de a que carpeta pertenece el archivo y su especificación. Lo mismo se aplica a las rutas, en la carpeta 📁 routes en vez de poner el archivo con el nombre de users.js podríamos poner users.routes.js, de esta manera nos quedaría más claro a que hace referencia el archivo, esto es cuestión de gustos, comodidad y organización.

Luego de eso simplemente en el archivo 📄 controllers.js de la carpeta 📁 controllers crearemos las mismas funciones que implementamos en las rutas en el punto anterior, le asignamos un nombre y las exportamos:
// (📄 controllers.js_)
// Método GET
exports.getControllers =
('/',
(req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: GET' },
});
});
// Método POST
exports.postControllers =
('/',
(req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: POST' },
});
});
// Método PUT
exports.putControllers =
('/:param',
(req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: PUT' },
});
});
// Método DELETE
exports.deleteControllers =
('/:param',
(req, res) => {
res.status(200).json({
success: true,
data: { example: 'Method: DELETE' },
});
});El archivo quedaría de ésta manera:

Una vez hecho ésto volvamos al archivo 📄 routes.js de la carpeta 📁 routes para modificarlo un poco. Lo que haremos será importar los métodos de los controladores:
// (📄 routes.js_)
const {
getControllers,
postControllers,
putControllers,
deleteControllers,
} = require('../controllers/controllers');Luego reemplazamos el segundo parámetro de la función con su respectivo método importado:
router.get('/', getControllers);
router.post('/', postControllers);
router.put('/:param', putControllers);
router.delete('/:param', deleteControllers);El archivo 📄 routes.js de la carpeta 📁 routes quedaría de la siguiente manera:

Con esto, si ejecutamos nuestra aplicación desde la consola con el comando npm start y accedemos nuevamente a http://localhost:5000/api eligiendo la petición (GET, POST, PUT, DELETE) obtendremos el mismo resultado, nada más que nuestra aplicación quedaría más ordenada y limpia.
Anteriormente colocamos en los métodos put y delete un parámetro /:param. En Express para acceder a ése parámetro simplemente lo llamamos desde la petición req.params.param, ya que éste (req.params) almacena los parámetros. El nombre que definamos como parámetro en la ruta es el nombre con el que debemos de acceder, por ejemplo podríamos colocar /:id, con eso accederiamos con el nombre req.params.id.
Vamos con un ejemplo práctico. En el archivo 📄 controllers.js de la carpeta 📁 controllers, en el método put y delete retornemos como respuesta el valor del parámetro ingresado almacenandolo en una constante:
// (📄 controllers.js_)
// Método PUT
exports.putControllers =
('/:param',
(req, res) => {
// Almacenamos el valor del parámetro en la constante
const param = req.params.param;
res.status(200).json({
success: true,
data: { param }, // Retornamos la respuesta con el valor del parámetro
});
});
// Método DELETE
exports.deleteControllers =
('/:param',
(req, res) => {
// Almacenamos el valor del parámetro en la constante
const param = req.params.param;
res.status(200).json({
success: true,
data: { param }, // Retornamos la respuesta con el valor del parámetro
});
});El archivo 📄 controllers.js quedaría de ésta manera:

Si ejecutamos nuevamente la aplicación en Postman y hacemos una peticion PUT o DELETE agregando un parámetro como por ejemplo http://localhost:5000/api/123456 obtendremos la respuesta 123456.

De ésta manera podremos acceder al parámetro para, por ejemplo, modificar o elminiar un usuario, un producto, etc. desde nuestra base de datos.
Conclusión 👨🏫
En resumen lo que hicimos como primer paso fue crear el proyecto, crear el archivo inicial de la aplicación 📄 server.js, crear el manejador de paquetes de Node desde la consola con npm init -y e instalar Express como dependencia de nuestra aplicación. Luego, en el segundo paso configuramos el servidor y le asignamos un puerto. En el tercer paso creamos la carpeta de rutas, dentro, su archivo 📄 routes.js e implementamos las rutas. Como cuarto paso creamos la carpeta de los controladores, dentro, su archivo 📄 controllers.js y definimos la función y su respuesta de retorno.
Como se puede observar, con Express es mucho más fácil crear una aplicación ya que es más sencillo y no tenemos que implementar tantas cosas nosotros mismos. ExpressJS nos brinda mucho con pocas lineas de código.
Código del proyecto 🔻
Dejo el enlace del repositorio en github para que puedan descargar el proyecto finalizado. Esto les puede servir como guía o como plantilla inicial para crear una aplicación en Node con Express. Deben descargarlo, abrir una terminal, posicionarse en el directorio raíz del proyecto, ejecutar npm install para instalar los paquetes de Node y para iniciarlo simplemente en la consola ejecutan el comando npm start.
Repositorio
Espero éste artículo les sea de mucha utilidad. Nos vemos!! 👋