Errors #

package main

import (
    "errors"
    "fmt"
)

// Sentinel errors — error variables defined at the package level
// Convention: names start with "Err"
var (
    ErrNotFound       = errors.New("not found")
    ErrNotAllowed     = errors.New("not allowed")
    ErrInvalidInput   = errors.New("invalid input")
    ErrConnectionIssue = errors.New("connection issue")
)

func findUser(id int) (*User, error) {
    if id <= 0 {
        return nil, ErrInvalidInput
    }
    if id > 1000 {
        return nil, ErrNotFound
    }
    return &User{ID: id, Name: "Budi"}, nil
}

func main() {
    _, err := findUser(-1)

    // Compare with == — ANTI-PATTERN for wrapped errors
    if err == ErrInvalidInput {
        fmt.Println("wrong input") // works but not robust
    }

    // CORRECT: use errors.Is — works even if the error is wrapped
    if errors.Is(err, ErrInvalidInput) {
        fmt.Println("wrong input") // always correct
    }
}

var ErrNotFound = errors.New("not found")

// Repository layer
func repoFindBook(id int) error {
    return ErrNotFound
}

// Service layer — adds context
func serviceFindBook(id int) error {
    if err := repoFindBook(id); err != nil {
        return fmt.Errorf("serviceFindBook %d: %w", id, err)
        // The error is now: "serviceFindBook 42: not found"
    }
    return nil
}

// Handler layer
func handlerFindBook(id int) {
    err := serviceFindBook(id)

    // == doesn't work because the error is already wrapped
    fmt.Println(err == ErrNotFound) // false

    // errors.Is opens all wrapping layers
    fmt.Println(errors.Is(err, ErrNotFound)) // true ✓
}

// %v vs %w comparison
var ErrDB = errors.New("database error")

// With %v — the old error becomes a string, can't be unwrapped
err1 := fmt.Errorf("operation failed: %v", ErrDB)
fmt.Println(errors.Is(err1, ErrDB)) // false ❌

// With %w — the old error is wrapped, can be unwrapped
err2 := fmt.Errorf("operation failed: %w", ErrDB)
fmt.Println(errors.Is(err2, ErrDB)) // true ✓

// Naming convention in error messages
// Format: "functionName arguments: message" or "functionName: message"
func loadConfig(path string) error {
    data, err := os.ReadFile(path)
    if err != nil {
        // Include the path as context — very useful when debugging
        return fmt.Errorf("loadConfig %s: %w", path, err)
    }
    _ = data
    return nil
}

func initializeApp(configPath string) error {
    if err := loadConfig(configPath); err != nil {
        return fmt.Errorf("initializeApp: %w", err)
    }
    return nil
}

// The error formed when called with a wrong path:
// "initializeApp: loadConfig /etc/app.yaml:
//  open /etc/app.yaml: no such file or directory"

var (
    ErrValidation = errors.New("validation failed")
    ErrDB         = errors.New("database error")
)

// Wrap two errors at once with two %w verbs
err := fmt.Errorf("saveData: %w and %w", ErrValidation, ErrDB)
fmt.Println(err)
// saveData: validation failed and database error

fmt.Println(errors.Is(err, ErrValidation)) // true
fmt.Println(errors.Is(err, ErrDB))       // true

// errors.Join — another way to combine several errors (Go 1.20+)
errs := []error{ErrValidation, ErrDB}
joined := errors.Join(errs...)
fmt.Println(joined)
// validation failed
// database error

fmt.Println(errors.Is(joined, ErrValidation)) // true
fmt.Println(errors.Is(joined, ErrDB))       // true

import (
    "errors"
    "io"
    "io/fs"
    "os"
)

// Examples with various error types from the stdlib
func errorsIsExamples() {
    // An error from the os package
    _, err := os.Open("missing.txt")

    // Check with sentinel errors from io/fs
    if errors.Is(err, fs.ErrNotExist) {
        fmt.Println("file doesn't exist")
    }
    if errors.Is(err, fs.ErrPermission) {
        fmt.Println("no permission")
    }

    // EOF — a sentinel error from io
    _, err2 := fmt.Sscan("", new(int))
    if errors.Is(err2, io.EOF) {
        fmt.Println("no data")
    }

    // errors.Is also works with nil
    var errNil error = nil
    fmt.Println(errors.Is(errNil, nil)) // true
}

// A custom Is method — for more flexible comparisons
type HTTPError struct {
    StatusCode int
    Message    string
}

