Guía para el manejo de excepciones en Express

Introducción

Es probable que ocurran excepciones y errores mientras los usuarios interactúan con cualquier aplicación, depende de los ingenieros de software elegir un medio para manejar cualquier error que pueda surgir, a sabiendas o sin saberlo. Como resultado, los desarrolladores de back-end que crean API con Express se encuentran trabajando para asegurarse de que están creando una API útil, eficiente y utilizable. Lo más importante es manejar los errores de tal manera que se construya un sistema robusto porque esto ayuda a reducir el tiempo de desarrollo, los errores absolutos, los problemas de productividad y determina el éxito o la escalabilidad del desarrollo de software.

¿Necesita registrar el mensaje de error, suprimir el error, notificar a los usuarios sobre el error o escribir código para manejar los errores? Extrañar más.

En esta guía, aprenderemos a crear una base de código robusta de manejo de errores para aplicaciones Express, que servirá para ayudar a detectar errores de aplicaciones y tomar las medidas óptimas para recuperar cualquier aplicación que falle sin problemas durante el tiempo de ejecución.

¿Qué es el manejo de errores?

En el desarrollo de software, hay dos tipos diferentes de excepciones: operativos. y programático.

• Pueden surgir fallas operativas durante el tiempo de ejecución, y para evitar que la aplicación finalice abruptamente, debemos manejar estas excepciones con elegancia a través de métodos eficientes de manejo de errores.
• Las excepciones programáticas son lanzadas manualmente por un programador, cuando surge un estado excepcional.

Puede pensar en las excepciones operativas como excepciones "inesperadas, pero previstas" (como acceder a un índice fuera de los límites), y las excepciones programáticas como excepciones "esperadas y previstas" (como una excepción de formato de número).

El manejo de excepciones es el procedimiento utilizado para encontrar y corregir fallas dentro de un programa. El manejo de errores envía mensajes que incluyen el tipo de error que ocurrió y la pila donde ocurrió el error.

En Express, el manejo de excepciones se refiere a cómo Express se configura para capturar y procesar excepciones síncronas y asíncronas. Lo bueno del manejo de excepciones en Express es que, como desarrollador, no necesita escribir sus propios manejadores de excepciones; Express viene con un controlador de excepciones predeterminado. El controlador de excepciones ayuda a identificar errores e informarlos al usuario. También proporciona varias estrategias correctivas y las implementa para mitigar las excepciones.

Si bien esto puede parecer un montón de cosas ocultas, el manejo de excepciones en Express no ralentiza el proceso general de un programa ni detiene su ejecución.

Comprender el manejo de excepciones en Express

Con el controlador de errores predeterminado que viene con Express, tenemos en nuestras manos un conjunto de funciones de middleware que ayudan a detectar errores en los controladores de ruta automáticamente. Pronto, crearemos un proyecto para poner en práctica la teoría sobre cómo devolver errores correctos en una aplicación Express y cómo no filtrar información confidencial.

Definición de la función de middleware en Express

Las funciones de middleware de manejo de errores se definen de tal manera que aceptan un Error object como el primer parámetro de entrada, seguido de los parámetros predeterminados de cualquier otra función de middleware: request, responsey next. next() La función salta todo el middleware actual al siguiente controlador de errores para el enrutador.

Configurar el manejo de errores en Express

Ejecute el siguiente comando en su terminal para crear una aplicación Node and Express:

$ mkdir error-handling-express

En la carpeta recién creada, inicialicemos un nuevo proyecto de Nodo:

$ cd error-handling-express && npm init -y

Esto crea un package.json archivo en nuestra carpeta.

Para crear un servidor Express en nuestra aplicación Node, tenemos que instalar el express paquete, dotenv para cargar automáticamente las variables de entorno en .env Archivo en process.env objeto, y nodemon para reiniciar la aplicación de nodo si se observa un cambio de archivo en el directorio.

$ npm install express dotenv nodemon

A continuación, cree un app.js archivo en la carpeta del proyecto que servirá como archivo de índice para la aplicación.

