feat: remove global handlers and enable push notifications by default

- Remove all global push notification handler functionality
- Simplify registry to support only single handler per notification type
- Enable push notifications by default for RESP3 connections
- Update comprehensive test suite to remove global handler tests
- Update demo to show multiple specific handlers instead of global handlers
- Always respect custom processors regardless of PushNotifications flag

Push notifications are now automatically enabled for RESP3 and each
notification type has a single dedicated handler for predictable behavior.

Author: ndyakov

example/push-notification-demo/main.go

@@ -18,8 +18,8 @@ func main() {
 	// Example 2: Custom push notification handlers
 	customHandlersExample()
 
-	// Example 3: Global push notification handlers
-	globalHandlersExample()
+	// Example 3: Multiple specific handlers
+	multipleSpecificHandlersExample()
 
 	// Example 4: Custom push notifications
 	customPushNotificationExample()
@@ -95,8 +95,8 @@ func customHandlersExample() {
 	fmt.Println("   - SYSTEM_ALERT: Handles system alert notifications")
 }
 
-func globalHandlersExample() {
-	fmt.Println("\n=== Global Push Notification Handler Example ===")
+func multipleSpecificHandlersExample() {
+	fmt.Println("\n=== Multiple Specific Handlers Example ===")
 
 	client := redis.NewClient(&redis.Options{
 		Addr:              "localhost:6379",
@@ -105,25 +105,21 @@ func globalHandlersExample() {
 	})
 	defer client.Close()
 
-	// Register a global handler that receives ALL push notifications
-	client.RegisterGlobalPushNotificationHandlerFunc(func(ctx context.Context, notification []interface{}) bool {
-		if len(notification) > 0 {
-			command := notification[0]
-			fmt.Printf("📡 Global handler received: %v (args: %d)\n", command, len(notification)-1)
-		}
+	// Register specific handlers
+	client.RegisterPushNotificationHandlerFunc("SPECIFIC_EVENT", func(ctx context.Context, notification []interface{}) bool {
+		fmt.Printf("🎯 Specific handler for SPECIFIC_EVENT: %v\n", notification)
 		return true
 	})
 
-	// Register specific handlers as well
-	client.RegisterPushNotificationHandlerFunc("SPECIFIC_EVENT", func(ctx context.Context, notification []interface{}) bool {
-		fmt.Printf("🎯 Specific handler for SPECIFIC_EVENT: %v\n", notification)
+	client.RegisterPushNotificationHandlerFunc("ANOTHER_EVENT", func(ctx context.Context, notification []interface{}) bool {
+		fmt.Printf("🎯 Specific handler for ANOTHER_EVENT: %v\n", notification)
 		return true
 	})
 
-	fmt.Println("✅ Global and specific handlers registered:")
-	fmt.Println("   - Global handler will receive ALL push notifications")
-	fmt.Println("   - Specific handler will receive only SPECIFIC_EVENT notifications")
-	fmt.Println("   - Both handlers will be called for SPECIFIC_EVENT notifications")
+	fmt.Println("✅ Specific handlers registered:")
+	fmt.Println("   - SPECIFIC_EVENT handler will receive only SPECIFIC_EVENT notifications")
+	fmt.Println("   - ANOTHER_EVENT handler will receive only ANOTHER_EVENT notifications")
+	fmt.Println("   - Each notification type has a single dedicated handler")
 }
 
 func customPushNotificationExample() {
@@ -143,24 +139,9 @@ func customPushNotificationExample() {
 		return true
 	})
 
-	// Register a global handler to monitor all notifications
-	client.RegisterGlobalPushNotificationHandlerFunc(func(ctx context.Context, notification []interface{}) bool {
-		if len(notification) > 0 {
-			command := notification[0]
-			switch command {
-			case "MOVING", "MIGRATING", "MIGRATED":
-				fmt.Printf("🔄 Cluster notification: %v\n", command)
-			default:
-				fmt.Printf("📨 Other notification: %v\n", command)
-			}
-		}
-		return true
-	})
-
 	fmt.Println("✅ Custom push notifications enabled:")
-	fmt.Println("   - MOVING, MIGRATING, MIGRATED notifications → Cluster handlers")
 	fmt.Println("   - APPLICATION_EVENT notifications → Custom handler")
-	fmt.Println("   - All notifications → Global monitoring handler")
+	fmt.Println("   - Each notification type has a single dedicated handler")
 }
 
 func multipleNotificationTypesExample() {

options.go

@@ -221,7 +221,11 @@ type Options struct {
 	// When enabled, the client will process RESP3 push notifications and
 	// route them to registered handlers.
 	//
-	// default: false
+	// For RESP3 connections (Protocol: 3), push notifications are automatically enabled.
+	// To disable push notifications for RESP3, use Protocol: 2 instead.
+	// For RESP2 connections, push notifications are not available.
+	//
+	// default: automatically enabled for RESP3, disabled for RESP2
 	PushNotifications bool
 
 	// PushNotificationProcessor is the processor for handling push notifications.

push_notifications.go

@@ -28,14 +28,12 @@ func (f PushNotificationHandlerFunc) HandlePushNotification(ctx context.Context,
 type PushNotificationRegistry struct {
 	mu       sync.RWMutex
 	handlers map[string]PushNotificationHandler // command -> single handler
-	global   []PushNotificationHandler          // global handlers for all notifications
 }
 
 // NewPushNotificationRegistry creates a new push notification registry.
 func NewPushNotificationRegistry() *PushNotificationRegistry {
 	return &PushNotificationRegistry{
 		handlers: make(map[string]PushNotificationHandler),
-		global:   make([]PushNotificationHandler, 0),
 	}
 }
 
@@ -52,14 +50,6 @@ func (r *PushNotificationRegistry) RegisterHandler(command string, handler PushN
 	return nil
 }
 
-// RegisterGlobalHandler registers a handler that will receive all push notifications.
-func (r *PushNotificationRegistry) RegisterGlobalHandler(handler PushNotificationHandler) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	r.global = append(r.global, handler)
-}
-
 // UnregisterHandler removes the handler for a specific push notification command.
 func (r *PushNotificationRegistry) UnregisterHandler(command string) {
 	r.mu.Lock()
@@ -68,7 +58,7 @@ func (r *PushNotificationRegistry) UnregisterHandler(command string) {
 	delete(r.handlers, command)
 }
 
-// HandleNotification processes a push notification by calling all registered handlers.
+// HandleNotification processes a push notification by calling the registered handler.
 func (r *PushNotificationRegistry) HandleNotification(ctx context.Context, notification []interface{}) bool {
 	if len(notification) == 0 {
 		return false
@@ -83,23 +73,12 @@ func (r *PushNotificationRegistry) HandleNotification(ctx context.Context, notif
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 
-	handled := false
-
-	// Call global handlers first
-	for _, handler := range r.global {
-		if handler.HandlePushNotification(ctx, notification) {
-			handled = true
-		}
-	}
-
 	// Call specific handler
 	if handler, exists := r.handlers[command]; exists {
-		if handler.HandlePushNotification(ctx, notification) {
-			handled = true
-		}
+		return handler.HandlePushNotification(ctx, notification)
 	}
 
-	return handled
+	return false
 }
 
 // GetRegisteredCommands returns a list of commands that have registered handlers.
@@ -114,12 +93,12 @@ func (r *PushNotificationRegistry) GetRegisteredCommands() []string {
 	return commands
 }
 
-// HasHandlers returns true if there are any handlers registered (global or specific).
+// HasHandlers returns true if there are any handlers registered.
 func (r *PushNotificationRegistry) HasHandlers() bool {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 
-	return len(r.global) > 0 || len(r.handlers) > 0
+	return len(r.handlers) > 0
 }
 
 // PushNotificationProcessor handles the processing of push notifications from Redis.
@@ -206,22 +185,12 @@ func (p *PushNotificationProcessor) RegisterHandler(command string, handler Push
 	return p.registry.RegisterHandler(command, handler)
 }
 
-// RegisterGlobalHandler is a convenience method to register a global handler.
-func (p *PushNotificationProcessor) RegisterGlobalHandler(handler PushNotificationHandler) {
-	p.registry.RegisterGlobalHandler(handler)
-}
-
 // RegisterHandlerFunc is a convenience method to register a function as a handler.
 // Returns an error if a handler is already registered for this command.
 func (p *PushNotificationProcessor) RegisterHandlerFunc(command string, handlerFunc func(ctx context.Context, notification []interface{}) bool) error {
 	return p.registry.RegisterHandler(command, PushNotificationHandlerFunc(handlerFunc))
 }
 
-// RegisterGlobalHandlerFunc is a convenience method to register a function as a global handler.
-func (p *PushNotificationProcessor) RegisterGlobalHandlerFunc(handlerFunc func(ctx context.Context, notification []interface{}) bool) {
-	p.registry.RegisterGlobalHandler(PushNotificationHandlerFunc(handlerFunc))
-}
-
 // Common push notification commands
 const (
 	// Redis Cluster notifications