func (e *HTTPError) Error() string {
    return fmt.Sprintf("HTTP %d: %s", e.StatusCode, e.Message)
}

// Implement Is so errors.Is works based on the status code
func (e *HTTPError) Is(target error) bool {
    t, ok := target.(*HTTPError)
    if !ok {
        return false
    }
    // Match if the status code is the same (ignore the message)
    return e.StatusCode == t.StatusCode
}

var ErrNotFoundHTTP = &HTTPError{StatusCode: 404}
var ErrUnauthorizedHTTP = &HTTPError{StatusCode: 401}

func checkResponse(err error) {
    if errors.Is(err, ErrNotFoundHTTP) {
        fmt.Println("resource not found")
    }
    if errors.Is(err, ErrUnauthorizedHTTP) {
        fmt.Println("authentication needed")
    }
}

// errors.As enables access to error details
type ValidationError struct {
    Field   string
    Message string
    Value   any
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed for field %q: %s (value: %v)",
        e.Field, e.Message, e.Value)
}

func validateAge(age int) error {
    if age < 0 {
        return &ValidationError{
            Field:   "age",
            Message: "must not be negative",
            Value:   age,
        }
    }
    if age > 150 {
        return &ValidationError{
            Field:   "age",
            Message: "not realistic",
            Value:   age,
        }
    }
    return nil
}

func processRegistration(age int) error {
    if err := validateAge(age); err != nil {
        return fmt.Errorf("processRegistration: %w", err)
    }
    return nil
}

func main() {
    err := processRegistration(-5)

    // errors.Is isn't enough — we need the field and value details
    // errors.As extracts *ValidationError from inside the wrapping chain
    var errVal *ValidationError
    if errors.As(err, &errVal) {
        // Now we can access the fields of ValidationError
        fmt.Printf("Problem field: %s\n", errVal.Field)
        fmt.Printf("Message: %s\n", errVal.Message)
        fmt.Printf("Sent value: %v\n", errVal.Value)

        // Can create an appropriate HTTP response
        // http.Error(w, errVal.Message, http.StatusBadRequest)
    }
}

// A real example: an HTTP handler with full error handling
func findBookHandler(w http.ResponseWriter, r *http.Request) {
    idStr := r.URL.Query().Get("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        http.Error(w, "invalid ID", http.StatusBadRequest)
        return
    }

    book, err := serviceFindBook(id)
    if err != nil {
        // Check the error type for the right response
        switch {
        case errors.Is(err, ErrNotFound):
            http.Error(w, "Book not found", http.StatusNotFound)

        case errors.Is(err, ErrNotAllowed):
            http.Error(w, "Access denied", http.StatusForbidden)

        default:
            // Check whether there are validation error details
            var errVal *ValidationError
            if errors.As(err, &errVal) {
                http.Error(w,
                    fmt.Sprintf("Invalid input: %s", errVal.Message),
                    http.StatusBadRequest)
                return
            }

            // Unknown error — log and return 500
            log.Printf("unexpected error: %v", err)
            http.Error(w, "Internal server error", http.StatusInternalServerError)
        }
        return
    }

    json.NewEncoder(w).Encode(book)
}

err1 := errors.New("base error")
err2 := fmt.Errorf("layer 2: %w", err1)
err3 := fmt.Errorf("layer 3: %w", err2)

fmt.Println(err3)                    // layer 3: layer 2: base error
fmt.Println(errors.Unwrap(err3))     // layer 2: base error
fmt.Println(errors.Unwrap(errors.Unwrap(err3))) // base error
fmt.Println(errors.Unwrap(err1))     // nil — no more layers

// Traverse the whole error chain manually
func traceError(err error) {
    fmt.Println("=== Error Chain ===")
    for err != nil {
        fmt.Printf("  %T: %v\n", err, err)
        err = errors.Unwrap(err)
    }
}

traceError(err3)
// === Error Chain ===
//   *fmt.wrapError: layer 3: layer 2: base error
//   *fmt.wrapError: layer 2: base error
//   *errors.errorString: base error

import "errors"

// Form validation — collect all errors at once
type RegistrationForm struct {
    Name     string
    Email    string
    Password string
    Age      int
}

