Como validar CPF no servidor usando Next.js API Routes

// lib/cpf-validator.js

export function validarDigitosCpf(cpf) {
    const cpfLimpo = cpf.replace(/\D/g, '');

    if (cpfLimpo.length !== 11) {
    return { valido: false, erro: 'CPF deve conter 11 dígitos' };
    }

    if (/^(\d)\1{10}$/.test(cpfLimpo)) {
    return { valido: false, erro: 'CPF com todos os dígitos iguais' };
    }

    const digitos = cpfLimpo.split('').map(Number);

    let soma = 0;
    for (let i = 0; i < 9; i++) {
    soma += digitos[i] * (10 - i);
    }
    const d1 = soma % 11 < 2 ? 0 : 11 - (soma % 11);

    soma = 0;
    for (let i = 0; i < 10; i++) {
    soma += digitos[i] * (11 - i);
    }
    const d2 = soma % 11 < 2 ? 0 : 11 - (soma % 11);

    if (digitos[9] !== d1 || digitos[10] !== d2) {
    return { valido: false, erro: 'Dígitos verificadores inválidos' };
    }

    return { valido: true, cpfLimpo };
}

export function formatarCpf(cpf) {
    const limpo = cpf.replace(/\D/g, '');
    return limpo.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
}

// app/api/validar-cpf/route.js

import { validarDigitosCpf } from '@/lib/cpf-validator';

export async function POST(request) {
    const body = await request.json();
    const { cpf } = body;

    if (!cpf) {
    return Response.json(
    { success: false, message: 'CPF é obrigatório' },
    { status: 400 }
    );
    }

    const validacaoLocal = validarDigitosCpf(cpf);

    if (!validacaoLocal.valido) {
    return Response.json({
    success: false,
    validacaoLocal: false,
    message: validacaoLocal.erro,
    }, { status: 400 });
    }

    try {
    const apiResponse = await fetch(
    `${process.env.CPFHUB_BASE_URL}/cpf/${validacaoLocal.cpfLimpo}`,
    {
    headers: {
    'x-api-key': process.env.CPFHUB_API_KEY,
    },
    }
    );

    if (!apiResponse.ok) {
    return Response.json({
    success: true,
    validacaoLocal: true,
    encontradoNaBase: false,
    message: 'CPF válido, porém não encontrado na base',
    });
    }

    const dados = await apiResponse.json();

    return Response.json({
    success: true,
    validacaoLocal: true,
    encontradoNaBase: dados.success,
    data: dados.success ? dados.data : null,
    message: dados.success
    ? 'CPF válido e encontrado'
    : 'CPF válido, mas sem dados',
    });
    } catch (error) {
    return Response.json({
    success: false,
    validacaoLocal: true,
    message: 'Erro ao consultar API externa',
    }, { status: 502 });
    }
}

// app/api/validar-cpf/lote/route.js

import { validarDigitosCpf } from '@/lib/cpf-validator';

export async function POST(request) {
    const { cpfs } = await request.json();

    if (!Array.isArray(cpfs) || cpfs.length === 0) {
    return Response.json(
    { success: false, message: 'Envie um array de CPFs' },
    { status: 400 }
    );
    }

    if (cpfs.length > 50) {
    return Response.json(
    { success: false, message: 'Máximo de 50 CPFs por requisição' },
    { status: 400 }
    );
    }

    const resultados = await Promise.allSettled(
    cpfs.map(async (cpf) => {
    const validacao = validarDigitosCpf(cpf);

    if (!validacao.valido) {
    return { cpf, valido: false, erro: validacao.erro };
    }

    const response = await fetch(
    `${process.env.CPFHUB_BASE_URL}/cpf/${validacao.cpfLimpo}`,
    {
    headers: { 'x-api-key': process.env.CPFHUB_API_KEY },
    }
    );

    if (!response.ok) {
    return { cpf, valido: true, encontrado: false };
    }

    const dados = await response.json();
    return {
    cpf,
    valido: true,
    encontrado: dados.success,
    nome: dados.success ? dados.data.name : null,
    };
    })
    );

    const processados = resultados.map((r) =>
    r.status === 'fulfilled' ? r.value : { erro: 'Falha no processamento' }
    );

    return Response.json({ success: true, resultados: processados });
}

// middleware.js

import { NextResponse } from 'next/server';

const rateLimit = new Map();
const WINDOW_MS = 60 * 1000;
const MAX_REQUESTS = 30;

export function middleware(request) {
    if (!request.nextUrl.pathname.startsWith('/api/validar-cpf')) {
    return NextResponse.next();
    }

    const ip = request.headers.get('x-forwarded-for') ||
    request.headers.get('x-real-ip') || 'unknown';

    const now = Date.now();
    const windowStart = now - WINDOW_MS;

    if (!rateLimit.has(ip)) {
    rateLimit.set(ip, []);
    }

    const requests = rateLimit.get(ip).filter((t) => t > windowStart);
    requests.push(now);
    rateLimit.set(ip, requests);

    if (requests.length > MAX_REQUESTS) {
    return Response.json(
    { success: false, message: 'Limite de requisições excedido' },
    { status: 429, headers: { 'Retry-After': '60' } }
    );
    }

    return NextResponse.next();
}

export const config = {
    matcher: '/api/validar-cpf/:path*',
};

// hooks/useCpfValidation.js
'use client';

import { useState, useCallback } from 'react';

export function useCpfValidation() {
    const [loading, setLoading] = useState(false);
    const [resultado, setResultado] = useState(null);
    const [erro, setErro] = useState(null);

    const validar = useCallback(async (cpf) => {
    setLoading(true);
    setErro(null);
    setResultado(null);

    try {
    const response = await fetch('/api/validar-cpf', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ cpf }),
    });

    const data = await response.json();

    if (response.ok && data.success) {
    setResultado(data);
    } else {
    setErro(data.message || 'Erro na validação');
    }
    } catch {
    setErro('Erro de conexão');
    } finally {
    setLoading(false);
    }
    }, []);

    return { validar, loading, resultado, erro };
}