// app.js

// Importando o módulo 'fs/promises' para operações de arquivo assíncronas que retornam Promises.
// Nota: Em cenários mais simples ou legados, o 'fs' puro com callbacks era comum,
// mas 'fs/promises' é a abordagem moderna e recomendada para trabalhar com Promises.
const fs = require('fs/promises');
// Importando o módulo 'path' para lidar com caminhos de arquivos de forma segura e multiplataforma.
const path = require('path');
// Definindo um caminho para um arquivo de exemplo.
// O arquivo será 'dados.txt' na mesma pasta do 'app.js'.
const caminhoArquivo = path.join(__dirname, 'dados.txt');
// --- Função para simular uma operação assíncrona com Promise ---
/* Simula a leitura de um arquivo. Esta função retorna uma Promise
  que será resolvida com o conteúdo do arquivo ou rejeitada em caso de erro.
  @param {string} caminho O caminho completo do arquivo a ser lido.
  @returns {Promise} Uma Promise que resolve com o conteúdo do arquivo.
 /
function lerArquivoAssincrono(caminho) {
    // Retornamos uma nova Promise. O construtor da Promise recebe uma função
    // com dois argumentos: resolve (para sucesso) e reject (para falha).
    return new Promise(async (resolve, reject) => {
        // Simulamos um atraso artificial para mimetizar uma operação de I/O real,
        // que naturalmente levaria tempo. Aqui, 2 segundos (2000 milissegundos).
        console.log([${new Date().toLocaleTimeString()}] Tentando ler o arquivo: ${caminho});
        await new Promise(res => setTimeout(res, 2000)); // Espera 2 segundos

        try {
            // Tentamos ler o arquivo de forma assíncrona usando 'fs/promises'.
            // O '.readFile' já retorna uma Promise, então podemos usar await aqui dentro
            // de um bloco async para um código mais linear.
            const conteudo = await fs.readFile(caminho, { encoding: 'utf8' });
            console.log([${new Date().toLocaleTimeString()}] Arquivo '${path.basename(caminho)}' lido com sucesso.);
            // Se a leitura for bem-sucedida, a Promise é resolvida com o conteúdo.
            resolve(conteudo);
        } catch (erro) {
            // Se ocorrer qualquer erro durante a leitura, a Promise é rejeitada com o erro.
            console.error([${new Date().toLocaleTimeString()}] Erro ao ler o arquivo '${path.basename(caminho)}':, erro.message);
            reject(new Error(Falha na leitura do arquivo: ${erro.message}));
        }
    });
}
// --- Ponto de Entrada da Aplicação ---
async function iniciarAplicacao() {
    console.log([${new Date().toLocaleTimeString()}] Aplicação iniciada.);
    // --- Uso Básico da Promise: .then() e .catch() ---
    console.log(\n--- Exemplo 1: Leitura de arquivo bem-sucedida ---);
    lerArquivoAssincrono(caminhoArquivo)
        // O método .then() é executado quando a Promise é resolvida (sucesso).
        // Ele recebe o valor que foi passado para 'resolve()'.
        .then(conteudo => {
            console.log([${new Date().toLocaleTimeString()}] Resultado do Exemplo 1 (Sucesso):);
            console.log(Conteúdo do arquivo: "${conteudo.trim()}");
        })
        // O método .catch() é executado quando a Promise é rejeitada (erro).
        // Ele recebe o valor que foi passado para 'reject()'.
        .catch(erro => {
            console.error([${new Date().toLocaleTimeString()}] Resultado do Exemplo 1 (Erro):, erro.message);
        })
        // O método .finally() é sempre executado, independentemente de a Promise
        // ter sido resolvida ou rejeitada. Útil para limpeza de recursos.
        .finally(() => {
            console.log([${new Date().toLocaleTimeString()}] Exemplo 1 finalizado (operação de limpeza, etc.).);
        });
    // --- Exemplo 2: Tratamento de erro (arquivo inexistente) ---
    console.log(\n--- Exemplo 2: Leitura de arquivo inexistente ---);
    const arquivoInexistente = path.join(__dirname, 'arquivo_nao_existe.txt');
    lerArquivoAssincrono(arquivoInexistente)
        .then(conteudo => {
            console.log([${new Date().toLocaleTimeString()}] Resultado do Exemplo 2 (Sucesso - Não deveria ocorrer):, conteudo);
        })
        .catch(erro => {
            // Este .catch() irá capturar o erro de 'arquivo_nao_existe.txt'.
            console.error([${new Date().toLocaleTimeString()}] Resultado do Exemplo 2 (Erro esperado):, erro.message);
        })
        .finally(() => {
            console.log([${new Date().toLocaleTimeString()}] Exemplo 2 finalizado (operação de limpeza, etc.).);
        });
    // --- Exemplo 3: Encadeamento de Promises ---
    // Múltiplas operações assíncronas em sequência.
    // O resultado de uma Promise pode ser passado como entrada para a próxima.
    console.log(\n--- Exemplo 3: Encadeamento de Promises ---);
    lerArquivoAssincrono(caminhoArquivo)
        .then(conteudo => {
            console.log([${new Date().toLocaleTimeString()}] Etapa 1: Arquivo lido. Conteúdo: "${conteudo.trim().substring(0, 15)}...");
            // Aqui, simulamos uma segunda operação assíncrona que processa o conteúdo.
            // É crucial RETORNAR uma nova Promise para que o próximo .then() possa encadear.
            return new Promise(res => {
                setTimeout(() => {
                    const conteudoProcessado = conteudo.toUpperCase();
                    console.log([${new Date().toLocaleTimeString()}] Etapa 2: Conteúdo processado para maiúsculas.);
                    res(conteudoProcessado);
                }, 1500); // Mais 1.5 segundos de atraso
            });
        })
        .then(conteudoFinal => {
            // Este .then() recebe o resultado da Promise retornada na etapa anterior.
            console.log([${new Date().toLocaleTimeString()}] Etapa 3: Conteúdo final após processamento: "${conteudoFinal.trim().substring(0, 30)}...");
            // Podemos retornar mais uma Promise, se necessário, ou um valor direto.
            return Processamento completo e finalizado.;
        })
        .catch(erro => {
            console.error([${new Date().toLocaleTimeString()}] Erro no encadeamento de Promises:, erro.message);
        })
        .finally(() => {
            console.log([${new Date().toLocaleTimeString()}] Exemplo 3 finalizado.);
        });
    console.log([${new Date().toLocaleTimeString()}] Operações assíncronas disparadas. A aplicação continua executando outras tarefas.);
    // O código aqui é executado imediatamente, sem esperar as Promises acima terminarem,
    // demonstrando a natureza não-bloqueante.
}
// Cria um arquivo de exemplo para ser lido pela Promise.
// Use fs.writeFile para garantir que o arquivo exista antes de tentar ler.
fs.writeFile(caminhoArquivo, 'Este e um exemplo de conteudo do arquivo dados.txt.\nLinha 2 de teste.', { encoding: 'utf8' })
    .then(() => {
        console.log([${new Date().toLocaleTimeString()}] Arquivo de exemplo '${path.basename(caminhoArquivo)}' criado com sucesso.);
        iniciarAplicacao(); // Inicia a aplicação após criar o arquivo.
    })
    .catch(err => {
        console.error([${new Date().toLocaleTimeString()}] Erro ao criar arquivo de exemplo:, err.message);
        // Se não conseguir criar o arquivo, ainda tentamos iniciar a aplicação,
        // mas o Exemplo 1 falhará, demonstrando o .catch().
        iniciarAplicacao();
    });

// Adicione esta seção ao seu arquivo app.js ou crie um novo.

// --- Nova Função para o Exercício ---
/ Simula uma conexão com banco de dados para buscar um usuário.
  Resolve se o idUsuario for par, rejeita se for ímpar.
  @param {number} idUsuario O ID do usuário a ser buscado.
  @returns {Promise} Uma Promise que resolve com a mensagem de sucesso ou rejeita com a mensagem de erro.
 */
