7. Валидация входных данных

package domain

import (
    "errors"
    "fmt"
    "regexp"
)

var ErrInvalidInput = errors.New("invalid input")

type CreateUserRequest struct {
    Email    string `json:"email"`
    Password string `json:"password"`
    Age      int    `json:"age"`
}

func (r *CreateUserRequest) Validate() error {
    var errs []error

    if r.Email == "" {
        errs = append(errs, errors.New("email is required"))
    } else if !isValidEmail(r.Email) {
        errs = append(errs, errors.New("invalid email format"))
    }

    if len(r.Password) < 8 {
        errs = append(errs, errors.New("password must be at least 8 characters"))
    }

    if r.Age < 18 || r.Age > 120 {
        errs = append(errs, errors.New("age must be between 18 and 120"))
    }

    if len(errs) > 0 {
        return fmt.Errorf("%w: %v", ErrInvalidInput, errs)
    }
    return nil
}

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

func isValidEmail(email string) bool {
    return emailRegex.MatchString(email)
}

import "github.com/go-playground/validator/v10"

type CreateUserRequest struct {
    Email    string `json:"email" validate:"required,email"`
    Password string `json:"password" validate:"required,min=8,max=64"`
    Age      int    `json:"age" validate:"required,gte=18,lte=120"`
}

var validate = validator.New()

func (r *CreateUserRequest) Validate() error {
    if err := validate.Struct(r); err != nil {
        // Преобразование ошибок валидации в читаемый вид
        var ve validator.ValidationErrors
        if errors.As(err, &ve) {
            return formatValidationErrors(ve)
        }
        return err
    }
    return nil
}

func formatValidationErrors(ve validator.ValidationErrors) error {
    msgs := make([]string, 0, len(ve))
    for _, e := range ve {
        msgs = append(msgs, fmt.Sprintf("%s: %s failed on %s", e.Field(), e.Value(), e.Tag()))
    }
    return fmt.Errorf("validation failed: %v", msgs)
}

type ValidationError struct {
    Field   string `json:"field"`
    Message string `json:"message"`
}

type ErrorResponse struct {
    Error   string            `json:"error"`
    Details []ValidationError `json:"details,omitempty"`
}

func writeValidationErrors(w http.ResponseWriter, err error) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusBadRequest)

    var details []ValidationError
    var ve validator.ValidationErrors

    if errors.As(err, &ve) {
        details = make([]ValidationError, 0, len(ve))
        for _, e := range ve {
            details = append(details, ValidationError{
                Field:   e.Field(),
                Message: translateTag(e.Tag()),
            })
        }
    } else {
        details = []ValidationError{{Field: "body", Message: err.Error()}}
    }

    json.NewEncoder(w).Encode(ErrorResponse{
        Error:   "validation_failed",
        Details: details,
    })
}

func translateTag(tag string) string {
    tags := map[string]string{
        "required": "поле обязательно",
        "email":    "неверный формат email",
        "min":      "значение меньше допустимого",
        "gte":      "значение меньше минимального",
    }
    if msg, ok := tags[tag]; ok {
        return msg
    }
    return "неверное значение"
}

func createUserHandler(w http.ResponseWriter, r *http.Request) {
    // 1. Декодирование
    var req CreateUserRequest
    decoder := json.NewDecoder(r.Body)
    decoder.DisallowUnknownFields() // Защита от лишних полей
    if err := decoder.Decode(&req); err != nil {
        http.Error(w, "invalid json payload", http.StatusBadRequest)
        return
    }

    // 2. Валидация
    if err := req.Validate(); err != nil {
        writeValidationErrors(w, err)
        return
    }

    // 3. Бизнес-логика
    user, err := userService.Create(r.Context(), &req)
    if err != nil {
        http.Error(w, "failed to create user", http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func maxBodySize(next http.Handler, limit int64) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        r.Body = http.MaxBytesReader(w, r.Body, limit)
        next.ServeHTTP(w, r)
    })
}

// Использование
mux.Handle("/api/users", maxBodySize(createUserHandler, 1<<20)) // 1MB