Como consumir API de CPF em Scala com Play Framework e Akka HTTP

// build.sbt
name := "cpf-validator"
version := "1.0"
scalaVersion := "2.13.12"

libraryDependencies ++= Seq(
    guice,
    ws,
    "com.typesafe.play" %% "play-json" % "2.10.0",
)

# conf/application.conf
cpfhub {
    base-url = "https://api.cpfhub.io"
    api-key = "SUA_CHAVE_DE_API"
    api-key = ${?CPFHUB_API_KEY}
    timeout = 5 seconds
}

play.ws.timeout.request = 5s
play.ws.timeout.connection = 3s

// app/models/CpfModels.scala
package models

import play.api.libs.json._

case class CpfData(
    cpf: String,
    name: String,
    nameUpper: String,
    gender: String,
    birthDate: String,
    day: Int,
    month: Int,
    year: Int
)

object CpfData {
    implicit val reads: Reads[CpfData] = Json.reads[CpfData]
    implicit val writes: Writes[CpfData] = Json.writes[CpfData]
}

case class CpfResponse(
    success: Boolean,
    data: Option[CpfData]
)

object CpfResponse {
    implicit val reads: Reads[CpfResponse] = Json.reads[CpfResponse]
}

sealed trait CpfError {
    def message: String
    def statusCode: Int
}

object CpfError {
    case class InvalidCpf(message: String = "CPF deve conter 11 dígitos") extends CpfError { val statusCode = 400 }
    case class NotFound(message: String = "CPF não encontrado") extends CpfError { val statusCode = 404 }
    case class Unauthorized(message: String = "Chave de API inválida") extends CpfError { val statusCode = 401 }
    case class Timeout(message: String = "Timeout na consulta") extends CpfError { val statusCode = 504 }
    case class ApiError(message: String, statusCode: Int) extends CpfError
}

// app/services/CpfHubService.scala
package services

import javax.inject._
import scala.concurrent.{ExecutionContext, Future}
import scala.concurrent.duration._
import play.api.libs.ws._
import play.api.{Configuration, Logger}
import models._

@Singleton
class CpfHubService @Inject()(
    ws: WSClient,
    config: Configuration
)(implicit ec: ExecutionContext) {

    private val logger = Logger(getClass)
    private val baseUrl = config.get[String]("cpfhub.base-url")
    private val apiKey = config.get[String]("cpfhub.api-key")
    private val timeout = config.get[Duration]("cpfhub.timeout")

    def consultarCpf(cpf: String): Future[Either[CpfError, CpfData]] = {
    val cpfLimpo = cpf.replaceAll("\\D", "")

    if (cpfLimpo.length != 11) {
    return Future.successful(Left(CpfError.InvalidCpf()))
    }

    val url = s"$baseUrl/cpf/$cpfLimpo"

    logger.info(s"Consultando CPF: $cpfLimpo")

    ws.url(url)
    .addHttpHeaders(
    "x-api-key" -> apiKey,
    "Accept" -> "application/json"
    )
    .withRequestTimeout(timeout)
    .get()
    .map { response =>
    response.status match {
    case 200 =>
    response.json.validate[CpfResponse] match {
    case JsSuccess(cpfResponse, _) if cpfResponse.success =>
    cpfResponse.data match {
    case Some(data) =>
    logger.info(s"CPF encontrado: ${data.name}")
    Right(data)
    case None =>
    Left(CpfError.ApiError("Resposta sem dados", 500))
    }
    case _ =>
    Left(CpfError.ApiError("Resposta inválida da API", 500))
    }
    case 400 => Left(CpfError.InvalidCpf("CPF com formato inválido"))
    case 401 => Left(CpfError.Unauthorized())
    case 404 => Left(CpfError.NotFound())
    case other => Left(CpfError.ApiError(s"Erro HTTP $other", other))
    }
    }
    .recover {
    case _: scala.concurrent.TimeoutException =>
    logger.error("Timeout ao consultar CPF")
    Left(CpfError.Timeout())
    case ex: Exception =>
    logger.error(s"Erro na consulta: ${ex.getMessage}")
    Left(CpfError.ApiError(ex.getMessage, 502))
    }
    }
}

// app/controllers/CpfController.scala
package controllers

import javax.inject._
import scala.concurrent.ExecutionContext
import play.api.mvc._
import play.api.libs.json._
import services.CpfHubService
import models.CpfData

@Singleton
class CpfController @Inject()(
    cc: ControllerComponents,
    cpfService: CpfHubService
)(implicit ec: ExecutionContext) extends AbstractController(cc) {

    def consultar(cpf: String): Action[AnyContent] = Action.async {
    cpfService.consultarCpf(cpf).map {
    case Right(data) =>
    Ok(Json.obj(
    "success" -> true,
    "data" -> Json.toJson(data)
    ))
    case Left(error) =>
    Status(error.statusCode)(Json.obj(
    "success" -> false,
    "error" -> error.message
    ))
    }
    }
}

# conf/routes
GET /api/cpf/:cpf controllers.CpfController.consultar(cpf: String)

// src/main/scala/CpfHubAkka.scala
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import akka.http.scaladsl.model.headers.RawHeader
import akka.http.scaladsl.unmarshalling.Unmarshal
import spray.json._
import scala.concurrent.{ExecutionContext, Future}
import scala.concurrent.duration._

object CpfHubAkka {
    implicit val system: ActorSystem = ActorSystem("cpfhub")
    implicit val ec: ExecutionContext = system.dispatcher

    case class CpfData(cpf: String, name: String, gender: String, birthDate: String)

    object CpfJsonProtocol extends DefaultJsonProtocol {
    implicit val cpfDataFormat: RootJsonFormat[CpfData] = jsonFormat4(CpfData)
    }

    def consultarCpf(cpf: String, apiKey: String): Future[CpfData] = {
    val cpfLimpo = cpf.replaceAll("\\D", "")
    val request = HttpRequest(
    method = HttpMethods.GET,
    uri = s"https://api.cpfhub.io/cpf/$cpfLimpo",
    headers = List(
    RawHeader("x-api-key", apiKey),
    RawHeader("Accept", "application/json")
    )
    )

    Http().singleRequest(request).flatMap { response =>
    Unmarshal(response.entity).to[String].map { body =>
    import CpfJsonProtocol._
    val json = body.parseJson.asJsObject
    val data = json.fields("data").convertTo[CpfData]
    data
    }
    }
    }
}