Tengo un middleware async en express, porque quiero usar await dentro de él para limpiar mi código.
const express = require('express'); const app = express(); app.use(async(req, res, next) => { await authenticate(req); next(); }); app.get('/route', async(req, res) => { const result = await request('http://example.com'); res.end(result); }); app.use((err, req, res, next) => { console.error(err); res .status(500) .end('error'); }) app.listen(8080); El problema es que cuando se rechaza, no va a mi middleware de error, pero si elimino la palabra clave async y throw un middleware, sí lo hace.
app.get('/route', (req, res, next) => { throw new Error('Error'); res.end(result); }); Así que recibo UnhandledPromiseRejectionWarning en lugar de ingresar mi middleware de manejo de errores, ¿cómo puedo dejar que el error surja y manejarlo rápidamente?
El problema es que cuando se rechaza, no va a mi middleware de error, pero si elimino la palabra clave asíncrona y lanzo un middleware, sí lo hace.
express no admite promesas actualmente, el soporte puede venir en la versión futura de express@5.xx
Entonces, cuando pasa una función de middleware, express la llamará dentro de un bloque try/catch .
Layer.prototype.handle_request = function handle(req, res, next) { var fn = this.handle; if (fn.length > 3) { // not a standard request handler return next(); } try { fn(req, res, next); } catch (err) { next(err); } }; El problema es que try/catch no detectará un rechazo de Promise fuera de una función async y dado que express no agrega un controlador .catch a la Promise devuelta por su middleware, obtiene un UnhandledPromiseRejectionWarning .
La manera fácil es agregar try/catch dentro de su middleware y llamar a next(err) .
app.get('/route', async(req, res, next) => { try { const result = await request('http://example.com'); res.end(result); } catch(err) { next(err); } }); Pero si tiene muchos middlewares async , puede ser un poco repetitivo.
Dado que me gusta que mis middlewares estén lo más limpios posible, y por lo general dejo que los errores surjan, utilizo un envoltorio alrededor de los middlewares async , que llamará a next(err) si se rechaza la promesa, alcanzando el controlador de errores express y evitando UnhandledPromiseRejectionWarning
const asyncHandler = fn => (req, res, next) => { return Promise .resolve(fn(req, res, next)) .catch(next); }; module.exports = asyncHandler;Ahora puedes llamarlo así:
app.use(asyncHandler(async(req, res, next) => { await authenticate(req); next(); })); app.get('/async', asyncHandler(async(req, res) => { const result = await request('http://example.com'); res.end(result); })); // Any rejection will go to the error handlerTambién hay algunos paquetes que se pueden usar
Bueno, encontré esto: https://github.com/davidbanham/express-async-errors/ , luego requiero el script y listo.
const express = require('express'); require('express-async-errors');La respuesta con asyncHandler es buena y útil, pero aún no es cómodo escribir este contenedor en cada ruta. Propongo mejorarlo:
const asyncHandler = fn => (req, res, next) => { return Promise .resolve(fn(req, res, next)) .catch(next) } const methods = [ 'get', 'post', 'delete' // & etc. ] function toAsyncRouter(router) { for (let key in router) { if (methods.includes(key)) { let method = router[key] router[key] = (path, ...callbacks) => method.call(router, path, ...callbacks.map(cb => asyncHandler(cb))) } } return router }y ahora podemos hacer de esa manera:
const router = toAsyncRouter(express().Router()) router.get('/', someAsyncController)y así uno.
Hace un minuto se agregó un módulo npm async-express-decorator .