Como integrar validação de CPF em Cloudflare Workers com fetch API

npm create cloudflare@latest cpf-validator -- --type=hello-world
cd cpf-validator

name = "cpf-validator"
main = "src/index.ts"
compatibility_date = "2024-01-01"

[vars]
ENVIRONMENT = "production"

[[kv_namespaces]]
binding = "CPF_CACHE"
id = "seu_kv_namespace_id"

// src/index.ts

interface Env {
    CPFHUB_API_KEY: string;
    CPF_CACHE: KVNamespace;
    ENVIRONMENT: string;
}

interface CPFApiResponse {
    success: boolean;
    data?: {
    cpf: string;
    name: string;
    nameUpper: string;
    gender: string;
    birthDate: string;
    day: number;
    month: number;
    year: number;
    };
}

const CORS_HEADERS = {
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type",
};

const CACHE_TTL_SECONDS = 86400; // 24 horas
const API_TIMEOUT_MS = 10000;

function jsonResponse(body: object, status = 200): Response {
    return new Response(JSON.stringify(body), {
    status,
    headers: {
    ...CORS_HEADERS,
    "Content-Type": "application/json",
    "Cache-Control": "no-store",
    },
    });
}

function limparCPF(cpf: string): string {
    return cpf.replace(/\D/g, "");
}

function validarFormatoCPF(cpf: string): string | null {
    if (cpf.length !== 11) return "CPF deve conter 11 digitos";
    if (/^(\d)\1+$/.test(cpf)) return "CPF invalido";
    return null;
}

async function consultarCPFHub(
    cpf: string,
    apiKey: string
): Promise<CPFApiResponse> {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT_MS);

    try {
    const response = await fetch(`https://api.cpfhub.io/cpf/${cpf}`, {
    method: "GET",
    headers: {
    "x-api-key": apiKey,
    "Accept": "application/json",
    },
    signal: controller.signal,
    });

    clearTimeout(timeoutId);

    if (!response.ok) {
    throw new Error(`API retornou status ${response.status}`);
    }

    return await response.json();
    } catch (error) {
    clearTimeout(timeoutId);
    throw error;
    }
}

export default {
    async fetch(request: Request, env: Env): Promise<Response> {
    // CORS preflight
    if (request.method === "OPTIONS") {
    return new Response(null, { headers: CORS_HEADERS });
    }

    if (request.method !== "GET") {
    return jsonResponse({ erro: "Metodo nao permitido" }, 405);
    }

    const url = new URL(request.url);
    const pathParts = url.pathname.split("/").filter(Boolean);

    // Rota: /cpf/:numero
    if (pathParts[0] !== "cpf" || !pathParts[1]) {
    return jsonResponse(
    { erro: "Use /cpf/{numero} para consultar" },
    400
    );
    }

    const cpf = limparCPF(pathParts[1]);
    const erroFormato = validarFormatoCPF(cpf);

    if (erroFormato) {
    return jsonResponse({ erro: erroFormato }, 400);
    }

    // Verificar cache KV
    const cacheKey = `cpf:${cpf}`;
    const cached = await env.CPF_CACHE.get(cacheKey, "json");

    if (cached) {
    return jsonResponse({
    valido: true,
    dados: cached,
    fonte: "cache",
    });
    }

    // Consultar API CPFHub.io
    try {
    const resultado = await consultarCPFHub(cpf, env.CPFHUB_API_KEY);

    if (!resultado.success || !resultado.data) {
    return jsonResponse({ erro: "CPF nao encontrado" }, 404);
    }

    const dados = {
    nome: resultado.data.name,
    cpf: resultado.data.cpf,
    genero: resultado.data.gender,
    dataNascimento: resultado.data.birthDate,
    };

    // Salvar no cache KV
    await env.CPF_CACHE.put(cacheKey, JSON.stringify(dados), {
    expirationTtl: CACHE_TTL_SECONDS,
    });

    return jsonResponse({
    valido: true,
    dados,
    fonte: "api",
    });
    } catch (error) {
    const mensagem =
    error instanceof DOMException && error.name === "AbortError"
    ? "Timeout na consulta de CPF"
    : `Erro: ${(error as Error).message}`;

    return jsonResponse({ erro: mensagem }, 500);
    }
    },
};

# Criar KV namespace
npx wrangler kv:namespace create CPF_CACHE

# O comando retorna o ID -- adicione ao wrangler.toml

# Definir segredo
npx wrangler secret put CPFHUB_API_KEY
# O CLI solicita o valor de forma segura

# Para desenvolvimento local, crie .dev.vars
echo "CPFHUB_API_KEY=sua_chave_aqui" > .dev.vars

# Desenvolvimento local
npx wrangler dev

# Deploy para producao
npx wrangler deploy

curl http://localhost:8787/cpf/12345678901

// Implementacao de rate limiting no proprio Worker
async function verificarRateLimit(
    request: Request,
    env: Env
): Promise<boolean> {
    const ip = request.headers.get("CF-Connecting-IP") ?? "unknown";
    const rateLimitKey = `ratelimit:${ip}`;
    const contagem = parseInt(
    (await env.CPF_CACHE.get(rateLimitKey)) ?? "0"
    );

    if (contagem >= 10) {
    return false; // Limite excedido
    }

    await env.CPF_CACHE.put(rateLimitKey, String(contagem + 1), {
    expirationTtl: 60, // Reset a cada 60 segundos
    });

    return true;
}