Design di package pulito in Go: Singola responsabilità e coesione

package user

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"
    "net/smtp"
)

type UserService struct {
    db *sql.DB
}

// CreateUser inserisce un utente E invia un'email di benvenuto E logga via HTTP.
// Tre motivi per cambiare: schema DB, provider email, endpoint di logging.
func (s *UserService) CreateUser(username, email string) error {
    _, err := s.db.Exec(
        "INSERT INTO users (username, email) VALUES ($1, $2)",
        username, email,
    )
    if err != nil {
        return fmt.Errorf("insert user: %w", err)
    }

    // Responsabilita 2: email
    auth := smtp.PlainAuth("", "robot@example.com", "secret", "smtp.example.com")
    msg := []byte("Subject: Welcome\r\n\r\nWelcome to the platform, " + username)
    if err := smtp.SendMail("smtp.example.com:587", auth, "robot@example.com",
        []string{email}, msg); err != nil {
        return fmt.Errorf("send welcome email: %w", err)
    }

    // Responsabilita 3: audit log via HTTP
    payload, _ := json.Marshal(map[string]string{"event": "user.created", "email": email})
    _, _ = http.Post("https://audit.internal/events", "application/json",
        bytes.NewReader(payload))

    return nil
}

package storage

import (
    "context"
    "database/sql"
    "fmt"
)

type User struct {
    ID       int64
    Username string
    Email    string
}

type UserRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) Create(ctx context.Context, username, email string) (*User, error) {
    var id int64
    err := r.db.QueryRowContext(ctx,
        "INSERT INTO users (username, email) VALUES ($1, $2) RETURNING id",
        username, email,
    ).Scan(&id)
    if err != nil {
        return nil, fmt.Errorf("create user: %w", err)
    }
    return &User{ID: id, Username: username, Email: email}, nil
}

package notification

import (
    "fmt"
    "net/smtp"
)

type SMTPConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    From     string
}

type Service struct {
    cfg SMTPConfig
}

func NewService(cfg SMTPConfig) *Service {
    return &Service{cfg: cfg}
}

func (s *Service) SendWelcome(toEmail, username string) error {
    addr := fmt.Sprintf("%s:%d", s.cfg.Host, s.cfg.Port)
    auth := smtp.PlainAuth("", s.cfg.Username, s.cfg.Password, s.cfg.Host)
    msg := []byte(fmt.Sprintf("Subject: Welcome\r\n\r\nWelcome, %s!", username))
    if err := smtp.SendMail(addr, auth, s.cfg.From, []string{toEmail}, msg); err != nil {
        return fmt.Errorf("send welcome email to %s: %w", toEmail, err)
    }
    return nil
}

package user

import (
    "context"
    "fmt"

    "example.com/app/notification"
    "example.com/app/storage"
)

// Notifier è l'interfaccia richiesta da questo package. Non conosce SMTP.
type Notifier interface {
    SendWelcome(email, username string) error
}

// Storer è l'interfaccia richiesta da questo package. Non conosce SQL.
type Storer interface {
    Create(ctx context.Context, username, email string) (*storage.User, error)
}

type Service struct {
    store    Storer
    notifier Notifier
}

func NewService(store Storer, notifier Notifier) *Service {
    return &Service{store: store, notifier: notifier}
}

func (s *Service) Register(ctx context.Context, username, email string) error {
    user, err := s.store.Create(ctx, username, email)
    if err != nil {
        return fmt.Errorf("register: %w", err)
    }
    if err := s.notifier.SendWelcome(user.Email, user.Username); err != nil {
        // Non fatale: l'utente è creato, la notifica è best-effort.
        return fmt.Errorf("register: send welcome: %w", err)
    }
    return nil
}

// Esportato: i consumatori devono chiamare NewUserRepository e usare UserRepository.
type UserRepository struct { /* ... */ }
func NewUserRepository(db *sql.DB) *UserRepository { /* ... */ }
func (r *UserRepository) Create(ctx context.Context, username, email string) (*User, error) { /* ... */ }

// Non esportato: i consumatori non devono sapere come viene costruita la query.
func (r *UserRepository) buildInsertQuery() string { /* ... */ }

// Queste interfacce vivono nel package user, non in storage o notification.
// Il package user definisce il comportamento di cui ha bisogno; storage e notification
// lo implementano senza conoscere il package user.
type Storer interface {
    Create(ctx context.Context, username, email string) (*storage.User, error)
}

type Notifier interface {
    SendWelcome(email, username string) error
}

package user_test

import (
    "context"
    "testing"

    "example.com/app/storage"
    "example.com/app/user"
)

type stubStorer struct{ user *storage.User }
func (s *stubStorer) Create(_ context.Context, username, email string) (*storage.User, error) {
    return &storage.User{ID: 1, Username: username, Email: email}, nil
}

type stubNotifier struct{ called bool }
func (n *stubNotifier) SendWelcome(_, _ string) error { n.called = true; return nil }

func TestRegister_SendsWelcome(t *testing.T) {
    notifier := &stubNotifier{}
    svc := user.NewService(&stubStorer{}, notifier)

    if err := svc.Register(context.Background(), "alice", "alice@example.com"); err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    if !notifier.called {
        t.Fatal("expected welcome notification to be sent")
    }
}