Como Consumir a API de CPF em Kotlin Usando Ktor Client e Retrofit

import kotlinx.serialization.Serializable

@Serializable
data class CPFResponse(
    val success: Boolean,
    val data: CPFData
)

@Serializable
data class CPFData(
    val cpf: String,
    val name: String,
    val nameUpper: String,
    val gender: String,
    val birthDate: String,
    val day: String,
    val month: String,
    val year: String
)

sealed class CPFResult {
    data class Success(val data: CPFData) : CPFResult()
    data class Error(val message: String, val code: Int? = null) : CPFResult()
}

import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json

class CPFServiceKtor(private val apiKey: String) {
    private val client = HttpClient(CIO) {
    install(ContentNegotiation) {
    json(Json {
    ignoreUnknownKeys = true
    isLenient = true
    })
    }
    install(HttpTimeout) {
    requestTimeoutMillis = 15_000
    connectTimeoutMillis = 10_000
    }
    defaultRequest {
    header("x-api-key", apiKey)
    }
    }

    suspend fun consultarCPF(cpf: String): CPFResult {
    val cpfLimpo = cpf.replace(Regex("[^0-9]"), "")

    if (cpfLimpo.length != 11) {
    return CPFResult.Error("CPF deve conter 11 dígitos")
    }

    return try {
    val response: CPFResponse = client.get(
    "https://api.cpfhub.io/cpf/$cpfLimpo"
    ).body()

    if (response.success) {
    CPFResult.Success(response.data)
    } else {
    CPFResult.Error("CPF não encontrado")
    }
    } catch (e: ClientRequestException) {
    CPFResult.Error("Erro do cliente: ${e.response.status}", e.response.status.value)
    } catch (e: ServerResponseException) {
    CPFResult.Error("Erro do servidor: ${e.response.status}", e.response.status.value)
    } catch (e: Exception) {
    CPFResult.Error("Erro de conexão: ${e.message}")
    }
    }

    fun close() {
    client.close()
    }
}

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Path
import retrofit2.Response
import okhttp3.OkHttpClient
import okhttp3.Interceptor
import java.util.concurrent.TimeUnit

interface CPFApi {
    @GET("cpf/{cpf}")
    suspend fun consultarCPF(
    @Path("cpf") cpf: String
    ): Response<CPFResponseRetrofit>
}

data class CPFResponseRetrofit(
    val success: Boolean,
    val data: CPFDataRetrofit
)

data class CPFDataRetrofit(
    val cpf: String,
    val name: String,
    val nameUpper: String,
    val gender: String,
    val birthDate: String,
    val day: String,
    val month: String,
    val year: String
)

class CPFServiceRetrofit(private val apiKey: String) {
    private val authInterceptor = Interceptor { chain ->
    val request = chain.request().newBuilder()
    .addHeader("x-api-key", apiKey)
    .build()
    chain.proceed(request)
    }

    private val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(authInterceptor)
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(15, TimeUnit.SECONDS)
    .build()

    private val api: CPFApi = Retrofit.Builder()
    .baseUrl("https://api.cpfhub.io/")
    .client(okHttpClient)
    .addConverterFactory(GsonConverterFactory.create())
    .build()
    .create(CPFApi::class.java)

    suspend fun consultarCPF(cpf: String): CPFResult {
    val cpfLimpo = cpf.replace(Regex("[^0-9]"), "")

    if (cpfLimpo.length != 11) {
    return CPFResult.Error("CPF deve conter 11 dígitos")
    }

    return try {
    val response = api.consultarCPF(cpfLimpo)
    if (response.isSuccessful && response.body()?.success == true) {
    val body = response.body()!!.data
    CPFResult.Success(CPFData(
    cpf = body.cpf, name = body.name,
    nameUpper = body.nameUpper, gender = body.gender,
    birthDate = body.birthDate, day = body.day,
    month = body.month, year = body.year
    ))
    } else {
    CPFResult.Error("CPF não encontrado", response.code())
    }
    } catch (e: Exception) {
    CPFResult.Error("Erro de conexão: ${e.message}")
    }
    }
}

// Uso unificado com ambas as implementações
suspend fun main() {
    val apiKey = System.getenv("CPFHUB_API_KEY")
    ?: throw IllegalStateException("API key não configurada")

    // Com Ktor
    val servicoKtor = CPFServiceKtor(apiKey)
    when (val resultado = servicoKtor.consultarCPF("12345678909")) {
    is CPFResult.Success -> println("Ktor: ${resultado.data.name}")
    is CPFResult.Error -> println("Ktor erro: ${resultado.message}")
    }
    servicoKtor.close()

    // Com Retrofit
    val servicoRetrofit = CPFServiceRetrofit(apiKey)
    when (val resultado = servicoRetrofit.consultarCPF("12345678909")) {
    is CPFResult.Success -> println("Retrofit: ${resultado.data.name}")
    is CPFResult.Error -> println("Retrofit erro: ${resultado.message}")
    }
}