function simularConexaoBancoDeDados(idUsuario) {
    return new Promise((resolve, reject) => {
        console.log([${new Date().toLocaleTimeString()}] Tentando conectar ao banco para idUsuario: ${idUsuario});
        // Simula um atraso de 3 segundos para a 'conexão' e 'consulta'.
        setTimeout(() => {
            if (idUsuario % 2 === 0) {
                // Se o ID for par, resolvemos a Promise.
                const mensagemSucesso = Usuário ${idUsuario} encontrado e dados carregados com sucesso.;
                console.log([${new Date().toLocaleTimeString()}] Sucesso DB para ${idUsuario}.);
                resolve(mensagemSucesso);
            } else {
                // Se o ID for ímpar, rejeitamos a Promise.
                const mensagemErro = Usuário ${idUsuario} não encontrado no banco de dados.;
                console.error([${new Date().toLocaleTimeString()}] Erro DB para ${idUsuario}.);
                reject(new Error(mensagemErro));
            }
        }, 3000); // Atraso de 3 segundos
    });
}
// --- Chamadas para a nova função ---
async function executarExerciciosPromises() {
    console.log(\n--- Exercício: Simulação de Conexão com Banco de Dados ---);
    // Chamada com ID par (sucesso esperado)
    console.log(\nDisparando consulta para ID par (10).);
    simularConexaoBancoDeDados(10)
        .then(resultado => {
            console.log([${new Date().toLocaleTimeString()}] RESULTADO SUCESSO EXERCÍCIO:, resultado);
        })
        .catch(erro => {
            console.error([${new Date().toLocaleTimeString()}] RESULTADO ERRO EXERCÍCIO (não deveria ocorrer para ID par):, erro.message);
        })
        .finally(() => {
            console.log([${new Date().toLocaleTimeString()}] Consulta para ID 10 finalizada.);
        });
    // Chamada com ID ímpar (erro esperado)
    console.log(\nDisparando consulta para ID ímpar (7).);
    simularConexaoBancoDeDados(7)
        .then(resultado => {
            console.log([${new Date().toLocaleTimeString()}] RESULTADO SUCESSO EXERCÍCIO (não deveria ocorrer para ID ímpar):, resultado);
        })
        .catch(erro => {
            console.error([${new Date().toLocaleTimeString()}] RESULTADO ERRO EXERCÍCIO (esperado para ID ímpar):, erro.message);
        })
        .finally(() => {
            console.log([${new Date().toLocaleTimeString()}] Consulta para ID 7 finalizada.);
        });
    console.log([${new Date().toLocaleTimeString()}] Ambas as consultas de banco de dados foram disparadas, aguardando resultados...);
}
// Chame a função do exercício após as outras operações ou de forma isolada.
// Por exemplo, você pode adicionar 'executarExerciciosPromises();' no final do 'iniciarAplicacao()'
// ou criar um novo arquivo para este exercício.
// Para este exemplo, vou chamar isoladamente para evitar sobrecarga no log anterior.
// Certifique-se de comentar as chamadas anteriores se estiver no mesmo arquivo para evitar confusão no log.
// executarExerciciosPromises();

📋 Copiar

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas