add support for dynamic event handlers, streamline event handler formatting

Author: benedikt-bartscher

reflex/compiler/templates.py

@@ -9,7 +9,7 @@
 from reflex import constants
 from reflex.constants import Hooks
 from reflex.constants.state import CAMEL_CASE_MEMO_MARKER
-from reflex.utils.format import format_state_name, json_dumps
+from reflex.utils.format import format_event_handler, format_state_name, json_dumps
 from reflex.vars.base import VarData
 
 if TYPE_CHECKING:
@@ -284,8 +284,10 @@ def context_template(
 
     # Compute dynamic state names that respect minification settings
     main_state_name = State.get_name()
-    on_load_internal = f"{OnLoadInternalState.get_name()}.on_load_internal"
-    update_vars_internal = f"{UpdateVarsInternalState.get_name()}.update_vars_internal"
+    on_load_internal = format_event_handler(OnLoadInternalState.on_load_internal)
+    update_vars_internal = format_event_handler(
+        UpdateVarsInternalState.update_vars_internal
+    )
     exception_state_full = FrontendEventExceptionState.get_full_name()
 
     initial_state = initial_state or {}
@@ -314,15 +316,15 @@ def context_template(
     if (client_storage_vars && Object.keys(client_storage_vars).length !== 0) {{
         internal_events.push(
             ReflexEvent(
-                '{state_name}.{update_vars_internal}',
+                '{update_vars_internal}',
                 {{vars: client_storage_vars}},
             ),
         );
     }}
 
     // `on_load_internal` triggers the correct on_load event(s) for the current page.
     // If the page does not define any on_load event, this will just set `is_hydrated = true`.
-    internal_events.push(ReflexEvent('{state_name}.{on_load_internal}'));
+    internal_events.push(ReflexEvent('{on_load_internal}'));
 
     return internal_events;
 }}

reflex/constants/event.py

@@ -3,6 +3,9 @@
 from enum import Enum
 from types import SimpleNamespace
 
+# The name of the setvar event handler.
+SETVAR = "setvar"
+
 
 class Endpoint(Enum):
     """Endpoints for the reflex backend API."""

reflex/state.py

@@ -609,6 +609,7 @@ def __init_subclass__(cls, mixin: bool = False, **kwargs):
             **cls.computed_vars,
         }
         cls.event_handlers = {}
+        cls._event_id_to_name = {}
 
         # Setup the base vars at the class level.
         for name, prop in cls.base_vars.items():
@@ -651,16 +652,9 @@ def __init_subclass__(cls, mixin: bool = False, **kwargs):
             cls.event_handlers[name] = handler
             setattr(cls, name, handler)
 
-        # Build event_id registry from minify.json configuration
-        from reflex.minify import get_event_id, get_state_full_path, is_minify_enabled
-
-        cls._event_id_to_name = {}
-        if is_minify_enabled():
-            state_path = get_state_full_path(cls)
-            for handler_name in events:
-                event_id = get_event_id(state_path, handler_name)
-                if event_id is not None:
-                    cls._event_id_to_name[event_id] = handler_name
+        # Register user-defined event handlers for minification
+        for handler_name in events:
+            cls._register_event_handler_for_minify(handler_name)
 
         # Initialize per-class var dependency tracking.
         cls._var_dependencies = {}
@@ -673,16 +667,42 @@ def _add_event_handler(
         cls,
         name: str,
         fn: Callable,
-    ):
+    ) -> EventHandler:
         """Add an event handler dynamically to the state.
 
         Args:
             name: The name of the event handler.
             fn: The function to call when the event is triggered.
+
+        Returns:
+            The created EventHandler instance.
         """
         handler = cls._create_event_handler(fn)
         cls.event_handlers[name] = handler
         setattr(cls, name, handler)
+        cls._register_event_handler_for_minify(name)
+        return handler
+
+    @classmethod
+    def _register_event_handler_for_minify(cls, handler_name: str) -> None:
+        """Register an event handler for minification if applicable.
+
+        Called when an event handler is added to event_handlers dict.
+        Updates _event_id_to_name if minification is enabled and the handler
+        has a minified ID in the config.
+
+        Args:
+            handler_name: The original name of the event handler.
+        """
+        from reflex.minify import get_event_id, get_minify_config, get_state_full_path
+
+        if get_minify_config() is None:
+            return
+
+        state_path = get_state_full_path(cls)
+        event_id = get_event_id(state_path, handler_name)
+        if event_id is not None:
+            cls._event_id_to_name[event_id] = handler_name
 
     @staticmethod
     def _copy_fn(fn: Callable) -> Callable:
@@ -1204,7 +1224,10 @@ def _create_event_handler(
     @classmethod
     def _create_setvar(cls):
         """Create the setvar method for the state."""
-        cls.setvar = cls.event_handlers["setvar"] = EventHandlerSetVar(state_cls=cls)
+        cls.setvar = cls.event_handlers[constants.event.SETVAR] = EventHandlerSetVar(
+            state_cls=cls
+        )
+        cls._register_event_handler_for_minify(constants.event.SETVAR)
 
     @classmethod
     def _create_setter(cls, name: str, prop: Var):
@@ -1244,6 +1267,7 @@ def __call__(self, *args, **kwargs):
             )
             cls.event_handlers[setter_name] = event_handler
             setattr(cls, setter_name, event_handler)
+            cls._register_event_handler_for_minify(setter_name)
 
     @classmethod
     def _set_default_value(cls, name: str, prop: Var):

reflex/utils/format.py

@@ -6,7 +6,8 @@
 import json
 import os
 import re
-from typing import TYPE_CHECKING, Any
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
 
 from reflex import constants
 from reflex.constants.state import FRONTEND_EVENT_STATE
@@ -439,7 +440,9 @@ def format_props(*single_props, **key_value_props) -> list[str]:
     ] + [(f"...{LiteralVar.create(prop)!s}") for prop in single_props]
 
 
-def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
+def get_event_handler_parts(
+    handler: EventHandler | Callable[..., Any],
+) -> tuple[str, str]:
     """Get the state and function name of an event handler.
 
     Args:
@@ -448,9 +451,13 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     Returns:
         The state and function name (possibly minified based on minify.json).
     """
+    from reflex.event import EventHandler
     from reflex.minify import is_minify_enabled
     from reflex.state import State
 
+    # Cast for type checker - at runtime this is always an EventHandler
+    handler = cast(EventHandler, handler)
+
     # Get the class that defines the event handler.
     parts = handler.fn.__qualname__.split(".")
 
@@ -486,7 +493,7 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     return (state_full_name, name)
 
 
-def format_event_handler(handler: EventHandler) -> str:
+def format_event_handler(handler: EventHandler | Callable[..., Any]) -> str:
     """Format an event handler.
 
     Args:

tests/units/test_minification.py

@@ -419,3 +419,116 @@ def my_handler(self):
 
         # Should be the minified name directly
         assert event_name == "d"
+
+
+class TestDynamicHandlerMinification:
+    """Tests for dynamic event handler minification (setvar, auto-setters)."""
+
+    def test_setvar_registered_with_config(self, temp_minify_json):
+        """Test that setvar is registered in _event_id_to_name when config exists."""
+        expected_module = "tests.units.test_minification"
+        expected_state_path = f"{expected_module}.State.TestStateWithSetvar"
+
+        config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                "reflex.state.State": "a",
+                expected_state_path: "b",
+            },
+            "events": {
+                expected_state_path: {"setvar": "s"},
+            },
+        }
+        save_minify_config(config)
+        clear_config_cache()
+        State.get_name.cache_clear()
+        State.get_full_name.cache_clear()
+        State.get_class_substate.cache_clear()
+
+        class TestStateWithSetvar(State):
+            pass
+
+        # Verify setvar is registered for minification
+        assert "s" in TestStateWithSetvar._event_id_to_name
+        assert TestStateWithSetvar._event_id_to_name["s"] == "setvar"
+
+    def test_auto_setter_registered_with_config(self, temp_minify_json):
+        """Test that auto-setters (set_*) are registered in _event_id_to_name when config exists."""
+        expected_module = "tests.units.test_minification"
+        expected_state_path = f"{expected_module}.State.TestStateWithAutoSetter"
+
+        config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                "reflex.state.State": "a",
+                expected_state_path: "b",
+            },
+            "events": {
+                expected_state_path: {"set_count": "c", "setvar": "v"},
+            },
+        }
+        save_minify_config(config)
+        clear_config_cache()
+        State.get_name.cache_clear()
+        State.get_full_name.cache_clear()
+        State.get_class_substate.cache_clear()
+
+        class TestStateWithAutoSetter(State):
+            count: int = 0
+
+        # Verify auto-setter is registered for minification
+        assert "c" in TestStateWithAutoSetter._event_id_to_name
+        assert TestStateWithAutoSetter._event_id_to_name["c"] == "set_count"
+
+    def test_dynamic_handlers_not_registered_without_config(self, temp_minify_json):
+        """Test that dynamic handlers are NOT registered when no config exists."""
+        # No config saved - temp_minify_json fixture ensures clean state
+
+        class TestStateNoConfig(State):
+            count: int = 0
+
+        # Without config, _event_id_to_name should be empty
+        assert TestStateNoConfig._event_id_to_name == {}
+
+    def test_add_event_handler_registered_with_config(self, temp_minify_json):
+        """Test that dynamically added event handlers via _add_event_handler are registered."""
+        import reflex as rx
+
+        expected_module = "tests.units.test_minification"
+        expected_state_path = f"{expected_module}.State.TestStateWithDynamicHandler"
+
+        config: MinifyConfig = {
+            "version": SCHEMA_VERSION,
+            "states": {
+                "reflex.state.State": "a",
+                expected_state_path: "b",
+            },
+            "events": {
+                expected_state_path: {"dynamic_handler": "d", "setvar": "v"},
+            },
+        }
+        save_minify_config(config)
+        clear_config_cache()
+        State.get_name.cache_clear()
+        State.get_full_name.cache_clear()
+        State.get_class_substate.cache_clear()
+
+        class TestStateWithDynamicHandler(State):
+            pass
+
+        # Dynamically add an event handler after class creation
+        @rx.event
+        def dynamic_handler(self):
+            pass
+
+        from reflex.event import EventHandler
+
+        handler = EventHandler(
+            fn=dynamic_handler,
+            state_full_name=TestStateWithDynamicHandler.get_full_name(),
+        )
+        TestStateWithDynamicHandler._add_event_handler("dynamic_handler", handler)
+
+        # Verify dynamic handler is registered for minification
+        assert "d" in TestStateWithDynamicHandler._event_id_to_name
+        assert TestStateWithDynamicHandler._event_id_to_name["d"] == "dynamic_handler"