func validateForm(form RegistrationForm) error {
    var errs []error

    if form.Name == "" {
        errs = append(errs, errors.New("name must not be empty"))
    } else if len(form.Name) < 2 {
        errs = append(errs, errors.New("name must be at least 2 characters"))
    }

    if form.Email == "" {
        errs = append(errs, errors.New("email must not be empty"))
    } else if !strings.Contains(form.Email, "@") {
        errs = append(errs, errors.New("invalid email format"))
    }

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

    if form.Age < 18 {
        errs = append(errs, errors.New("age must be at least 18"))
    }

    // errors.Join combines all errors
    // returns nil if the slice is empty
    return errors.Join(errs...)
}

func main() {
    form := RegistrationForm{
        Name:     "A",
        Email:    "not-an-email",
        Password: "123",
        Age:      15,
    }

    if err := validateForm(form); err != nil {
        fmt.Println("Validation failed:")
        fmt.Println(err)
        // Validation failed:
        // name must be at least 2 characters
        // invalid email format
        // password must be at least 8 characters
        // age must be at least 18
    }
}

import (
    "errors"
    "sync"
)

func runParallel(tasks []func() error) error {
    var (
        mu   sync.Mutex
        errs []error
        wg   sync.WaitGroup
    )

    for _, t := range tasks {
        wg.Add(1)
        go func(fn func() error) {
            defer wg.Done()
            if err := fn(); err != nil {
                mu.Lock()
                errs = append(errs, err)
                mu.Unlock()
            }
        }(t)
    }

    wg.Wait()
    return errors.Join(errs...)
}

// Usage
err := runParallel([]func() error{
    func() error { return sendEmail("[email protected]") },
    func() error { return sendNotification(123) },
    func() error { return updateCache("key") },
})

if err != nil {
    fmt.Println("Some operations failed:", err)
}

// A custom error type with Unwrap for wrapping compatibility
type DBError struct {
    Operation string
    Query     string
    Err       error // the underlying error
}

func (e *DBError) Error() string {
    return fmt.Sprintf("db error during %s: %v", e.Operation, e.Err)
}

// Unwrap allows errors.Is and errors.As to reach the underlying error
func (e *DBError) Unwrap() error {
    return e.Err
}

// Usage
var ErrDBConnection = errors.New("database connection issue")

func queryDB(query string) error {
    // Simulate a connection error
    return &DBError{
        Operation: "SELECT",
        Query:     query,
        Err:       ErrDBConnection,
    }
}

func main() {
    err := queryDB("SELECT * FROM users WHERE id = 1")

    // errors.As to access DBError details
    var errDB *DBError
    if errors.As(err, &errDB) {
        fmt.Printf("Operation: %s\n", errDB.Operation)
        fmt.Printf("Query: %s\n", errDB.Query)
    }

    // errors.Is can still find ErrDBConnection
    // because DBError implements Unwrap
    if errors.Is(err, ErrDBConnection) {
        fmt.Println("Database connection issue — try reconnecting")
    }
}

// An error carrying an HTTP status code and an API error code
type AppError struct {
    Code       string // code for the client: "USER_NOT_FOUND", "INVALID_INPUT"
    Message    string // a message that can be shown to the user
    StatusHTTP int    // the matching HTTP status code
    Err        error  // the underlying error (for logging, not sent to the client)
}

func (e *AppError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("[%s] %s: %v", e.Code, e.Message, e.Err)
    }
    return fmt.Sprintf("[%s] %s", e.Code, e.Message)
}

func (e *AppError) Unwrap() error {
    return e.Err
}

// Constructors for common errors
func ErrUserNotFound(id int) *AppError {
    return &AppError{
        Code:       "USER_NOT_FOUND",
        Message:    fmt.Sprintf("user with ID %d not found", id),
        StatusHTTP: 404,
    }
}

func ErrInvalidInputApp(field, message string) *AppError {
    return &AppError{
        Code:       "INVALID_INPUT",
        Message:    fmt.Sprintf("field %s: %s", field, message),
        StatusHTTP: 400,
    }
}

// A handler using AppError
func genericHandler(w http.ResponseWriter, r *http.Request, err error) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(appErr.StatusHTTP)
        json.NewEncoder(w).Encode(map[string]string{
            "error":   appErr.Code,
            "message": appErr.Message,
        })
        return
    }

    // An unknown error
    log.Printf("unexpected error: %v", err)
    http.Error(w, "internal server error", 500)
}

// ✗ ANTI-PATTERN 1: Ignore errors
data, _ := os.ReadFile("config.yaml") // data could be nil!
// If ReadFile fails, data is nil and subsequent usage will panic

