Como integrar a API de CPF em uma aplicação Phoenix

# mix.exs
defp deps do
    [
    {:phoenix, "~> 1.7"},
    {:phoenix_live_view, "~> 0.20"},
    {:tesla, "~> 1.8"},
    {:hackney, "~> 1.20"},
    {:jason, "~> 1.4"}
    ]
end

# config/config.exs
config :minha_app, :cpfhub,
    base_url: "https://api.cpfhub.io",
    api_key: System.get_env("CPFHUB_API_KEY")

defmodule MinhaApp.Cpf do
    @moduledoc """
    Context para operações relacionadas a CPF.
    """

    alias MinhaApp.Cpf.ApiClient

    def consultar(cpf) do
    cpf_limpo = String.replace(cpf, ~r/\D/, "")

    with :ok <- validar_formato(cpf_limpo),
    {:ok, dados} <- ApiClient.consultar(cpf_limpo) do
    {:ok, dados}
    end
    end

    def validar_formato(cpf) when byte_size(cpf) == 11 do
    digitos = cpf
    |> String.graphemes()
    |> Enum.map(&String.to_integer/1)

    if Enum.uniq(digitos) |> length() == 1 do
    {:error, :digitos_repetidos}
    else
    :ok
    end
    end

    def validar_formato(_cpf), do: {:error, :formato_invalido}
end

defmodule MinhaApp.Cpf.ApiClient do
    use Tesla

    @config Application.compile_env(:minha_app, :cpfhub, [])

    plug Tesla.Middleware.BaseUrl, @config[:base_url] || "https://api.cpfhub.io"
    plug Tesla.Middleware.JSON
    plug Tesla.Middleware.Headers, [{"x-api-key", @config[:api_key] || ""}]
    plug Tesla.Middleware.Timeout, timeout: 10_000
    plug Tesla.Middleware.Retry, delay: 500, max_retries: 2

    def consultar(cpf) do
    case get("/cpf/#{cpf}") do
    {:ok, %Tesla.Env{status: 200, body: %{"success" => true, "data" => data}}} ->
    {:ok, parse_data(data)}

    {:ok, %Tesla.Env{status: 404}} ->
    {:error, :cpf_nao_encontrado}

    {:ok, %Tesla.Env{status: 401}} ->
    {:error, :chave_invalida}

    {:ok, %Tesla.Env{status: status}} ->
    {:error, {:status_inesperado, status}}

    {:error, reason} ->
    {:error, {:falha_conexao, reason}}
    end
    end

    defp parse_data(data) do
    %{
    cpf: data["cpf"],
    nome: data["name"],
    nome_upper: data["nameUpper"],
    genero: data["gender"],
    data_nascimento: data["birthDate"],
    dia: data["day"],
    mes: data["month"],
    ano: data["year"]
    }
    end
end

defmodule MinhaAppWeb.CpfController do
    use MinhaAppWeb, :controller

    alias MinhaApp.Cpf

    def show(conn, %{"cpf" => cpf}) do
    case Cpf.consultar(cpf) do
    {:ok, dados} ->
    conn
    |> put_status(:ok)
    |> json(%{success: true, data: dados})

    {:error, :cpf_nao_encontrado} ->
    conn
    |> put_status(:not_found)
    |> json(%{success: false, message: "CPF não encontrado"})

    {:error, :formato_invalido} ->
    conn
    |> put_status(:bad_request)
    |> json(%{success: false, message: "Formato de CPF inválido"})

    {:error, _reason} ->
    conn
    |> put_status(:bad_gateway)
    |> json(%{success: false, message: "Erro ao consultar API externa"})
    end
    end
end

defmodule MinhaAppWeb.CpfLive do
    use MinhaAppWeb, :live_view

    alias MinhaApp.Cpf

    def mount(_params, _session, socket) do
    {:ok, assign(socket, cpf: "", resultado: nil, loading: false, erro: nil)}
    end

    def handle_event("consultar", %{"cpf" => cpf}, socket) do
    socket = assign(socket, loading: true, erro: nil, resultado: nil)

    case Cpf.consultar(cpf) do
    {:ok, dados} ->
    {:noreply, assign(socket, resultado: dados, loading: false)}

    {:error, reason} ->
    mensagem = mensagem_erro(reason)
    {:noreply, assign(socket, erro: mensagem, loading: false)}
    end
    end

    defp mensagem_erro(:cpf_nao_encontrado), do: "CPF não encontrado na base"
    defp mensagem_erro(:formato_invalido), do: "Formato de CPF inválido"
    defp mensagem_erro(:chave_invalida), do: "Chave de API inválida"
    defp mensagem_erro(_), do: "Erro ao consultar o serviço"
end