Ahora que hemos instalado todas las dependencias necesarias para nuestra aplicación Express, debemos configurar el script para leer la aplicación en el package.json expediente. Para lograr eso, el package.json archivo, para que el scripts objeto es como se muestra a continuación:

"scripts": {
    "start": "nodemon app.js"
},

Alternativamente, puede omitir el uso de nodemon, y use node app.js preferiblemente.

Configuración de un servidor Express

Para configurar el servidor, primero tenemos que importar los distintos paquetes a app.js. También crearemos un .env archivo en el directorio del proyecto – para almacenar todas las variables de entorno para la aplicación:

const express = require('express')
require('dotenv').config

PORT=4000 

Hemos definido el número de puerto para la aplicación en .env, que es cargado y leído por dotenv, y se puede acceder más tarde.

Inicialización del servidor Express

Ahora, necesitamos inicializar el servidor Express y hacer que nuestra aplicación escuche el número de puerto de la aplicación, junto con una solicitud a una ruta de prueba: /test. actualicemos app.js, debajo de las declaraciones de importación:

const app = express();
const port = process.env.PORT || 4000;

app.get("/test", async (req, res) => {
    return res.status(200).json({ success: true });
});

app.listen(port, () => {
    console.log(`Server is running at port ${port}`);
});

De aquí en adelante, aprenderemos cómo manejar varios casos de uso de errores operativos que se pueden encontrar en Express.

Manejo de errores no encontrados en Express

Suponga que necesita obtener todos los usuarios de una base de datos de usuarios, puede manejar de manera eficiente un escenario de error potencial donde no existen datos en la base de datos, envolviendo la lógica en un try/catch block – con la esperanza de detectar cualquier error que pudiera proyectarse en el catch bloque:

const getUser = () => undefined;

app.get("/get-user", async (req, res) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error('User not found');
		}
	} catch (error) {
	    
		console.log(error); 
		
		res.status(400).send(error.message) 
	}
	return res.status(200).json({
		success: true
	});
});

Esto resulta en:

User not found

Ahora, cuando se realiza esta solicitud (puede probar usando Postman) y no existe ningún usuario en la base de datos, el cliente recibe un mensaje de error que dice "Usuario no encontrado". Además, notará que el error también se registra en la consola.

Optimización del manejo de errores con el middleware del manejador de errores

Podemos optimizar el desarrollo mediante la creación de un middleware de manejo de errores que vendría al final de todas las rutas definidas, de modo que si se produce un error en una de las rutas, Express automáticamente echará un vistazo al siguiente middleware y seguirá bajando en la lista. hasta que llega al controlador de errores. El controlador de errores procesará el error y también enviará una respuesta al cliente.

Para comenzar, cree una carpeta llamada middleware en el directorio del proyecto, y en esta carpeta, cree un archivo llamado errorHandler.js que define el controlador de errores:

const errorHandler = (error, req, res, next) => {
    
    console.log(error); 
    
    res.status(400).send(error.message); 
}
module.exports = errorHandler;

En nuestra función de middleware, le hemos hecho saber a Express que no se trata de una función de middleware básica, sino de un controlador de errores, agregando el error parámetro antes de los 3 parámetros básicos.

Ahora, usaremos el controlador de errores en nuestra demostración. app.js y maneje el error inicial de obtener usuarios con el middleware del controlador de errores, como se muestra a continuación:

const getUser = () => undefined;

app.get("/get-user", async (req, res, next) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
	} catch (error) {
		return next(error);
	}
});

app.use(errorHandler);

Podemos optimizar nuestro código aún más, creando una abstracción alrededor del try/catch lógica. Podemos lograr esto creando una nueva carpeta en el directorio del proyecto llamada utils, y en él, crea un archivo llamado tryCatch.js.

Para abstraer la try-catch lógica: podemos definir una función que acepta otra función (conocida como la controlador) como su parámetro, y devuelve un async función que mantendrá un try/catch para cualquier controlador recibido.

