minify event names as well

Author: benedikt-bartscher

.gitignore

@@ -21,4 +21,5 @@ reflex.db
 node_modules
 package-lock.json
 *.pyi
-.pre-commit-config.yaml
+.pre-commit-config.yaml
+uploaded_files/*

reflex/environment.py

@@ -487,12 +487,12 @@ class PerformanceMode(enum.Enum):
 
 
 @enum.unique
-class StateMinifyMode(enum.Enum):
-    """Mode for state name minification."""
+class MinifyMode(enum.Enum):
+    """Mode for state/event name minification."""
 
-    DISABLED = "disabled"  # Never minify state names (default)
-    ENABLED = "enabled"  # Minify states that have explicit state_id
-    ENFORCE = "enforce"  # Require all non-mixin states to have state_id
+    DISABLED = "disabled"  # Never minify names (default)
+    ENABLED = "enabled"  # Minify items that have explicit IDs
+    ENFORCE = "enforce"  # Require all items to have explicit IDs
 
 
 class ExecutorType(enum.Enum):
@@ -698,7 +698,10 @@ class EnvironmentVariables:
     REFLEX_STATE_SIZE_LIMIT: EnvVar[int] = env_var(1000)
 
     # State name minification mode: disabled, enabled, or enforce.
-    REFLEX_MINIFY_STATES: EnvVar[StateMinifyMode] = env_var(StateMinifyMode.DISABLED)
+    REFLEX_MINIFY_STATES: EnvVar[MinifyMode] = env_var(MinifyMode.DISABLED)
+
+    # Event handler name minification mode: disabled, enabled, or enforce.
+    REFLEX_MINIFY_EVENTS: EnvVar[MinifyMode] = env_var(MinifyMode.DISABLED)
 
     # Whether to use the turbopack bundler.
     REFLEX_USE_TURBOPACK: EnvVar[bool] = env_var(False)

reflex/event.py

@@ -89,6 +89,7 @@ def substate_token(self) -> str:
 _EVENT_FIELDS: set[str] = {f.name for f in dataclasses.fields(Event)}
 
 BACKGROUND_TASK_MARKER = "_reflex_background_task"
+EVENT_ID_MARKER = "_rx_event_id"
 
 
 @dataclasses.dataclass(
@@ -2311,6 +2312,7 @@ class EventNamespace:
 
     # Constants
     BACKGROUND_TASK_MARKER = BACKGROUND_TASK_MARKER
+    EVENT_ID_MARKER = EVENT_ID_MARKER
     _EVENT_FIELDS = _EVENT_FIELDS
     FORM_DATA = FORM_DATA
     upload_files = upload_files
@@ -2334,6 +2336,7 @@ def __new__(
         throttle: int | None = None,
         debounce: int | None = None,
         temporal: bool | None = None,
+        event_id: int | None = None,
     ) -> Callable[
         [Callable[[BASE_STATE, Unpack[P]], Any]], EventCallback[Unpack[P]]  # pyright: ignore [reportInvalidTypeVarUse]
     ]: ...
@@ -2349,6 +2352,7 @@ def __new__(
         throttle: int | None = None,
         debounce: int | None = None,
         temporal: bool | None = None,
+        event_id: int | None = None,
     ) -> EventCallback[Unpack[P]]: ...
 
     def __new__(
@@ -2361,6 +2365,7 @@ def __new__(
         throttle: int | None = None,
         debounce: int | None = None,
         temporal: bool | None = None,
+        event_id: int | None = None,
     ) -> (
         EventCallback[Unpack[P]]
         | Callable[[Callable[[BASE_STATE, Unpack[P]], Any]], EventCallback[Unpack[P]]]
@@ -2375,6 +2380,7 @@ def __new__(
             throttle: Throttle the event handler to limit calls (in milliseconds).
             debounce: Debounce the event handler to delay calls (in milliseconds).
             temporal: Whether the event should be dropped when the backend is down.
+            event_id: Optional integer ID for deterministic minified event names.
 
         Raises:
             TypeError: If background is True and the function is not a coroutine or async generator. # noqa: DAR402
@@ -2462,6 +2468,9 @@ def wrapper(
             event_actions = _build_event_actions()
             if event_actions:
                 func._rx_event_actions = event_actions  # pyright: ignore [reportFunctionMemberAccess]
+            # Store event_id on the function for minification
+            if event_id is not None:
+                setattr(func, EVENT_ID_MARKER, event_id)
             return func  # pyright: ignore [reportReturnType]
 
         if func is not None:

reflex/state.py

@@ -42,6 +42,7 @@
 from reflex.environment import PerformanceMode, environment
 from reflex.event import (
     BACKGROUND_TASK_MARKER,
+    EVENT_ID_MARKER,
     Event,
     EventHandler,
     EventSpec,
@@ -429,6 +430,9 @@ class BaseState(EvenMoreBasicBaseState):
     # The explicit state ID for minification (None = use full name).
     _state_id: ClassVar[int | None] = None
 
+    # Per-class registry mapping event_id -> event handler name for minification.
+    _event_id_to_name: ClassVar[builtins.dict[int, str]] = {}
+
     # The parent state.
     parent_state: BaseState | None = field(default=None, is_var=False)
 
@@ -711,6 +715,36 @@ def __init_subclass__(
             cls.event_handlers[name] = handler
             setattr(cls, name, handler)
 
+        # Build event_id registry and validate uniqueness within this state class
+        cls._event_id_to_name = {}
+        missing_event_ids: list[str] = []
+        for name, fn in events.items():
+            event_id = getattr(fn, EVENT_ID_MARKER, None)
+            if event_id is not None:
+                if event_id in cls._event_id_to_name:
+                    existing_name = cls._event_id_to_name[event_id]
+                    msg = (
+                        f"Duplicate event_id={event_id} in state '{cls.__name__}': "
+                        f"handlers '{existing_name}' and '{name}' cannot share the same event_id."
+                    )
+                    raise StateValueError(msg)
+                cls._event_id_to_name[event_id] = name
+            else:
+                missing_event_ids.append(name)
+
+        # In ENFORCE mode, all event handlers must have event_id
+        from reflex.environment import MinifyMode
+
+        if (
+            environment.REFLEX_MINIFY_EVENTS.get() == MinifyMode.ENFORCE
+            and missing_event_ids
+        ):
+            msg = (
+                f"State '{cls.__name__}' in ENFORCE mode: event handlers "
+                f"{missing_event_ids} are missing required event_id."
+            )
+            raise StateValueError(msg)
+
         # Initialize per-class var dependency tracking.
         cls._var_dependencies = {}
         cls._init_var_dependency_dicts()
@@ -753,6 +787,10 @@ def _copy_fn(fn: Callable) -> Callable:
         newfn.__annotations__ = fn.__annotations__
         if mark := getattr(fn, BACKGROUND_TASK_MARKER, None):
             setattr(newfn, BACKGROUND_TASK_MARKER, mark)
+        # Preserve event_id for minification
+        event_id = getattr(fn, EVENT_ID_MARKER, None)
+        if event_id is not None:
+            object.__setattr__(newfn, EVENT_ID_MARKER, event_id)
         return newfn
 
     @staticmethod
@@ -1059,22 +1097,22 @@ def get_name(cls) -> str:
         Raises:
             StateValueError: If ENFORCE mode is set and state_id is missing.
         """
-        from reflex.environment import StateMinifyMode
+        from reflex.environment import MinifyMode
         from reflex.utils.exceptions import StateValueError
 
         module = cls.__module__.replace(".", "___")
         full_name = format.to_snake_case(f"{module}___{cls.__name__}")
 
         minify_mode = environment.REFLEX_MINIFY_STATES.get()
 
-        if minify_mode == StateMinifyMode.DISABLED:
+        if minify_mode == MinifyMode.DISABLED:
             return full_name
 
         if cls._state_id is not None:
             return _int_to_minified_name(cls._state_id)
 
         # state_id not set
-        if minify_mode == StateMinifyMode.ENFORCE:
+        if minify_mode == MinifyMode.ENFORCE:
             msg = (
                 f"State '{cls.__module__}.{cls.__name__}' is missing required state_id. "
                 f"Add state_id parameter: class {cls.__name__}(rx.State, state_id=N)"
@@ -1797,6 +1835,25 @@ async def get_var_value(self, var: Var[VAR_TYPE]) -> VAR_TYPE:
         )
         return getattr(other_state, var_data.field_name)
 
+    @classmethod
+    def _get_original_event_name(cls, minified_name: str) -> str | None:
+        """Look up the original event handler name from a minified name.
+
+        This is used when the frontend sends back minified event names
+        and the backend needs to find the actual event handler.
+
+        Args:
+            minified_name: The minified event name (e.g., 'a').
+
+        Returns:
+            The original event handler name, or None if not found.
+        """
+        # Build reverse lookup: minified_name -> original_name
+        for event_id, original_name in cls._event_id_to_name.items():
+            if _int_to_minified_name(event_id) == minified_name:
+                return original_name
+        return None
+
     def _get_event_handler(
         self, event: Event
     ) -> tuple[BaseState | StateProxy, EventHandler]:
@@ -1819,7 +1876,17 @@ def _get_event_handler(
         if not substate:
             msg = "The value of state cannot be None when processing an event."
             raise ValueError(msg)
-        handler = substate.event_handlers[name]
+
+        # Try to look up the handler directly first
+        handler = substate.event_handlers.get(name)
+        if handler is None:
+            # If not found, the name might be minified - try reverse lookup
+            original_name = substate._get_original_event_name(name)
+            if original_name is not None:
+                handler = substate.event_handlers.get(original_name)
+            if handler is None:
+                msg = f"Event handler '{name}' not found in state '{type(substate).__name__}'"
+                raise KeyError(msg)
 
         # For background tasks, proxy the state
         if handler.is_background:

reflex/utils/format.py

@@ -446,8 +446,12 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
         handler: The event handler to get the parts of.
 
     Returns:
-        The state and function name.
+        The state and function name (possibly minified based on REFLEX_MINIFY_EVENTS).
     """
+    from reflex.environment import MinifyMode, environment
+    from reflex.event import EVENT_ID_MARKER
+    from reflex.state import State, _int_to_minified_name
+
     # Get the class that defines the event handler.
     parts = handler.fn.__qualname__.split(".")
 
@@ -461,11 +465,16 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     # Get the function name
     name = parts[-1]
 
-    from reflex.state import State
-
     if state_full_name == FRONTEND_EVENT_STATE and name not in State.__dict__:
         return ("", to_snake_case(handler.fn.__qualname__))
 
+    # Check for event_id minification
+    mode = environment.REFLEX_MINIFY_EVENTS.get()
+    if mode != MinifyMode.DISABLED:
+        event_id = getattr(handler.fn, EVENT_ID_MARKER, None)
+        if event_id is not None:
+            name = _int_to_minified_name(event_id)
+
     return (state_full_name, name)