Modern Error Handling with Wrapping

package main

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

// Custom error types for domain-specific errors
type ValidationError struct {
	Field   string
	Message string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation error: %s - %s", e.Field, e.Message)
}

type DatabaseError struct {
	Operation string
	Err       error
}

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

// Unwrap implements error unwrapping for DatabaseError
func (e *DatabaseError) Unwrap() error {
	return e.Err
}

// UserService handles user operations with proper error handling
type UserService struct{}

// ValidateUser checks if user data is valid
func (s *UserService) ValidateUser(username, email string) error {
	if username == "" {
		return &ValidationError{
			Field:   "username",
			Message: "cannot be empty",
		}
	}

	if email == "" {
		return &ValidationError{
			Field:   "email",
			Message: "cannot be empty",
		}
	}

	if len(username) < 3 {
		return &ValidationError{
			Field:   "username",
			Message: "must be at least 3 characters long",
		}
	}

	return nil
}

// SaveUser simulates saving a user to a database
func (s *UserService) SaveUser(username, email string) error {
	// First validate user
	if err := s.ValidateUser(username, email); err != nil {
		// Wrap validation error with context
		return fmt.Errorf("failed to validate user before save: %w", err)
	}

	// Simulate database error
	dbErr := errors.New("connection timeout")
	return &DatabaseError{
		Operation: "insert",
		Err:       dbErr,
	}
}

// FileOperation simulates a file operation with wrapped errors
func FileOperation(filename string) error {
	file, err := os.Open(filename)
	if err != nil {
		// Wrap the system error with custom context
		return fmt.Errorf("failed to open file '%s': %w", filename, err)
	}
	defer file.Close()

	// Do something with the file...
	return nil
}

func main() {
	// Example 1: Custom error types with wrapping
	userService := &UserService{}
	err := userService.SaveUser("jo", "[email protected]")
	if err != nil {
		fmt.Println("Error saving user:", err)

		// Check if error is a ValidationError (using errors.As)
		var valErr *ValidationError
		if errors.As(err, &valErr) {
			fmt.Printf("Validation failed for field '%s': %s\n", valErr.Field, valErr.Message)
		}

		// Check if error is a DatabaseError
		var dbErr *DatabaseError
		if errors.As(err, &dbErr) {
			fmt.Printf("Database error during %s: %v\n", dbErr.Operation, dbErr.Err)
		}

		// Unwrap and check the original error
		rootErr := errors.Unwrap(err)
		fmt.Printf("Root error: %v\n", rootErr)
	}

	fmt.Println("---")

	// Example 2: Wrapping standard library errors
	err = FileOperation("nonexistent.txt")
	if err != nil {
		fmt.Println("File operation error:", err)

		// Check if the wrapped error is fs.ErrNotExist
		if errors.Is(err, fs.ErrNotExist) {
			fmt.Println("The file does not exist (detected via errors.Is)")
		}

		// Extract the original error
		var pathErr *fs.PathError
		if errors.As(err, &pathErr) {
			fmt.Printf("Path error details: Op=%s, Path=%s, Err=%v\n", pathErr.Op, pathErr.Path, pathErr.Err)
		}
	}

	// Example 3: Chained error wrapping
	originalErr := errors.New("original error")
	wrappedErr1 := fmt.Errorf("level 1 wrap: %w", originalErr)
	wrappedErr2 := fmt.Errorf("level 2 wrap: %w", wrappedErr1)

	fmt.Println("---")
	fmt.Println("Chained errors:")
	fmt.Println("Wrapped 2:", wrappedErr2)
	fmt.Println("Is original error?", errors.Is(wrappedErr2, originalErr))
	fmt.Println("Unwrap once:", errors.Unwrap(wrappedErr2))
	fmt.Println("Unwrap twice:", errors.Unwrap(errors.Unwrap(wrappedErr2)))
}