Home / Questions / 269424
Accepted
H. Díaz
Asked: 2020-06-05 04:08:54 +0800 CST 2020-06-05 04:08:54 +0800 CST

How to catch this exception

  • 772

I have a problem with an exception, the thing is that I can't catch it and I don't know how to do it:

I have a model that does an insert into a database:

xxxModel.generaNuevoxxx = async function (c, tipo, xxx) {

    let sql = `insert into xxx
        (xxx)
        values
        (xxx)`; 
    let obj = {
        xxx: xxx.xxx,
        xxx: xxx.xxx,
    }
    try {
        console.log(obj);
        return await c.execute(sql, obj, dbController.config);
    } catch (e) {
        throw new Error(`(xxx-model) generaNuevoxxxx -> ${e.message}`);
    }
}

Which if an exception occurs in the execution of the insert would throw the exception. Then I have a controller, which is somewhat more extensive:

async function fabricar(req, res) {
    let c;
    try {
       /*Aqui se hacen más cosas*/
       infoComponentes.map(async xxx => {
          try{
              let medidaxxx = calcularMedida(xxx);
              xxx.s1 = medidaxxx.stock_1;
              xxx.s2 = medidaxxx.stock_2;
              if (xxx.FAMILIA == 'xxxx' || xxx.FAMILIA == '<<<<') {
                  await xxxModel.generaMovimientoxxx(c, "qwe", [componente]);
                  await xxxModel.generaNuevoxxx(c, "qwe", xxx);
                ////AQUI ES DONDE LLAMO AL MODELO, EL CUAL AL DEVOLVER LA EXCEPCIÓN NO LA MANEJA
              }
          }catch(e){
            throw e;
          }
        });
      await c.commit();
      console.log("Desconectando...".red);
      return res.status(200).send({ message: "Proceso acabado." });
    }catch(e){
        c.rollback();
        console.log(`Error: (xxx) -> ${e.message}`);
        return res.status(500).send({ message: e.message });
    }

It tells me that the exception is unhandled and also arrives at the commit and finishes showing the finished process message. How could I catch that exception?

javascript

2 Answers

  1. Best Answer

    tl;dr

    Short answer

    Do not use a nested block to try to catch an error from an asynchronous function that you pass as an argument to an iterable( map) method, since the method mapis not asynchronous. Therefore the proper option is to handle promises with Promise.all() .

    Long answer with explanation and example code at the end

    The problem is in the way you handle asynchronous functions. Although you are using try...catch, the procedure is not done the way you think.

    When you make the call to: infoComponentes.map(async xxx => {...});you are effectively calling an asynchronous function that is executed for each element of your array, but the maptype Arraymethod is not an asynchronous method.

    Let's look at an example:

    const numbers = [1, 2, 3, 4, 5];
//La siguiente función devuelve el doble de "number"
// es una función async porque devuelve una Promesa
const asyncDoubles = async (number) => {
  console.log(`Calculando ${number}.`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Devolviendo ${number} * 2.`);
      return resolve(number * 2);
    }, 2000);
  });
}
// llamamos al método map de numbers y le pasamos nuestra fucnión asíncrona
const doubles = numbers.map(asyncDoubles);
console.log(doubles);
console.log(`Esta es la línea final, después de esto no debería haber mas nada`);

    As you can see, the method mapis not executed asynchronously, that is, for each element of numbersour function will be executed asyncDoubles, but that function will be called immediately without waiting for the previous call to return a result.

    Let's see what happens now if we throw an error inside our async function based on the result of the operation. For that we will use try...catch.

    // nuestro array ahora contiene 6 números
const numbers = [1, 2, 3, 4, 5, 6];

// nuestra función no cambia en su declaración
const asyncDoubles = async (number) => {
  console.log(`Calculando ${number}.`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // ahora intentaremos calcular el valor doble
      // e impondremos una condición
      // si la misma no se cumple, se lanzará un error
      try {
        if(number < 6) {
          console.log(`Devolviendo ${number} * 2.`);
          return resolve(number * 2);
        } else {
          throw new Error(`Número mayor que 5.`);
        }
      } catch (error) {
        // si en el bloque try se produce un error, el mismo será capturado aqui
        console.log(`Se captura el error: ${error.message}`);
        return reject(error);
      }
    }, 2000);
  });
}

// ahora veamos la secuencia de acontecimientos:
const doubles = numbers.map(asyncDoubles);
console.log(doubles);
console.log(`Esta es la línea final, después de esto no debería haber mas nada`);

    If we were to run such code in Node, we would get the following at the end of our code:

    UnhandledPromiseRejectionWarning: Error: Número mayor que 5.

    Why do we get this error?

    Simply because all of our code has been executed, there is nothing else to process except what is in it event loop(our function setTimeout()), which is executed after 2 seconds and in which a promise is rejected.

    However, there is no more code to process, the error propagates to the main process without a handler for it, and that is where it shows us the message.

    How is it possible that mapit is not async if I call it inside a function declared with async?

    In your code you call the method mapinside an async function async function fabricar(req, res) {...}- should it be async now?

    Let's see an example of behavior using mapinside a function async:

    const numbers = [1, 2, 3, 4, 5, 6];
const asyncDoubles = async (number) => {
  console.log(`Calculando ${number}.`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      try {
        if(number < 6) {
          console.log(`Devolviendo ${number} * 2.`);
          return resolve(number * 2);
        } else {
          throw new Error(`Número mayor que 5.`);
        }
      } catch (error) {
        console.log(`Se captura el error: ${error.message}`);
        return reject(error);
      }
    }, 2000);
  });
}

// declaramos una función async y llamamos a map dentro de la misma
const calcularDobles = async () => {
  const result = numbers.map(asyncDoubles);
  console.log(result);
  return result;
}

// llamamos a nuestra función async
const doubles = calcularDobles();
console.log(doubles);
console.log(`Esta es la línea final, después de esto no debería haber mas nada`);

    Well, it's the same behavior.

    However we have not used await. Should we use it?

    const numbers = [1, 2, 3, 4, 5, 6];
const asyncDoubles = async (number) => {
  console.log(`Calculando ${number}.`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      try {
        if(number < 6) {
          console.log(`Devolviendo ${number} * 2.`);
          return resolve(number * 2);
        } else {
          throw new Error(`Número mayor que 5.`);
        }
      } catch (error) {
        console.log(`Se captura el error: ${error.message}`);
        return reject(error);
      }
    }, 2000);
  });
}

const calcularDobles = async () => {
  const result = await numbers.map(asyncDoubles);
  console.log(result);
  return result;
}

const doubles = calcularDobles();
console.log(doubles);
console.log(`Esta es la línea final, después de esto no debería haber mas nada`);

    Well, nothing. We keep getting the same result. Resources are exhausted, so let's see the documentation for async functionan answer: (own translation)

    A function asyncis a function that operates asynchronously by event loopusing an Implicit Promise to return its result.

    A function asynccan contain the expression awaitthat pauses the execution of the asynchronous function and waits for the resolution of the passed Promise , and then resumes the execution of the function asyncand returns the resolved value.

    And here's the whole mystery: awaitIt also doesn't convert a synchronous function (like map) to a function asíncrona. What it does awaitis wait for the function to be executed ( map) to return a result and then it continues with the execution of the function async. The method mapdoesn't return a Promise, so it awaitjust pauses for a while, which is how long it takes mapto call the function asyncDoubles, and continues on its way without waiting for calls to asyncDoublesresolve the Promise.

    SOLUTION

    We've already seen that using asyncto do what we're trying to do isn't an option, since the method mapisn't asynchronous.

    We must refactor our code. Currently based on what you state in your question, I can understand the process of what you are trying to accomplish.

    I have given myself the task of creating an example as similar as possible so that it can be reproduced with the tools available here. The code would be the following:

    // el siguiente JSON emula a request
const req = {
  body: {
    componentes: [
      { name: 'Componente 1', status: 'No procesado' },
      { name: 'Componente 2', status: 'No procesado' },
      { name: 'Componente 3', status: 'No procesado' },
      { name: 'Componente 4', status: 'No procesado' },
      { name: 'Componente 5', status: 'No procesado' }
    ]
  }
}

// el siguiente JSON emula a response
const res = {
  send: function(object) {
    console.log(object);
  }
}

// El siguiente JSON emula a Model según tu definición
const Model = {
  generarNuevo: async (componente) => {
    try {
      await execute(componente);
    } catch(error) {
      throw new Error(`Error en generarNuevo: ${error.message} al procesar ${componente.name}.`);
    }
  }
}

// la siguiente función emula a c.commit
const commit = async () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const fail = false;
      if(fail) {
        console.log(`Rejecting commit`);
        return reject(new Error(`Not Commited.`));
      }
      console.log(`Resolving commit`);
      return resolve(`Commited.`);
    }, 1000);
  });
}


// la siguiente función emula a c.execute
const execute = async (componente) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Procesando: ${componente.name}.`);
      if(componente.name !== 'Componente 5') {
        componente.status = 'Procesado';
        return resolve(componente);
      } else {
        return reject(new Error(`Promesa no resuelta`));
      }
    }, 2000);
  });
}

