Como Usar Redis para Cachear Respostas da API de CPF em Node.js

import Redis from "ioredis";

const redis = new Redis({
    host: process.env.REDIS_HOST || "127.0.0.1",
    port: parseInt(process.env.REDIS_PORT) || 6379,
    password: process.env.REDIS_PASSWORD || undefined,
    maxRetriesPerRequest: 3,
    retryStrategy(times) {
    const delay = Math.min(times * 200, 2000);
    return delay;
    }
});

redis.on("connect", () => console.log("Redis conectado"));
redis.on("error", (err) => console.error("Erro no Redis:", err));

const CACHE_PREFIX = "cpf:";
const CACHE_TTL = 86400; // 24 horas em segundos

async function consultarCPFComCache(cpf) {
    const chaveCache = `${CACHE_PREFIX}${cpf}`;

    // 1. Tentar buscar do cache
    const dadosCache = await redis.get(chaveCache);
    if (dadosCache) {
    console.log(`Cache HIT para CPF ${cpf}`);
    return { fonte: "cache", dados: JSON.parse(dadosCache) };
    }

    console.log(`Cache MISS para CPF ${cpf}`);

    // 2. Buscar da API
    const response = await fetch(`https://api.cpfhub.io/cpf/${cpf}`, {
    headers: { "x-api-key": process.env.CPFHUB_API_KEY }
    });
    const resultado = await response.json();

    if (resultado.success) {
    // 3. Armazenar no cache com TTL
    await redis.setex(chaveCache, CACHE_TTL, JSON.stringify(resultado.data));
    return { fonte: "api", dados: resultado.data };
    }

    return { fonte: "api", dados: null, erro: "CPF não encontrado" };
}

const CACHE_TTL_POSITIVO = 86400; // 24 horas
const CACHE_TTL_NEGATIVO = 3600; // 1 hora
const CACHE_TTL_ERRO = 300; // 5 minutos

async function consultarCPFComCacheCompleto(cpf) {
    const chaveCache = `${CACHE_PREFIX}${cpf}`;

    // Buscar do cache
    const dadosCache = await redis.get(chaveCache);
    if (dadosCache) {
    const parsed = JSON.parse(dadosCache);
    return { fonte: "cache", ...parsed };
    }

    try {
    const response = await fetch(`https://api.cpfhub.io/cpf/${cpf}`, {
    headers: { "x-api-key": process.env.CPFHUB_API_KEY }
    });
    const resultado = await response.json();

    if (resultado.success) {
    // Cache positivo: dados encontrados
    await redis.setex(
    chaveCache,
    CACHE_TTL_POSITIVO,
    JSON.stringify({ sucesso: true, dados: resultado.data })
    );
    return { fonte: "api", sucesso: true, dados: resultado.data };
    }

    // Cache negativo: CPF não encontrado
    await redis.setex(
    chaveCache,
    CACHE_TTL_NEGATIVO,
    JSON.stringify({ sucesso: false, motivo: "nao_encontrado" })
    );
    return { fonte: "api", sucesso: false, motivo: "nao_encontrado" };
    } catch (erro) {
    // Cache de erro: falha transitória
    await redis.setex(
    chaveCache,
    CACHE_TTL_ERRO,
    JSON.stringify({ sucesso: false, motivo: "erro_api" })
    );
    return { fonte: "api", sucesso: false, motivo: "erro_api" };
    }
}

// Invalidação manual de um CPF específico
async function invalidarCache(cpf) {
    await redis.del(`${CACHE_PREFIX}${cpf}`);
    console.log(`Cache invalidado para CPF ${cpf}`);
}

// Invalidação de todo o cache de CPF
async function limparCacheCPF() {
    const chaves = await redis.keys(`${CACHE_PREFIX}*`);
    if (chaves.length > 0) {
    await redis.del(...chaves);
    console.log(`${chaves.length} entradas de cache removidas`);
    }
}

class MonitorCache {
    constructor(redisClient) {
    this.redis = redisClient;
    this.hits = 0;
    this.misses = 0;
    }

    registrarHit() {
    this.hits++;
    }

    registrarMiss() {
    this.misses++;
    }

    get taxaAcerto() {
    const total = this.hits + this.misses;
    return total > 0 ? ((this.hits / total) * 100).toFixed(2) : 0;
    }

    async obterEstatisticas() {
    const info = await this.redis.info("memory");
    const memoriaUsada = info.match(/used_memory_human:(\S+)/)?.[1];
    const totalChaves = await this.redis.dbsize();

    return {
    hits: this.hits,
    misses: this.misses,
    taxaAcerto: `${this.taxaAcerto}%`,
    memoriaUsada,
    totalChaves
    };
    }
}

const monitor = new MonitorCache(redis);

// Exemplo de uso integrado
async function consultarComMonitoramento(cpf) {
    const chaveCache = `${CACHE_PREFIX}${cpf}`;
    const dadosCache = await redis.get(chaveCache);

    if (dadosCache) {
    monitor.registrarHit();
    return JSON.parse(dadosCache);
    }

    monitor.registrarMiss();
    // ... continua com consulta à API
}