Como criar um microsserviço de validação de CPF com Elixir e Phoenix

# Criação do projeto
# mix phx.new cpf_service --no-html --no-assets --no-dashboard --no-mailer

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

defmodule CpfService.Cpf do
    alias CpfService.Cpf.{Validator, ApiClient}

    def validar(cpf) do
    cpf_limpo = limpar_cpf(cpf)

    with :ok <- Validator.validar_formato(cpf_limpo),
    :ok <- Validator.validar_digitos(cpf_limpo) do
    {:ok, %{cpf: cpf_limpo, formato_valido: true, mensagem: "CPF válido"}}
    end
    end

    def consultar(cpf) do
    cpf_limpo = limpar_cpf(cpf)

    with :ok <- Validator.validar_formato(cpf_limpo),
    :ok <- Validator.validar_digitos(cpf_limpo),
    {:ok, dados} <- ApiClient.consultar(cpf_limpo) do
    {:ok, %{
    cpf: cpf_limpo,
    nome: dados["name"],
    nome_upper: dados["nameUpper"],
    genero: dados["gender"],
    data_nascimento: dados["birthDate"],
    dia: dados["day"],
    mes: dados["month"],
    ano: dados["year"]
    }}
    end
    end

    defp limpar_cpf(cpf), do: String.replace(cpf, ~r/\D/, "")
end

defmodule CpfService.Cpf.Validator do
    def validar_formato(cpf) when byte_size(cpf) != 11, do: {:error, :formato_invalido}
    def validar_formato(_cpf), do: :ok

    def 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_invalidos}
    end
    end
    end

    defp calcular_digito(digitos, count, peso) do
    soma = digitos |> Enum.take(count) |> Enum.with_index()
    |> Enum.reduce(0, fn {d, i}, acc -> acc + d * (peso - i) end)
    resto = rem(soma, 11)
    if resto < 2, do: 0, else: 11 - resto
    end
end

defmodule CpfService.Cpf.ApiClient do
    use Tesla

    plug Tesla.Middleware.BaseUrl, "https://api.cpfhub.io"
    plug Tesla.Middleware.JSON
    plug Tesla.Middleware.Timeout, timeout: 10_000
    plug Tesla.Middleware.Retry, delay: 500, max_retries: 2

    def consultar(cpf) do
    api_key = Application.get_env(:cpf_service, :cpfhub_api_key)
    headers = [{"x-api-key", api_key}]

    case get("/cpf/#{cpf}", headers: headers) do
    {:ok, %{status: 200, body: %{"success" => true, "data" => data}}} ->
    {:ok, data}

    {:ok, %{status: 404}} ->
    {:error, :nao_encontrado}

    {:ok, %{status: 401}} ->
    {:error, :nao_autorizado}

    {:ok, %{status: status}} ->
    {:error, {:status_inesperado, status}}

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

defmodule CpfServiceWeb.Router do
    use CpfServiceWeb, :router

    pipeline :api do
    plug :accepts, ["json"]
    end

    scope "/api", CpfServiceWeb do
    pipe_through :api

    get "/cpf/validar/:cpf", CpfController, :validar
    get "/cpf/consultar/:cpf", CpfController, :consultar
    get "/health", HealthController, :check
    end
end

defmodule CpfServiceWeb.CpfController do
    use CpfServiceWeb, :controller

    alias CpfService.Cpf

    def validar(conn, %{"cpf" => cpf}) do
    case Cpf.validar(cpf) do
    {:ok, resultado} ->
    json(conn, %{success: true, data: resultado})

    {:error, reason} ->
    conn
    |> put_status(:bad_request)
    |> json(%{success: false, error: to_string(reason)})
    end
    end

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

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

    {:error, :nao_autorizado} ->
    conn |> put_status(:unauthorized) |> json(%{success: false, error: "Chave inválida"})

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

defmodule CpfServiceWeb.HealthController do
    use CpfServiceWeb, :controller

    def check(conn, _params) do
    json(conn, %{
    status: "ok",
    service: "cpf-service",
    timestamp: DateTime.utc_now() |> DateTime.to_iso8601(),
    version: Application.spec(:cpf_service, :vsn) |> to_string()
    })
    end
end

# Dockerfile
# Utilize a imagem oficial do Elixir
# FROM elixir:1.16-alpine AS builder

# Configuração de release no mix.exs
def project do
    [
    app: :cpf_service,
    version: "1.0.0",
    elixir: "~> 1.16",
    releases: [
    cpf_service: [
    include_executables_for: [:unix],
    applications: [runtime_tools: :permanent]
    ]
    ]
    ]
end

# config/runtime.exs
import Config

config :cpf_service, CpfServiceWeb.Endpoint,
    url: [host: System.get_env("PHX_HOST") || "localhost"],
    http: [port: String.to_integer(System.get_env("PORT") || "4000")],
    server: true

config :cpf_service, :cpfhub_api_key, System.get_env("CPFHUB_API_KEY")