How to force error in the return of a Promise inside another Promise

Question

  const Firebird = require('node-firebird');
const { database } = require("../backend.conf");

async function pesqcdcidade(cidade) {

    return new Promise((resolve, reject) => {

        Firebird.attach(database, async function (err, db) {
            if (err) {
                reject(err);
            }

            const SQL = ' SELECT FIRST 1 CDCIDADE' +
                ' FROM CIDADES' +
                ' WHERE DESCRICAO =?';

            db.query(SQL, [cidade], async (err, resultParam) => {
                if (err) {
                    reject(err);
                };

                if (resultParam != undefined) {
                    if (resultParam.length > 0) {
                        for (k = 0; k < resultParam.length; k++) {
                            resolve(resultParam[k]);
                        }
                    } else {

                        resolve("inexistente")
                    }
                } else {

                    resolve("inexistente")

                }

                db.detach();
            });
        });

    });


};
async function insertCidade(endereco) {
    return new Promise((resolve, reject) => {

        Firebird.attach(database, function (err, db) {
            if (err) {
                reject(err);
            }

            const SQL = ' INSERT INTO CIDADES (CDCIDADE, DESCRICAO, CDESTADO) ' +
                ' VALUES ((SELECT COALESCE(MAX(CDCIDADE), 0) + 1 ' +
                ' FROM CIDADES), ?, ?)';

            db.transaction(Firebird.ISOLATION_READ_COMMITED, function (err, transaction) {
                if (err) {
                    reject(err);
                }

                transaction.query(SQL, [endereco.cidade, endereco.uf], function (err) {
                    if (err) {
                        reject(err);
                    }

                    transaction.commit(function (err) {
                        if (err) {
                            transaction.rollback();
                            reject(err);

                        } else {
                            resolve("OK")
                            db.detach();
                        }
                    });
                });
            })
        });
    });
};
module.exports = app => {

    const insert = async (req, res) => {

        let strTesteDescri = "cidade exemplo";
        let cdcidade = 0;

        let cliente = {
            "endereco": {
                "cidade": "exemplo de cidade",
                "uf": "RS"
            }
        }


        try {
            await pesqcdcidade(strTesteDescri)
                .then(async (resultado) => {
                    if (resultado == 'inexistente') {
                        return await insertCidade(cliente.endereco)
                            .then(
                                await pesqcdcidade(strTesteDescri)
                                    .then(resultado => {
                                        if (resultado != 'inexistente') {
                                            cdcidade = resultado.CDCIDADE
                                        }

                                    })

                            )
                            .catch((err) => {
                                throw new Error('insertCidade failed');
                            })
                    } else {
                        cdcidade = resultado.CDCIDADE
                    }
                })

        } catch (eer) {
            return res.status(500).send(err);
        }
    }

}`insira o código aqui`

Answer 1

Two options:

• withdraw that catch
• return a new error within the catch.

The async/await API is very practical but creates difficulties with error management.

async function teste() {
  const res = await Promise
    .resolve(foo())
    .catch(err => {
      console.log('Erro interno', err);
      throw new Error('Erro 2');
    });
  return res;
}

function foo() {
  return Promise.reject('Erro 1');
}

teste().catch(err => console.log('Catch exterior', err.message));

Usa throw new Error(...frase...) to create a new error and so it propagates to the code that invoked that line.