// la siguiente función emula al método fabricar del controlador
const fabricar = async (req, res) => {
  try {
    let infoComponentes = req.body.componentes;
    infoComponentes.map(async (componente) => {
      console.log(`infoComponentes.map: ${componente.name}`);
      try {
        await Model.generarNuevo(componente);
      } catch(e) {
        console.log(`Error en map: ${e.message}`);
        throw e;
      }
    });
    await commit();
    console.log('Deconectando...');
    res.send({
      message: 'Proceso finalizado satisfactoriamente.'
    });
  } catch(error) {
    console.log(error.message);
    res.send({
      message: error.message
    });
  }
}

fabricar(req,res);

    Well, we have already reproduced the error, and we will see that when executing this code in Node, we will obtain the following error:

    UnhandledPromiseRejectionWarning: Error: Error en generarNuevo: Promesa no resuelta al procesar Componente 5.

    However, before obtaining this error, we can see the following in the console:

    Resolving commit
Deconectando...
{ message: 'Proceso finalizado satisfactoriamente.' }

    That is, the block catchthat should catch our exception does not. And we already saw why earlier.

    Here comes the refactoring, having understood a little what you intend with your code.

    The process I think you want to perform would be the following:

    1. Given a list of "Components", perform a series of operations on each one.
    2. After completing step 1 with each item in the list, save the "Component" to the database.
    3. Once all components have been saved, perform a scan commiton the database.
    4. Report the results (whether positive or negative).

    In a nutshell you are performing a bulk inserton your database.

    Since the method mapis not asynchronous, we must look for an alternative to insert the records in the database.

    An alternative, in order not to alter so much the way we are trying to do things, is to use Promise.all .

    Basically, this method returns a Promise, which resolves successfully if all promises in the iterable argument complete successfully, and is rejected if any promises in the iterable argument are rejected.

    The implementation would be the following:

    // elementos req y res sin alteración

