Como validar CPF em tempo real usando Elixir e APIs REST

defmodule CpfValidator do
    @moduledoc """
    Módulo para validação algorítmica de CPF.
    """

    @doc """
    Valida os dígitos verificadores de um CPF.
    """
    def validar(cpf) when is_binary(cpf) do
    cpf
    |> String.replace(~r/\D/, "")
    |> validar_digitos()
    end

    defp validar_digitos(cpf) when byte_size(cpf) != 11, do: {:error, :tamanho_invalido}

    defp validar_digitos(cpf) do
    digitos = cpf |> String.graphemes() |> Enum.map(&String.to_integer/1)

    if Enum.uniq(digitos) |> length() == 1 do
    {:error, :digitos_repetidos}
    else
    d1 = calcular_digito(digitos, 9, 10)
    d2 = calcular_digito(digitos, 10, 11)

    if Enum.at(digitos, 9) == d1 and Enum.at(digitos, 10) == d2 do
    :ok
    else
    {:error, :digitos_verificadores_invalidos}
    end
    end
    end

    defp calcular_digito(digitos, count, peso_inicial) do
    soma =
    digitos
    |> Enum.take(count)
    |> Enum.with_index()
    |> Enum.reduce(0, fn {d, i}, acc -> acc + d * (peso_inicial - i) end)

    resto = rem(soma, 11)
    if resto < 2, do: 0, else: 11 - resto
    end
end

defmodule CpfValidationService do
    @moduledoc """
    Serviço de validação de CPF em tempo real com consulta à API.
    """

    alias CpfValidator

    @base_url "https://api.cpfhub.io"

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

    with :ok <- CpfValidator.validar(cpf_limpo),
    {:ok, dados} <- consultar_api(cpf_limpo, api_key) do
    {:ok, %{
    formato_valido: true,
    encontrado: true,
    nome: dados["name"],
    data_nascimento: dados["birthDate"],
    genero: dados["gender"],
    mensagem: "CPF válido e encontrado na base"
    }}
    else
    {:error, :tamanho_invalido} ->
    {:error, %{formato_valido: false, mensagem: "CPF deve conter 11 dígitos"}}

    {:error, :digitos_repetidos} ->
    {:error, %{formato_valido: false, mensagem: "CPF com dígitos repetidos"}}

    {:error, :digitos_verificadores_invalidos} ->
    {:error, %{formato_valido: false, mensagem: "Dígitos verificadores inválidos"}}

    {:error, :cpf_nao_encontrado} ->
    {:ok, %{
    formato_valido: true,
    encontrado: false,
    nome: nil,
    data_nascimento: nil,
    genero: nil,
    mensagem: "CPF válido, porém não encontrado na base"
    }}

    {:error, reason} ->
    {:error, %{formato_valido: true, mensagem: "Erro: #{inspect(reason)}"}}
    end
    end

    defp consultar_api(cpf, api_key) do
    headers = [{"x-api-key", api_key}]
    url = "#{@base_url}/cpf/#{cpf}"

    case HTTPoison.get(url, headers, recv_timeout: 5000) do
    {:ok, %{status_code: 200, body: body}} ->
    case Jason.decode!(body) do
    %{"success" => true, "data" => data} -> {:ok, data}
    _ -> {:error, :cpf_nao_encontrado}
    end

    {:ok, %{status_code: 404}} ->
    {:error, :cpf_nao_encontrado}

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

defmodule MinhaAppWeb.CpfValidationLive do
    use MinhaAppWeb, :live_view

    def mount(_params, _session, socket) do
    {:ok, assign(socket,
    cpf_input: "",
    validacao_local: nil,
    resultado_api: nil,
    loading: false
    )}
    end

    def handle_event("validar_local", %{"cpf" => cpf}, socket) do
    resultado = CpfValidator.validar(cpf)
    {:noreply, assign(socket, cpf_input: cpf, validacao_local: resultado)}
    end

    def handle_event("consultar_api", %{"cpf" => cpf}, socket) do
    socket = assign(socket, loading: true)
    api_key = Application.get_env(:minha_app, :cpfhub)[:api_key]

    case CpfValidationService.validar_completo(cpf, api_key) do
    {:ok, resultado} ->
    {:noreply, assign(socket, resultado_api: resultado, loading: false)}

    {:error, resultado} ->
    {:noreply, assign(socket, resultado_api: resultado, loading: false)}
    end
    end

    def render(assigns) do
    ~H"""
    <div class="max-w-md mx-auto">
    <h2>Validação de CPF</h2>

    <form phx-change="validar_local" phx-submit="consultar_api">
    <input type="text" name="cpf" value={@cpf_input}
    placeholder="000.000.000-00" maxlength="14"
    class="form-input w-full" />

    <button type="submit" disabled={@loading} class="btn mt-2">
    <%= if @loading, do: "Consultando...", else: "Consultar" %>
    </button>
    </form>

    <%= if @resultado_api do %>
    <div class="mt-4 p-4 border rounded">
    <p><strong>Status:</strong> <%= @resultado_api.mensagem %></p>
    <%= if @resultado_api[:nome] do %>
    <p><strong>Nome:</strong> <%= @resultado_api.nome %></p>
    <p><strong>Nascimento:</strong> <%= @resultado_api.data_nascimento %></p>
    <% end %>
    </div>
    <% end %>
    </div>
    """
    end
end

defmodule CpfCache do
    use GenServer

    @table_name :cpf_cache
    @ttl_seconds 600

    def start_link(_opts) do
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
    end

    def init(_) do
    :ets.new(@table_name, [:named_table, :public, read_concurrency: true])
    {:ok, %{}}
    end

    def get(cpf) do
    case :ets.lookup(@table_name, cpf) do
    [{^cpf, resultado, timestamp}] ->
    if System.system_time(:second) - timestamp < @ttl_seconds do
    {:ok, resultado}
    else
    :ets.delete(@table_name, cpf)
    :miss
    end
    [] -> :miss
    end
    end

    def put(cpf, resultado) do
    :ets.insert(@table_name, {cpf, resultado, System.system_time(:second)})
    :ok
    end
end