Como integrar validação de CPF em microserviços Go com Gin framework

mkdir cpf-service && cd cpf-service
go mod init cpf-service
go get github.com/gin-gonic/gin

cpf-service/
    main.go
    handlers/
    cpf_handler.go
    services/
    cpf_service.go
    models/
    cpf.go
    middleware/
    rate_limiter.go

// models/cpf.go
package models

type CpfResponse struct {
    Success bool `json:"success"`
    Data CpfData `json:"data"`
}

type CpfData struct {
    Cpf string `json:"cpf"`
    Name string `json:"name"`
    NameUpper string `json:"nameUpper"`
    Gender string `json:"gender"`
    BirthDate string `json:"birthDate"`
    Day int `json:"day"`
    Month int `json:"month"`
    Year int `json:"year"`
}

type ErrorResponse struct {
    Error string `json:"error"`
    Code int `json:"code"`
}

// services/cpf_service.go
package services

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "regexp"
    "time"

    "cpf-service/models"
)

type CpfService struct {
    httpClient *http.Client
    apiKey string
    baseURL string
}

func NewCpfService(apiKey string) *CpfService {
    return &CpfService{
    httpClient: &http.Client{
    Timeout: 10 * time.Second,
    },
    apiKey: apiKey,
    baseURL: "https://api.cpfhub.io",
    }
}

func (s *CpfService) Consultar(ctx context.Context, cpf string) (*models.CpfData, error) {
    re := regexp.MustCompile(`\D`)
    cpfLimpo := re.ReplaceAllString(cpf, "")

    if len(cpfLimpo) != 11 {
    return nil, fmt.Errorf("CPF inválido: informe 11 dígitos numéricos")
    }

    url := fmt.Sprintf("%s/cpf/%s", s.baseURL, cpfLimpo)

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
    return nil, fmt.Errorf("erro ao criar requisição: %w", err)
    }

    req.Header.Set("x-api-key", s.apiKey)
    req.Header.Set("Accept", "application/json")

    resp, err := s.httpClient.Do(req)
    if err != nil {
    if ctx.Err() == context.DeadlineExceeded {
    return nil, fmt.Errorf("tempo limite excedido")
    }
    return nil, fmt.Errorf("erro na requisição: %w", err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
    return nil, fmt.Errorf("erro ao ler resposta: %w", err)
    }

    if resp.StatusCode != http.StatusOK {
    return nil, fmt.Errorf("erro HTTP %d", resp.StatusCode)
    }

    var cpfResp models.CpfResponse
    if err := json.Unmarshal(body, &cpfResp); err != nil {
    return nil, fmt.Errorf("erro ao decodificar resposta: %w", err)
    }

    if !cpfResp.Success {
    return nil, fmt.Errorf("CPF não encontrado")
    }

    return &cpfResp.Data, nil
}

// handlers/cpf_handler.go
package handlers

import (
    "net/http"

    "cpf-service/models"
    "cpf-service/services"
    "github.com/gin-gonic/gin"
)

type CpfHandler struct {
    service *services.CpfService
}

func NewCpfHandler(service *services.CpfService) *CpfHandler {
    return &CpfHandler{service: service}
}

func (h *CpfHandler) Consultar(c *gin.Context) {
    cpf := c.Param("cpf")

    if cpf == "" {
    c.JSON(http.StatusBadRequest, models.ErrorResponse{
    Error: "CPF não informado.",
    Code: 400,
    })
    return
    }

    dados, err := h.service.Consultar(c.Request.Context(), cpf)
    if err != nil {
    status := http.StatusInternalServerError
    if err.Error() == "CPF inválido: informe 11 dígitos numéricos" {
    status = http.StatusBadRequest
    } else if err.Error() == "CPF não encontrado" {
    status = http.StatusNotFound
    } else if err.Error() == "tempo limite excedido" {
    status = http.StatusGatewayTimeout
    }

    c.JSON(status, models.ErrorResponse{
    Error: err.Error(),
    Code: status,
    })
    return
    }

    c.JSON(http.StatusOK, gin.H{
    "valido": true,
    "dados": dados,
    })
}

// middleware/rate_limiter.go
package middleware

import (
    "net/http"
    "sync"
    "time"

    "github.com/gin-gonic/gin"
)

type RateLimiter struct {
    mu sync.Mutex
    lastCall time.Time
    interval time.Duration
}

func NewRateLimiter(interval time.Duration) *RateLimiter {
    return &RateLimiter{
    interval: interval,
    }
}

func (rl *RateLimiter) Middleware() gin.HandlerFunc {
    return func(c *gin.Context) {
    rl.mu.Lock()
    elapsed := time.Since(rl.lastCall)
    if elapsed < rl.interval {
    rl.mu.Unlock()
    c.JSON(http.StatusTooManyRequests, gin.H{
    "error": "Aguarde antes de realizar uma nova consulta.",
    })
    c.Abort()
    return
    }
    rl.lastCall = time.Now()
    rl.mu.Unlock()
    c.Next()
    }
}

// main.go
package main

import (
    "log"
    "os"
    "time"

    "cpf-service/handlers"
    "cpf-service/middleware"
    "cpf-service/services"
    "github.com/gin-gonic/gin"
)

func main() {
    apiKey := os.Getenv("CPFHUB_API_KEY")
    if apiKey == "" {
    apiKey = "SUA_CHAVE_DE_API"
    }

    cpfService := services.NewCpfService(apiKey)
    cpfHandler := handlers.NewCpfHandler(cpfService)
    rateLimiter := middleware.NewRateLimiter(2 * time.Second)

    r := gin.Default()

    api := r.Group("/api")
    {
    cpf := api.Group("/cpf")
    cpf.Use(rateLimiter.Middleware())
    {
    cpf.GET("/:cpf", cpfHandler.Consultar)
    }
    }

    r.GET("/health", func(c *gin.Context) {
    c.JSON(200, gin.H{"status": "ok"})
    })

    log.Println("Servidor iniciado na porta 8080")
    if err := r.Run(":8080"); err != nil {
    log.Fatalf("Erro ao iniciar servidor: %v", err)
    }
}

# Iniciar o servidor
CPFHUB_API_KEY=SUA_CHAVE_DE_API go run main.go

# Em outro terminal, consultar CPF
curl -X GET http://localhost:8080/api/cpf/12345678900 \
    -H "Accept: application/json" \
    --max-time 10

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