Go Expert

Go Expert Skill

This skill provides deep Go expertise including Gin/Chi patterns, goroutines, error handling, table-driven tests, and security best practices.

---

Error Handling

Always Check Errors

// ✅ Correct - check and wrap
user, err := repo.GetByID(ctx, id)
if err != nil {
    return nil, fmt.Errorf("failed to get user %s: %w", id, err)
}

// ❌ Wrong - ignoring error
user, _ := repo.GetByID(ctx, id)  // Never do this!

Custom Error Types

type AppError struct {
    StatusCode int    `json:"-"`
    Code       string `json:"code"`
    Message    string `json:"message"`
    Err        error  `json:"-"`
}

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

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

// Constructors
func ErrNotFound(resource string) *AppError {
    return &AppError{
        StatusCode: http.StatusNotFound,
        Code:       "NOT_FOUND",
        Message:    fmt.Sprintf("%s not found", resource),
    }
}

func ErrBadRequest(message string) *AppError {
    return &AppError{
        StatusCode: http.StatusBadRequest,
        Code:       "BAD_REQUEST",
        Message:    message,
    }
}

Error Checking

// Check specific error types
func handleError(err error) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        // Handle app error
        log.Printf("App error: %s", appErr.Code)
        return
    }

    if errors.Is(err, context.DeadlineExceeded) {
        // Handle timeout
        log.Println("Request timed out")
        return
    }

    if errors.Is(err, sql.ErrNoRows) {
        // Handle not found
        return
    }

    // Unknown error
    log.Printf("Unexpected error: %v", err)
}

---

Concurrency Patterns

Worker Pool

func ProcessItems(ctx context.Context, items []Item, workers int) error {
    jobs := make(chan Item, len(items))
    results := make(chan error, len(items))

    // Start workers
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for item := range jobs {
                select {
                case <-ctx.Done():
                    results <- ctx.Err()
                    return
                default:
                    results <- processItem(ctx, item)
                }
            }
        }()
    }

    // Send jobs
    for _, item := range items {
        jobs <- item
    }
    close(jobs)

    // Wait and close results
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collect errors
    var errs []error
    for err := range results {
        if err != nil {
            errs = append(errs, err)
        }
    }

    return errors.Join(errs...)
}