Si se produce un error en el controlador, se detecta en el catch bloque y la siguiente función se llama:

const tryCatch = (controller) => async (req, res, next) => {
	try {
		await controller(req, res);
	} catch (error) {
		return next(error);
	}
};
module.exports = tryCatch;

Con la try/catch abstracción, podemos refactorizar nuestro código para hacerlo más sucinto omitiendo el try-catch cláusula explícitamente al buscar usuarios en el app.js:

const getUser = () => undefined;

app.get(
	"/get-user",
	tryCatch(async (req, res) => {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
		res.status(400).send(error.message);
	})
);

Hemos abstraído con éxito la lógica de intento y captura y nuestro código aún funciona como lo hacía antes.

Manejo de errores de validación en Express

Para esta demostración, crearemos una nueva ruta en nuestra aplicación Express para iniciar sesión, para validar una identificación de usuario al iniciar sesión. Primero, instalaremos el joi paquete, para ayudar con la creación de un esquema, con el que podemos hacer cumplir los requisitos:

$ npm i joi

A continuación, cree un esquema que sea un Joi.object con un userId que debe ser un número y es obligatorio, lo que significa que la solicitud debe coincidir con un objeto que tenga un ID de usuario.

Podemos usar el validate() método en el objeto de esquema para validar cada entrada contra el esquema:

const schema = Joi.object({
	userId: Joi.number().required(),
});

app.post(
	"/login",
	tryCatch(async (req, res) => {
		const {error, value} = schema.validate({});
		if (error) throw error;
	})
);

Si se pasa un objeto vacío al validate() método, el error se manejaría correctamente y el mensaje de error se enviaría al cliente:

En la consola, también tenemos acceso a un details matriz que incluye varios detalles sobre el error que podría comunicarse al usuario si es necesario.

Para manejar específicamente los errores de validación de tal manera que pase el detalle de error apropiado por error de validación, el middleware del controlador de errores se puede refactorizar:

const errorHandler = (error, req, res, next) => {
	console.log(error); 

	if (error.name === "ValidationError") {
		return res.status(400).send({
			type: "ValidationError",
			details: error.details,
		});
	}

	res.status(400).send(error.message); 
};

module.exports = errorHandler;

Con errorHandler.js ahora personalizado, cuando hacemos la misma solicitud con un objeto vacío pasado al validate() método:

Ahora tenemos acceso a un objeto personalizado que devuelve mensajes de una manera más legible/amigable. De esta manera, podemos enviar y manejar diferentes tipos de errores según el tipo de error que se presente.

Conclusión

En esta guía, revisamos todos los aspectos del manejo de errores de Express.js, incluido cómo se maneja el código síncrono y asíncrono de manera predeterminada, cómo crear sus propias clases de error, cómo escribir funciones personalizadas de middleware de manejo de errores y proporcionar next como el controlador de captura final

Al igual que con todas las tareas, también existen mejores prácticas durante el desarrollo que incluyen el manejo efectivo de errores, y hoy hemos aprendido cómo podemos manejar los errores en una aplicación Express de manera sólida.

Manejar correctamente los errores no solo significa reducir el tiempo de desarrollo mediante la búsqueda de fallas y errores fácilmente, sino también desarrollar una base de código robusta para aplicaciones a gran escala. En esta guía, hemos visto cómo configurar middleware para manejar errores operativos. Algunas otras formas de mejorar el manejo de errores incluyen: no enviar seguimientos de pila, detener procesos correctamente para manejar excepciones no detectadas, proporcionar mensajes de error apropiados, enviar registros de errores y configurar una clase que amplíe el Error clase.

Espero que los ejemplos que usé en este tutorial te hayan gustado. Cubrí varios escenarios que podría encontrar al escribir una aplicación Express para usar en el mundo real sobre la gestión de errores. Por favor, avíseme si hay algo que me perdí. Nos beneficiará y me ayudará a aprender más también. Que tengas un buen día y gracias por leer.

Puede consultar todo el código fuente utilizado en el artículo sobre Github.

Recursos adicionales