replace "reload" functionality with internal rehydration

instead of telling the frontend to reload, just hydrate and run on_load
internally before processing the user's requested event.

Author: masenf

packages/reflex-core/src/reflex_core/.templates/web/utils/state.js

@@ -672,10 +672,6 @@ export const connect = async (
       queueEvents(update.events, socket, false, navigate, params);
     }
   });
-  socket.current.on("reload", async (event) => {
-    on_hydrated_queue.push(event);
-    queueEvents(initialEvents(), socket, true, navigate, params);
-  });
   socket.current.on("new_token", async (new_token) => {
     token = new_token;
     window.sessionStorage.setItem(TOKEN_KEY, new_token);

packages/reflex-core/src/reflex_core/_internal/event/processor/base_state_processor.py

@@ -19,12 +19,20 @@
     EventQueueEntry,
     RegisteredEventHandler,
 )
+from reflex_core.utils.format import format_event_handler
 
 if TYPE_CHECKING:
     from reflex.event import EventHandler, EventSpec
     from reflex.state import BaseState
 
 
+@functools.lru_cache(maxsize=1)
+def _hydrate_event_name():
+    from reflex.state import State
+
+    return format_event_handler(State.event_handlers["hydrate"])
+
+
 def _check_valid_yield(events: Any, handler_name: str = "unknown") -> Any:
     """Check if the events yielded are valid. They must be EventHandlers or EventSpecs.
 
@@ -271,6 +279,33 @@ class BaseStateEventProcessor(EventProcessor):
     frontend.
     """
 
+    async def _rehydrate(self, root_state: BaseState):
+        """Rehydrate the state by calling the hydrate event handler.
+
+        Args:
+            root_state: The root state to rehydrate.
+        """
+        from reflex.state import OnLoadInternalState, State
+
+        if (
+            type(root_state) is not State
+            or OnLoadInternalState.get_name() not in root_state.substates
+        ):
+            return
+
+        await process_event(
+            handler=State.event_handlers["hydrate"],
+            payload={},
+            state=root_state,
+            root_state=root_state,
+        )
+        await process_event(
+            handler=OnLoadInternalState.event_handlers["on_load_internal"],
+            payload={},
+            state=await root_state.get_state(OnLoadInternalState),
+            root_state=root_state,
+        )
+
     async def _process_event_queue_entry(
         self, *, entry: EventQueueEntry, registered_handler: RegisteredEventHandler
     ) -> None:
@@ -295,7 +330,10 @@ async def _process_event_queue_entry(
             ),
             event=entry.event,
         ) as state:
-            # TODO: handle "reload" trigger of brand new state instances
+            # Compatibility hack rehydrate the state before processing this event.
+            needs_to_rehydrate = bool(
+                not state.router_data and event.name != _hydrate_event_name()
+            )
 
             # re-assign only when the value is set and different
             if router_data and state.router_data != router_data:
@@ -322,6 +360,9 @@ async def _process_event_queue_entry(
             substate = await state.get_state(event.state_cls)
             root_state = state._get_root_state()
 
+            if needs_to_rehydrate:
+                await self._rehydrate(root_state)
+
             # Process non-background events while holding the lock.
             if not registered_handler.handler.is_background:
                 await process_event(

tests/units/conftest.py

@@ -281,12 +281,18 @@ def handle_backend_exception(ex: Exception) -> None:
 
 
 @pytest.fixture
-def mock_base_state_event_processor_obj() -> BaseStateEventProcessor:
+def mock_base_state_event_processor_obj(
+    monkeypatch: pytest.MonkeyPatch,
+) -> BaseStateEventProcessor:
     """Create a BaseState event processor.
 
+    Args:
+        monkeypatch: pytest monkeypatch fixture.
+
     Returns:
         A fresh BaseState event processor.
     """
+    monkeypatch.setattr(BaseStateEventProcessor, "_rehydrate", mock.AsyncMock())
 
     def handle_backend_exception(ex: Exception) -> None:
         formatted_exc = "\n".join(traceback.format_exception(ex))