Como consumir API de CPF em Bun com runtime ultra-rápido

// src/cpfhub.ts

interface CPFData {
    cpf: string;
    name: string;
    nameUpper: string;
    gender: string;
    birthDate: string;
    day: number;
    month: number;
    year: number;
}

interface CPFApiResponse {
    success: boolean;
    data?: CPFData;
}

const API_URL = "https://api.cpfhub.io/cpf";
const API_KEY = Bun.env.CPFHUB_API_KEY ?? "";
const TIMEOUT_MS = 10000;

export async function consultarCPF(cpf: string): Promise<{
    sucesso: boolean;
    dados?: CPFData;
    erro?: string;
}> {
    const cpfLimpo = cpf.replace(/\D/g, "");

    if (cpfLimpo.length !== 11) {
    return { sucesso: false, erro: "CPF deve conter 11 digitos" };
    }

    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);

    try {
    const response = await fetch(`${API_URL}/${cpfLimpo}`, {
    method: "GET",
    headers: {
    "x-api-key": API_KEY,
    "Accept": "application/json",
    },
    signal: controller.signal,
    });

    clearTimeout(timeoutId);

    if (!response.ok) {
    return { sucesso: false, erro: `Status ${response.status}` };
    }

    const resultado: CPFApiResponse = await response.json();

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

    return { sucesso: true, dados: resultado.data };
    } catch (error) {
    clearTimeout(timeoutId);

    if (error instanceof Error && error.name === "AbortError") {
    return { sucesso: false, erro: "Timeout na consulta" };
    }

    return { sucesso: false, erro: String(error) };
    }
}

// src/server.ts
import { consultarCPF } from "./cpfhub";

const PORT = parseInt(Bun.env.PORT ?? "3000");

function jsonResponse(body: object, status = 200): Response {
    return new Response(JSON.stringify(body), {
    status,
    headers: {
    "Content-Type": "application/json",
    "X-Powered-By": "Bun",
    },
    });
}

const server = Bun.serve({
    port: PORT,

    async fetch(req: Request): Promise<Response> {
    const url = new URL(req.url);
    const inicio = performance.now();

    // Health check
    if (url.pathname === "/health") {
    return jsonResponse({
    status: "ok",
    runtime: "bun",
    version: Bun.version,
    timestamp: new Date().toISOString(),
    });
    }

    // Rota de consulta de CPF
    if (req.method === "GET" && url.pathname.startsWith("/api/cpf/")) {
    const cpf = url.pathname.split("/api/cpf/")[1];

    if (!cpf || cpf.replace(/\D/g, "").length !== 11) {
    return jsonResponse(
    { erro: "CPF invalido. Informe 11 digitos na URL." },
    400
    );
    }

    const resultado = await consultarCPF(cpf);
    const duracao = (performance.now() - inicio).toFixed(2);

    if (!resultado.sucesso) {
    return jsonResponse(
    { erro: resultado.erro, duracaoMs: duracao },
    resultado.erro?.includes("nao encontrado") ? 404 : 500
    );
    }

    return jsonResponse({
    valido: true,
    dados: {
    nome: resultado.dados!.name,
    cpf: resultado.dados!.cpf,
    genero: resultado.dados!.gender,
    dataNascimento: resultado.dados!.birthDate,
    },
    duracaoMs: duracao,
    });
    }

    return jsonResponse({ erro: "Rota nao encontrada" }, 404);
    },

    error(error: Error): Response {
    console.error("Erro no servidor:", error);
    return jsonResponse({ erro: "Erro interno do servidor" }, 500);
    },
});

console.log(`Servidor Bun rodando em http://localhost:${server.port}`);

CPFHUB_API_KEY=sua_chave bun run src/server.ts

// src/cpfhub.test.ts
import { describe, test, expect, mock } from "bun:test";
import { consultarCPF } from "./cpfhub";

describe("consultarCPF", () => {
    test("rejeita CPF com menos de 11 digitos", async () => {
    const resultado = await consultarCPF("12345");
    expect(resultado.sucesso).toBe(false);
    expect(resultado.erro).toBe("CPF deve conter 11 digitos");
    });

    test("remove formatacao do CPF", async () => {
    const resultado = await consultarCPF("123.456.789-01");
    expect(resultado.erro).not.toBe("CPF deve conter 11 digitos");
    });

    test("retorna timeout apos limite", async () => {
    const fetchOriginal = globalThis.fetch;
    globalThis.fetch = mock(() =>
    new Promise((_, reject) => {
    setTimeout(() => reject(new DOMException("Aborted", "AbortError")), 100);
    })
    );

    const resultado = await consultarCPF("12345678901");
    expect(resultado.sucesso).toBe(false);
    expect(resultado.erro).toContain("Timeout");

    globalThis.fetch = fetchOriginal;
    });
});

bun test

FROM oven/bun:1.1 AS base
WORKDIR /app

COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production

COPY src ./src

ENV NODE_ENV=production
EXPOSE 3000

CMD ["bun", "run", "src/server.ts"]