add common error types

Author: ndyakov

README.md

@@ -434,14 +434,23 @@ res, err := rdb.Do(ctx, "set", "key", "value").Result()
 go-redis provides typed error checking functions for common Redis errors:
 
 ```go
+// Cluster and replication errors
 redis.IsLoadingError(err)        // Redis is loading the dataset
 redis.IsReadOnlyError(err)       // Write to read-only replica
 redis.IsClusterDownError(err)    // Cluster is down
 redis.IsTryAgainError(err)       // Command should be retried
 redis.IsMasterDownError(err)     // Master is down
-redis.IsMaxClientsError(err)     // Maximum clients reached
 redis.IsMovedError(err)          // Returns (address, true) if key moved
 redis.IsAskError(err)            // Returns (address, true) if key being migrated
+
+// Connection and resource errors
+redis.IsMaxClientsError(err)     // Maximum clients reached
+redis.IsAuthError(err)           // Authentication failed (NOAUTH, WRONGPASS, unauthenticated)
+redis.IsPermissionError(err)     // Permission denied (NOPERM)
+redis.IsOOMError(err)            // Out of memory (OOM)
+
+// Transaction errors
+redis.IsExecAbortError(err)      // Transaction aborted (EXECABORT)
 ```
 
 ### Error Wrapping in Hooks
