Como integrar validação de CPF em apps iOS com Swift e URLSession

struct CpfResponse: Codable {
    let success: Bool
    let data: CpfData?
}

struct CpfData: Codable {
    let cpf: String
    let name: String
    let nameUpper: String
    let gender: String
    let birthDate: String
    let day: Int
    let month: Int
    let year: Int
}

{
    "success": true,
    "data": {
    "cpf": "12345678900",
    "name": "João da Silva",
    "nameUpper": "JOÃO DA SILVA",
    "gender": "M",
    "birthDate": "15/06/1990",
    "day": 15,
    "month": 6,
    "year": 1990
    }
}

import Foundation

enum CpfServiceError: Error, LocalizedError {
    case cpfInvalido
    case chaveNaoConfigurada
    case erroHTTP(statusCode: Int)
    case timeout
    case respostInvalida
    case cpfNaoEncontrado

    var errorDescription: String? {
    switch self {
    case .cpfInvalido:
    return "CPF inválido. Informe 11 dígitos numéricos."
    case .chaveNaoConfigurada:
    return "Chave de API não configurada."
    case .erroHTTP(let code):
    return "Erro HTTP: \(code)"
    case .timeout:
    return "A requisição excedeu o tempo limite."
    case .respostInvalida:
    return "Resposta inválida da API."
    case .cpfNaoEncontrado:
    return "CPF não encontrado na base de dados."
    }
    }
}

class CpfService {

    private let apiKey: String
    private let baseURL = "https://api.cpfhub.io/cpf/"
    private let session: URLSession

    init(apiKey: String) {
    self.apiKey = apiKey

    let config = URLSessionConfiguration.default
    config.timeoutIntervalForRequest = 10
    config.timeoutIntervalForResource = 15
    self.session = URLSession(configuration: config)
    }

    func consultarCpf(_ cpf: String) async throws -> CpfData {
    let cpfLimpo = cpf.replacingOccurrences(
    of: "[^0-9]", with: "", options: .regularExpression
    )

    guard cpfLimpo.count == 11 else {
    throw CpfServiceError.cpfInvalido
    }

    guard !apiKey.isEmpty else {
    throw CpfServiceError.chaveNaoConfigurada
    }

    guard let url = URL(string: "\(baseURL)\(cpfLimpo)") else {
    throw CpfServiceError.cpfInvalido
    }

    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
    request.setValue("application/json", forHTTPHeaderField: "Accept")

    do {
    let (data, response) = try await session.data(for: request)

    guard let httpResponse = response as? HTTPURLResponse else {
    throw CpfServiceError.respostInvalida
    }

    switch httpResponse.statusCode {
    case 200:
    let cpfResponse = try JSONDecoder().decode(
    CpfResponse.self, from: data
    )
    guard cpfResponse.success, let cpfData = cpfResponse.data else {
    throw CpfServiceError.cpfNaoEncontrado
    }
    return cpfData
    default:
    throw CpfServiceError.erroHTTP(
    statusCode: httpResponse.statusCode
    )
    }
    } catch let error as URLError where error.code == .timedOut {
    throw CpfServiceError.timeout
    }
    }
}

import SwiftUI

@MainActor
class CpfViewModel: ObservableObject {

    @Published var cpfInput: String = ""
    @Published var resultado: CpfData?
    @Published var erro: String?
    @Published var carregando: Bool = false

    private let service: CpfService

    init() {
    self.service = CpfService(apiKey: "SUA_CHAVE_DE_API")
    }

    func consultar() {
    erro = nil
    resultado = nil
    carregando = true

    Task {
    do {
    let dados = try await service.consultarCpf(cpfInput)
    self.resultado = dados
    } catch {
    self.erro = error.localizedDescription
    }
    self.carregando = false
    }
    }
}

struct ConsultaCpfView: View {

    @StateObject private var viewModel = CpfViewModel()

    var body: some View {
    NavigationView {
    VStack(spacing: 20) {
    TextField("CPF (somente números)", text: $viewModel.cpfInput)
    .keyboardType(.numberPad)
    .textFieldStyle(.roundedBorder)
    .padding(.horizontal)

    Button(action: { viewModel.consultar() }) {
    Text(viewModel.carregando ? "Consultando..." : "Consultar")
    .frame(maxWidth: .infinity)
    }
    .buttonStyle(.borderedProminent)
    .disabled(viewModel.carregando)
    .padding(.horizontal)

    if let dados = viewModel.resultado {
    VStack(alignment: .leading, spacing: 8) {
    Text("Nome: \(dados.name)")
    Text("CPF: \(dados.cpf)")
    Text("Nascimento: \(dados.birthDate)")
    Text("Gênero: \(dados.gender)")
    }
    .padding()
    }

    if let erro = viewModel.erro {
    Text(erro)
    .foregroundColor(.red)
    .padding()
    }

    Spacer()
    }
    .navigationTitle("Validação de CPF")
    }
    }
}

curl -X GET https://api.cpfhub.io/cpf/12345678900 \
    -H "x-api-key: SUA_CHAVE_DE_API" \
    -H "Accept: application/json" \
    --max-time 10