allow to enable/disable state and event ID minification independently via env vars

Author: benedikt-bartscher

reflex/environment.py

@@ -478,6 +478,13 @@ class PathExistsFlag:
 ExistingPath = Annotated[Path, PathExistsFlag]
 
 
+class MinifyMode(enum.Enum):
+    """Mode for minification of state/event IDs."""
+
+    ENABLED = "enabled"
+    DISABLED = "disabled"
+
+
 class PerformanceMode(enum.Enum):
     """Performance mode for the app."""
 
@@ -762,6 +769,12 @@ class EnvironmentVariables:
     # How long to opportunistically hold the redis lock in milliseconds (must be less than the token expiration).
     REFLEX_OPLOCK_HOLD_TIME_MS: EnvVar[int] = env_var(0)
 
+    # Whether to enable state ID minification (requires minify.json).
+    REFLEX_MINIFY_STATE: EnvVar[MinifyMode] = env_var(MinifyMode.DISABLED)
+
+    # Whether to enable event ID minification (requires minify.json).
+    REFLEX_MINIFY_EVENTS: EnvVar[MinifyMode] = env_var(MinifyMode.DISABLED)
+
 
 environment = EnvironmentVariables()
 

reflex/minify.py

@@ -115,12 +115,46 @@ def get_minify_config() -> MinifyConfig | None:
 
 
 def is_minify_enabled() -> bool:
-    """Check if minification is enabled.
+    """Check if any minification is enabled (state or event).
 
     Returns:
-        True if minify.json exists and is valid.
+        True if either state or event minification is enabled.
     """
-    return get_minify_config() is not None
+    return is_state_minify_enabled() or is_event_minify_enabled()
+
+
+@functools.cache
+def is_state_minify_enabled() -> bool:
+    """Check if state ID minification is enabled.
+
+    Requires both REFLEX_MINIFY_STATE=enabled and minify.json to exist.
+
+    Returns:
+        True if state minification is enabled.
+    """
+    from reflex.environment import MinifyMode, environment
+
+    return (
+        environment.REFLEX_MINIFY_STATE.get() == MinifyMode.ENABLED
+        and get_minify_config() is not None
+    )
+
+
+@functools.cache
+def is_event_minify_enabled() -> bool:
+    """Check if event ID minification is enabled.
+
+    Requires both REFLEX_MINIFY_EVENTS=enabled and minify.json to exist.
+
+    Returns:
+        True if event minification is enabled.
+    """
+    from reflex.environment import MinifyMode, environment
+
+    return (
+        environment.REFLEX_MINIFY_EVENTS.get() == MinifyMode.ENABLED
+        and get_minify_config() is not None
+    )
 
 
 def get_state_id(state_full_path: str) -> str | None:
@@ -175,6 +209,8 @@ def clear_config_cache() -> None:
     This should be called after modifying minify.json programmatically.
     """
     get_minify_config.cache_clear()
+    is_state_minify_enabled.cache_clear()
+    is_event_minify_enabled.cache_clear()
 
 
 # Base-54 encoding for minified names

reflex/reflex.py

@@ -1017,9 +1017,9 @@ def minify_list(output_json: bool):
 
     from reflex.minify import (
         get_event_id,
+        get_minify_config,
         get_state_full_path,
         get_state_id,
-        is_minify_enabled,
     )
     from reflex.state import BaseState, State
     from reflex.utils import prerequisites
@@ -1042,7 +1042,8 @@ class StateTreeData(TypedDict):
     # Load the user's app to register all state classes
     prerequisites.get_app()
 
-    minify_enabled = is_minify_enabled()
+    # CLI inspection always shows config contents regardless of env var settings
+    minify_enabled = get_minify_config() is not None
 
     def build_state_tree(state_cls: type[BaseState]) -> StateTreeData:
         """Recursively build state tree data.

reflex/state.py

@@ -694,9 +694,13 @@ def _register_event_handler_for_minify(cls, handler_name: str) -> None:
         Args:
             handler_name: The original name of the event handler.
         """
-        from reflex.minify import get_event_id, get_minify_config, get_state_full_path
+        from reflex.minify import (
+            get_event_id,
+            get_state_full_path,
+            is_event_minify_enabled,
+        )
 
-        if get_minify_config() is None:
+        if not is_event_minify_enabled():
             return
 
         state_path = get_state_full_path(cls)
@@ -1030,13 +1034,17 @@ def get_name(cls) -> str:
         Returns:
             The name of the state (minified if configured in minify.json).
         """
-        from reflex.minify import get_state_full_path, get_state_id, is_minify_enabled
+        from reflex.minify import (
+            get_state_full_path,
+            get_state_id,
+            is_state_minify_enabled,
+        )
 
         module = cls.__module__.replace(".", "___")
         full_name = format.to_snake_case(f"{module}___{cls.__name__}")
 
-        # If minification is enabled, look up the state ID from minify.json
-        if is_minify_enabled():
+        # If state minification is enabled, look up the state ID from minify.json
+        if is_state_minify_enabled():
             state_path = get_state_full_path(cls)
             state_id = get_state_id(state_path)
             if state_id is not None:

reflex/utils/format.py

@@ -452,7 +452,7 @@ def get_event_handler_parts(
         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.minify import is_event_minify_enabled
     from reflex.state import State
 
     # Cast for type checker - at runtime this is always an EventHandler
@@ -477,7 +477,7 @@ def get_event_handler_parts(
     # Check for event_id minification from minify.json
     # The state class stores its event ID mapping in _event_id_to_name
     # where key is minified_name and value is original_handler_name
-    if is_minify_enabled():
+    if is_event_minify_enabled():
         try:
             # Get the state class using the path
             state_cls = State.get_class_substate(state_full_name)