const req = {
  body: {
    componentes: [
      { name: 'Componente 1', status: 'No procesado' },
      { name: 'Componente 2', status: 'No procesado' },
      { name: 'Componente 3', status: 'No procesado' },
      { name: 'Componente 4', status: 'No procesado' },
      { name: 'Componente 5', status: 'No procesado' }
    ]
  }
}

const res = {
  send: function(object) {
    console.log(object);
  }
}

// Sin cambios en el método generarNuevo
const Model = {
  generarNuevo: async (componente) => {
    try {
      // realizamos operaciones con el componente antes de guardarlo
      await execute(componente);
    } catch(error) {
      throw new Error(`Error en generarNuevo: ${error.message}`);
    }
  }
}

// tampoco hay cambios en execute() ni en commit()
const execute = async (componente) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Procesando: ${componente.name}.`);
      if(componente.name !== 'Componente 5') {
        componente.status = 'Procesado';
        resolve(componente);
      } else {
        reject(new Error(`Error procesando ${componente.name}`));
      }
    }, 2000);
  });
}

const commit = async () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const fail = false;
      if(fail) {
        console.log(`Rejecting commit`);
        return reject(new Error(`Not Commited.`));
      }
      console.log(`Resolving commit`);
      return resolve(`Commited.`);
    }, 1000);
  });
}

// implementamos Promise.all en nuestro método fabricar()
const fabricar = (req, res) => {
  let infoComponentes = req.body.componentes;
  // almacenamos el array de componentes en un nuevo array y le llamaremos promises (tendrá promesas)
  let promises = infoComponentes.map((componente) => {
    // dado que generarNuevo es asícrona podemos usar then y catch
    return Model.generarNuevo(componente)
      .then(() => {
        console.log(`Promesa resuelta para: ${componente.name}.`);
      })
      .catch((e) => {
        throw new Error(e.message);
      });
  });

  // Ahora llamamos a Promise.all() y le pasamos nuestro array de promesas
  Promise.all(promises)
    .then(async () => {
      // si todas las promesas son resueltas podemos hacer commit
      // sin embargo, el commit podría fallar, habría
      // que envolverlo en un bloque `try catch`
      try {
        await commit();
        console.log('Deconectando...');
        console.log('Enviado respuesta a cliente:');
        res.send({
          message: 'Proceso finalizado satisfactoriamente.'
        });
      } catch (err) { // <- Aqui capturo errores en el commit
        console.log(err.message);
        console.log('Enviado respuesta a cliente:');
        res.send({
          message: `Error durante el proceso: ${err.message}`
        });
      }
      
    })
    .catch((error) => { // <- Aqui capturo errores en los execute de cada componente
      console.log(error.message);
      console.log('Enviado respuesta a cliente:');
      res.send({
        message: `Error en proceso: ${error.message}`
      });
    });
}

fabricar(req,res);

    Now, we're done bulk insertusing promises and asynchronous programming.

    If we execute the previous code in Node the possible results would be:

    Failed in Component 5

    //se cumple: componente.name === 'Componente 5'

Error en generarNuevo: Error procesando Componente 5
Enviado respuesta a cliente:
{ message: 'Error en proceso: Error en generarNuevo: Error procesando Componente 5' }

    No component error but commit error

    // se cumple: fail === true

Rejecting commit
Not Commited.
Enviado respuesta a cliente:
{ message: 'Error durante el proceso: Not Commited.' }

    No component error and no commit error

    Resolving commit
Deconectando...
Enviado respuesta a cliente:
{ message: 'Proceso finalizado satisfactoriamente.' }

    I hope this answer clears your doubts and helps you solve the problem.

    • 5

  2. When you execute the method .map(...), you are passing it an asynchronous function. That is, it is a function that returns a promise. It is similar (not the same) to using a setTimeout:

    function a() {
  setTimeout(() => {
    throw new Error('Error');
  });
}

try {
  a();
} catch (error) {
  console.log('Error capturado',error);
}
console.log('Ejecución completada');

    El error no se captura porque durante el try - catch no se ejecuta a(), simplemente se declara ( o se delega, como prefieras verlo) que se ejecutará en un futuro próximo.

    Usando promesas sería algo así:

    async function  a1() {
  return new Promise(function (a, r) {
    setTimeout(()=> {
      throw new Error()
    });
  });
}

async function  a2() {
  return new Promise(function (a, r) {
    setTimeout(() => {
      r('se llamó a reject');
    });
  });
}
async function m1() {
  try {
    await a1();
  } catch (error) {
    console.log('Error',error);
  }
  console.log('Ejecución 1 completada');
}

async function m2() {
  try {
     await a2();
    
  } catch (error) {
    console.log('Error capturado',error);
  }
  console.log('Ejecución 2 completada');
}
m1();
m2();

    Tenemos dos escenarios: se ha lanzado un error desde dentro de la promesa (en a1) o el error fue reconocido y simplemente se llamó a función de rejection (en a2). Al usar await, el código se queda esperando a la resolución de la promesa, pero si ésta lanza un error, no se puede capturar. Si llama a reject, se interpreta como un error asíncrono que se puede tratar dentro de la función asíncrona

    Por tanto podemos ver que si se manejan bien las promesas y las excepciones, podemos capturar los errores.

    ¿Qué ocurre con tu código? Tienes un array de promesas que no gestionas de ningún modo, con lo que los errores no se pueden capturar. Es lo que hace map: crea un array con el mismo número de elementos que array recorrido, generados por la función que le has pasado.

    La solución es usar Promise.all():

    await Promise.all(misDatos.map(await () => ...));


    async function porDos(n) {
  if (n<2) {
    console.log('Da', n * 2);
    return 2*n;
  }
  throw new Error('Nah');
}

async function main () {
  try {
    await Promise.all([0,1,2].map(porDos));
  } catch (e) {
    console.log('Ooops!',e.toString());
  }
}

main();

    • 2