Como Processar Múltiplas Consultas de CPF em Paralelo Usando Node.js

const fetch = (...args) =>
    import("node-fetch").then(({ default: f }) => f(...args));

const API_KEY = process.env.CPFHUB_API_KEY;
const BASE_URL = "https://api.cpfhub.io/cpf";

async function consultarCPF(cpf) {
    const response = await fetch(`${BASE_URL}/${cpf}`, {
    headers: { "x-api-key": API_KEY }
    });

    if (!response.ok) {
    throw new Error(`HTTP ${response.status} para CPF ${cpf}`);
    }

    return response.json();
}

async function consultarLoteSimples(cpfs) {
    const promessas = cpfs.map((cpf) => consultarCPF(cpf));
    const resultados = await Promise.allSettled(promessas);

    return resultados.map((resultado, index) => ({
    cpf: cpfs[index],
    sucesso: resultado.status === "fulfilled",
    dados: resultado.status === "fulfilled" ? resultado.value.data : null,
    erro: resultado.status === "rejected" ? resultado.reason.message : null
    }));
}

// Uso
const cpfs = ["12345678901", "98765432100", "11122233344"];
const resultados = await consultarLoteSimples(cpfs);
console.log(resultados);

import pLimit from "p-limit";

const limite = pLimit(10); // Máximo de 10 requisições simultâneas

async function consultarLoteControlado(cpfs) {
    const promessas = cpfs.map((cpf) =>
    limite(async () => {
    try {
    const resultado = await consultarCPF(cpf);
    return { cpf, sucesso: true, dados: resultado.data };
    } catch (erro) {
    return { cpf, sucesso: false, erro: erro.message };
    }
    })
    );

    return Promise.all(promessas);
}

// Processar 1000 CPFs com no máximo 10 em paralelo
const cpfsGrandes = gerarListaCPFs(1000);
const inicio = Date.now();
const resultados = await consultarLoteControlado(cpfsGrandes);
const duracao = Date.now() - inicio;

const sucessos = resultados.filter((r) => r.sucesso).length;
const falhas = resultados.filter((r) => !r.sucesso).length;

console.log(`Processados: ${resultados.length}`);
console.log(`Sucessos: ${sucessos}, Falhas: ${falhas}`);
console.log(`Duração: ${duracao}ms`);

async function poolConcorrencia(tarefas, concorrenciaMaxima) {
    const resultados = new Array(tarefas.length);
    let indiceAtual = 0;

    async function worker() {
    while (indiceAtual < tarefas.length) {
    const indice = indiceAtual++;
    try {
    resultados[indice] = {
    sucesso: true,
    dados: await tarefas[indice]()
    };
    } catch (erro) {
    resultados[indice] = { sucesso: false, erro: erro.message };
    }
    }
    }

    const workers = Array.from(
    { length: Math.min(concorrenciaMaxima, tarefas.length) },
    () => worker()
    );

    await Promise.all(workers);
    return resultados;
}

// Uso
const tarefas = cpfs.map((cpf) => () => consultarCPF(cpf));
const resultados = await poolConcorrencia(tarefas, 15);

async function consultarComRetry(cpf, tentativas = 3) {
    for (let i = 0; i < tentativas; i++) {
    try {
    const resultado = await consultarCPF(cpf);
    return resultado;
    } catch (erro) {
    if (i === tentativas - 1) throw erro;

    const delay = Math.pow(2, i) * 1000 + Math.random() * 500;
    console.log(
    `Tentativa ${i + 1} falhou para CPF ${cpf}. ` +
    `Retentando em ${Math.round(delay)}ms...`
    );
    await new Promise((resolve) => setTimeout(resolve, delay));
    }
    }
}

async function consultarLoteResilient(cpfs, concorrencia = 10) {
    const limite = pLimit(concorrencia);

    const promessas = cpfs.map((cpf) =>
    limite(async () => {
    try {
    const resultado = await consultarComRetry(cpf);
    return { cpf, sucesso: true, dados: resultado.data };
    } catch (erro) {
    return { cpf, sucesso: false, erro: erro.message };
    }
    })
    );

    return Promise.all(promessas);
}