// ✓ CORRECT: always check errors
data, err := os.ReadFile("config.yaml")
if err != nil {
    return fmt.Errorf("loadConfig: %w", err)
}

// ✗ ANTI-PATTERN 2: Only log the error but keep going
data, err = os.ReadFile("config.yaml")
if err != nil {
    log.Println("error:", err) // logs but doesn't return!
}
// The code below uses data, which might be nil

// ✓ CORRECT: log AND return (or handle properly)
data, err = os.ReadFile("config.yaml")
if err != nil {
    log.Printf("failed to read config: %v", err)
    return err // or use a default, or exit
}

// ✗ ANTI-PATTERN 3: Wrapping without added value
func findUser2(id int) error {
    err := db.Query(id)
    if err != nil {
        return fmt.Errorf("error: %w", err) // "error:" adds no context at all!
    }
    return nil
}

// ✓ CORRECT: wrap with meaningful context
func findUser3(id int) error {
    err := db.Query(id)
    if err != nil {
        return fmt.Errorf("findUser id=%d: %w", id, err) // function name + arguments
    }
    return nil
}

// ✗ ANTI-PATTERN 4: Wrapping an error that already has enough context
func findUser4(id int) (*User, error) {
    u, err := findUser3(id)
    if err != nil {
        // findUser3 already added good context
        // wrapping again only adds noise
        return nil, fmt.Errorf("findUser4 called with id %d and failed because: %w", id, err)
    }
    return u, nil
}

// ✓ CORRECT: wrap briefly or return directly if the context is already enough
func findUser5(id int) (*User, error) {
    u, err := findUser3(id)
    if err != nil {
        return nil, fmt.Errorf("findUser5: %w", err) // concise, not redundant
    }
    return u, nil
}

// ✗ ANTI-PATTERN 5: Use panic for errors that can be handled
func divide(a, b int) int {
    if b == 0 {
        panic("division by zero") // don't panic for predictable conditions!
    }
    return a / b
}

// ✓ CORRECT: return an error for conditions that can occur
func divideGood(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("can't divide by zero")
    }
    return a / b, nil
}

// errors.go — one file for all sentinel errors in the package
package app

import "errors"

// Authentication errors
var (
    ErrTokenExpired   = errors.New("token expired")
    ErrTokenInvalid   = errors.New("invalid token")
    ErrSessionNotFound = errors.New("session not found")
)

// Data errors
var (
    ErrUserNotFound    = errors.New("user not found")
    ErrProductNotFound = errors.New("product not found")
    ErrOutOfStock      = errors.New("out of stock")
    ErrDuplicateEmail  = errors.New("email already registered")
)

// System errors
var (
    ErrDatabase     = errors.New("database unavailable")
    ErrCache        = errors.New("cache unavailable")
    ErrExternalSvc  = errors.New("external service unavailable")
)

// Middleware that converts AppError into consistent JSON responses
type ErrorResponse struct {
    Code   string `json:"code"`
    Message string `json:"message"`
    Detail any    `json:"detail,omitempty"`
}

func errorHandler(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // Use panic recovery to catch unexpected panics
        defer func() {
            if rec := recover(); rec != nil {
                log.Printf("panic: %v\n%s", rec, debug.Stack())
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(500)
                json.NewEncoder(w).Encode(ErrorResponse{
                    Code:    "INTERNAL_ERROR",
                    Message: "an internal error occurred",
                })
            }
        }()

        next(w, r)
    }
}

func sendError(w http.ResponseWriter, err error) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(appErr.StatusHTTP)
        json.NewEncoder(w).Encode(ErrorResponse{
            Code:    appErr.Code,
            Message: appErr.Message,
        })
        return
    }

    // Check common sentinel errors
    switch {
    case errors.Is(err, ErrUserNotFound):
        w.WriteHeader(404)
        json.NewEncoder(w).Encode(ErrorResponse{
            Code:    "NOT_FOUND",
            Message: "data not found",
        })
    case errors.Is(err, ErrTokenInvalid),
        errors.Is(err, ErrTokenExpired):
        w.WriteHeader(401)
        json.NewEncoder(w).Encode(ErrorResponse{
            Code:    "UNAUTHORIZED",
            Message: "authentication required",
        })
    default:
        log.Printf("unhandled error: %v", err)
        w.WriteHeader(500)
        json.NewEncoder(w).Encode(ErrorResponse{
            Code:    "INTERNAL_ERROR",
            Message: "an internal error occurred",
        })
    }
}