Camadas Handler-Service-Repository

// porta do repository
type UserRepo interface {
    ByEmail(ctx context.Context, email string) (User, error)
    Insert(ctx context.Context, u User) error
}
 
// service
func (s *Service) Register(ctx context.Context, email string) error { /* regras */ }
 
// handler
func (h *Handler) Register(w http.ResponseWriter, r *http.Request) { /* decodificar, chamar service, responder */ }

// internal/user/repo.go
package user
 
import (
    "context"
    "time"
)
 
type User struct {
    ID        int64
    Email     string
    CreatedAt time.Time
}
 
type Repository interface {
    FindByEmail(ctx context.Context, email string) (User, error)
    Create(ctx context.Context, u User) error
}

// internal/user/service.go
package user
 
import (
    "context"
    "errors"
    "fmt"
    "strings"
    "time"
)
 
var (
    ErrInvalidEmail = errors.New("user: invalid email")
    ErrExists       = errors.New("user: email already registered")
)
 
type Service struct {
    repo Repository
    now  func() time.Time
}
 
func NewService(repo Repository) *Service {
    return &Service{repo: repo, now: time.Now}
}
 
func (s *Service) Register(ctx context.Context, email string) error {
    email = strings.TrimSpace(strings.ToLower(email))
    if !strings.Contains(email, "@") {
        return ErrInvalidEmail
    }
    if _, err := s.repo.FindByEmail(ctx, email); err == nil {
        return ErrExists
    }
    u := User{Email: email, CreatedAt: s.now()}
    if err := s.repo.Create(ctx, u); err != nil {
        return fmt.Errorf("register: %w", err)
    }
    return nil
}

// internal/user/postgres.go
package user
 
import (
    "context"
    "database/sql"
    "errors"
)
 
type PG struct {
    db *sql.DB
}
 
func (p *PG) FindByEmail(ctx context.Context, email string) (User, error) {
    var u User
    err := p.db.QueryRowContext(ctx,
        `SELECT id, email, created_at FROM users WHERE email=$1`, email,
    ).Scan(&u.ID, &u.Email, &u.CreatedAt)
    if errors.Is(err, sql.ErrNoRows) {
        return User{}, err
    }
    return u, err
}
 
func (p *PG) Create(ctx context.Context, u User) error {
    _, err := p.db.ExecContext(ctx,
        `INSERT INTO users (email, created_at) VALUES ($1,$2)`, u.Email, u.CreatedAt,
    )
    return err
}

// internal/user/http.go
package user
 
import (
    "encoding/json"
    "errors"
    "net/http"
)
 
type Handler struct {
    svc *Service
}
 
func NewHandler(svc *Service) *Handler {
    return &Handler{svc: svc}
}
 
func (h *Handler) Register(w http.ResponseWriter, r *http.Request) {
    var in struct {
        Email string `json:"email"`
    }
    if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
        http.Error(w, "invalid json", http.StatusBadRequest)
        return
    }
    err := h.svc.Register(r.Context(), in.Email)
    if err != nil {
        switch {
        case errors.Is(err, ErrInvalidEmail):
            http.Error(w, err.Error(), http.StatusBadRequest)
        case errors.Is(err, ErrExists):
            http.Error(w, err.Error(), http.StatusConflict)
        default:
            http.Error(w, "server error", http.StatusInternalServerError)
        }
        return
    }
    w.WriteHeader(http.StatusCreated)
}

// cmd/api/main.go
package main
 
import (
    "database/sql"
    "log"
    "net/http"
 
    _ "github.com/jackc/pgx/v5/stdlib"
 
    "example.com/app/internal/user"
)
 
func main() {
    db, err := sql.Open("pgx", "postgres://localhost/app?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    repo := &user.PG{db: db}
    svc := user.NewService(repo)
    h := user.NewHandler(svc)
 
    mux := http.NewServeMux()
    mux.HandleFunc("POST /users", h.Register)
    log.Fatal(http.ListenAndServe(":8080", mux))
}

// Repositório falso para testes de serviço
type memRepo struct {
    byEmail map[string]User
}
 
func (m *memRepo) FindByEmail(ctx context.Context, email string) (User, error) {
    u, ok := m.byEmail[email]
    if !ok {
        return User{}, errors.New("not found")
    }
    return u, nil
}