@@ -500,6 +509,60 @@ wrappedErr := fmt.Errorf("context: %w", err)
 cmd.SetErr(wrappedErr)
 ```
 
+### Pipeline Hook Example
+
+For pipeline operations, use `ProcessPipelineHook`:
+
+```go
+type PipelineLoggingHook struct{}
+
+func (h PipelineLoggingHook) DialHook(next redis.DialHook) redis.DialHook {
+    return next
+}
+
+func (h PipelineLoggingHook) ProcessHook(next redis.ProcessHook) redis.ProcessHook {
+    return next
+}
+
+func (h PipelineLoggingHook) ProcessPipelineHook(next redis.ProcessPipelineHook) redis.ProcessPipelineHook {
+    return func(ctx context.Context, cmds []redis.Cmder) error {
+        start := time.Now()
+        err := next(ctx, cmds)
+        duration := time.Since(start)
+
+        // Log pipeline execution
+        log.Printf("Pipeline executed %d commands in %v", len(cmds), duration)
+
+        // Check for errors in individual commands
+        for _, cmd := range cmds {
+            if cmdErr := cmd.Err(); cmdErr != nil {
+                // Wrap individual command errors if needed
+                if redis.IsAuthError(cmdErr) {
+                    log.Printf("Auth error in pipeline command %s: %v", cmd.Name(), cmdErr)
+                } else if redis.IsPermissionError(cmdErr) {
+                    log.Printf("Permission error in pipeline command %s: %v", cmd.Name(), cmdErr)
+                }
+
+                // Optionally wrap the error
+                wrappedErr := fmt.Errorf("pipeline cmd %s failed: %w", cmd.Name(), cmdErr)
+                cmd.SetErr(wrappedErr)
+            }
+        }
+
+        return err
+    }
+}
+
+// Register the hook
+rdb.AddHook(PipelineLoggingHook{})
+
+// Use pipeline - errors are still properly typed
+pipe := rdb.Pipeline()
+pipe.Set(ctx, "key1", "value1", 0)
+pipe.Get(ctx, "key2")
+_, err := pipe.Exec(ctx)
+```
+
 ## Run the test
 
 Recommended to use Docker, just need to run:

error.go

@@ -315,6 +315,33 @@ func IsAskError(err error) (addr string, ok bool) {
 	return "", false
 }
 
+// IsAuthError checks if an error is a Redis authentication error, even if wrapped.
+// Authentication errors occur when:
+// - NOAUTH: Redis requires authentication but none was provided
+// - WRONGPASS: Redis authentication failed due to incorrect password
+// - unauthenticated: Error returned when password changed
+func IsAuthError(err error) bool {
+	return proto.IsAuthError(err)
+}
+
+// IsPermissionError checks if an error is a Redis permission error, even if wrapped.
+// Permission errors (NOPERM) occur when a user does not have permission to execute a command.
+func IsPermissionError(err error) bool {
+	return proto.IsPermissionError(err)
+}
+
+// IsExecAbortError checks if an error is a Redis EXECABORT error, even if wrapped.
+// EXECABORT errors occur when a transaction is aborted.
+func IsExecAbortError(err error) bool {
+	return proto.IsExecAbortError(err)
+}
+
+// IsOOMError checks if an error is a Redis OOM (Out Of Memory) error, even if wrapped.
+// OOM errors occur when Redis is out of memory.
+func IsOOMError(err error) bool {
+	return proto.IsOOMError(err)
+}
+
 //------------------------------------------------------------------------------
 
 type timeoutError interface {

error_wrapping_test.go

@@ -640,3 +640,89 @@ func contains(s, substr string) bool {
 	return strings.Contains(s, substr)
 }
 
+func TestAuthErrorWrapping(t *testing.T) {
+	t.Run("Wrapped NOAUTH error", func(t *testing.T) {
+		// Create an auth error
+		authErr := proto.NewAuthError("NOAUTH Authentication required")
+
+		// Wrap it
+		wrappedErr := fmt.Errorf("hook: %w", authErr)
+
+		// Should still be detected
+		if !redis.IsAuthError(wrappedErr) {
+			t.Errorf("IsAuthError should detect wrapped NOAUTH error")
+		}
+	})
+
+	t.Run("Wrapped WRONGPASS error", func(t *testing.T) {
+		// Create an auth error
+		authErr := proto.NewAuthError("WRONGPASS invalid username-password pair")
+
+		// Wrap it multiple times
+		wrappedErr := fmt.Errorf("connection error: %w", authErr)
+		doubleWrappedErr := fmt.Errorf("client error: %w", wrappedErr)
+
+		// Should still be detected
+		if !redis.IsAuthError(doubleWrappedErr) {
+			t.Errorf("IsAuthError should detect double-wrapped WRONGPASS error")
+		}
+	})
+
+	t.Run("Wrapped unauthenticated error", func(t *testing.T) {
+		// Create an auth error
+		authErr := proto.NewAuthError("ERR unauthenticated")
+
+		// Wrap it
+		wrappedErr := fmt.Errorf("hook: %w", authErr)
+
+		// Should still be detected
+		if !redis.IsAuthError(wrappedErr) {
+			t.Errorf("IsAuthError should detect wrapped unauthenticated error")
+		}
+	})
+}
+
+func TestPermissionErrorWrapping(t *testing.T) {
+	t.Run("Wrapped NOPERM error", func(t *testing.T) {
+		// Create a permission error
+		permErr := proto.NewPermissionError("NOPERM this user has no permissions to run the 'flushdb' command")
+
+		// Wrap it
+		wrappedErr := fmt.Errorf("hook: %w", permErr)
+
+		// Should still be detected
+		if !redis.IsPermissionError(wrappedErr) {
+			t.Errorf("IsPermissionError should detect wrapped NOPERM error")
+		}
+	})
+}
+
+func TestExecAbortErrorWrapping(t *testing.T) {
+	t.Run("Wrapped EXECABORT error", func(t *testing.T) {
+		// Create an EXECABORT error
+		execAbortErr := proto.NewExecAbortError("EXECABORT Transaction discarded because of previous errors")
+
+		// Wrap it
+		wrappedErr := fmt.Errorf("hook: %w", execAbortErr)
+
+		// Should still be detected
+		if !redis.IsExecAbortError(wrappedErr) {
+			t.Errorf("IsExecAbortError should detect wrapped EXECABORT error")
+		}
+	})
+}
+
+func TestOOMErrorWrapping(t *testing.T) {
+	t.Run("Wrapped OOM error", func(t *testing.T) {
+		// Create an OOM error
+		oomErr := proto.NewOOMError("OOM command not allowed when used memory > 'maxmemory'")
+
+		// Wrap it
+		wrappedErr := fmt.Errorf("hook: %w", oomErr)
+
+		// Should still be detected
+		if !redis.IsOOMError(wrappedErr) {
+			t.Errorf("IsOOMError should detect wrapped OOM error")
+		}
+	})
+}