add url and route_id to routerdata as a replacement for pagedata (#5516)

adhami3310 · web-flow · commit a83ce0cdae5a · 2025-07-02T10:15:28.000-07:00
* add url and route_id to routerdata as a replacement for pagedata

* best effort to deprecate `page`

* use from_router_data

* call dataclasses.fields once
diff --git a/reflex/.templates/web/utils/state.js b/reflex/.templates/web/utils/state.js
@@ -370,7 +370,10 @@ export const applyEvent = async (event, socket, navigate, params) => {
         ...Object.fromEntries(new URLSearchParams(window.location.search)),
         ...params(),
       },
-      asPath: window.location.pathname + window.location.search,
+      asPath:
+        window.location.pathname +
+        window.location.search +
+        window.location.hash,
     };
   }
 
diff --git a/reflex/app.py b/reflex/app.py
@@ -1741,7 +1741,7 @@ async def process(
                     if (path := router_data.get(constants.RouteVar.PATH))
                     else "404"
                 ).removeprefix("/")
-                state.router = RouterData(router_data)
+                state.router = RouterData.from_router_data(router_data)
 
             # Preprocess the event.
             update = await app._preprocess(state, event)
diff --git a/reflex/istate/data.py b/reflex/istate/data.py
@@ -2,9 +2,11 @@
 
 import dataclasses
 from collections.abc import Mapping
+from typing import TYPE_CHECKING
+from urllib.parse import _NetlocResultMixinStr, urlsplit
 
 from reflex import constants
-from reflex.utils import format
+from reflex.utils import console, format
 from reflex.utils.serializers import serializer
 
 
@@ -45,36 +47,40 @@ class _HeaderData:
     )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+_HEADER_DATA_FIELDS = frozenset(
+    [field.name for field in dataclasses.fields(_HeaderData)]
+)
+
+
+@dataclasses.dataclass(frozen=True)
 class HeaderData(_HeaderData):
     """An object containing headers data."""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the HeaderData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "HeaderData":
+        """Create a HeaderData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A HeaderData object initialized with the provided router_data.
         """
-        super().__init__()
-        if router_data:
-            fields_names = [f.name for f in dataclasses.fields(self)]
-            for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items():
-                snake_case_key = format.to_snake_case(k)
-                if snake_case_key in fields_names:
-                    object.__setattr__(self, snake_case_key, v)
-            object.__setattr__(
-                self,
-                "raw_headers",
-                _FrozenDictStrStr(
-                    **{
-                        k: v
-                        for k, v in router_data.get(
-                            constants.RouteVar.HEADERS, {}
-                        ).items()
-                        if v
-                    }
-                ),
-            )
+        return cls(
+            **{
+                snake_case_key: v
+                for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                if v
+                and (snake_case_key := format.to_snake_case(k)) in _HEADER_DATA_FIELDS
+            },
+            raw_headers=_FrozenDictStrStr(
+                **{
+                    k: v
+                    for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                    if v
+                }
+            ),
+        )
 
 
 @serializer(to=dict)
@@ -90,6 +96,35 @@ def serialize_frozen_dict_str_str(obj: _FrozenDictStrStr) -> dict:
     return dict(obj._data)
 
 
+class ReflexURL(str, _NetlocResultMixinStr):
+    """A class representing a URL split result."""
+
+    if TYPE_CHECKING:
+        scheme: str
+        netloc: str
+        path: str
+        query: str
+        fragment: str
+
+    def __new__(cls, url: str):
+        """Create a new ReflexURL instance.
+
+        Args:
+            url: the URL to split.
+
+        Returns:
+            A new ReflexURL instance.
+        """
+        (scheme, netloc, path, query, fragment) = urlsplit(url)
+        obj = super().__new__(cls, url)
+        object.__setattr__(obj, "scheme", scheme)
+        object.__setattr__(obj, "netloc", netloc)
+        object.__setattr__(obj, "path", path)
+        object.__setattr__(obj, "query", query)
+        object.__setattr__(obj, "fragment", fragment)
+        return obj
+
+
 @dataclasses.dataclass(frozen=True)
 class PageData:
     """An object containing page data."""
@@ -101,77 +136,115 @@ class PageData:
     full_raw_path: str = ""
     params: dict = dataclasses.field(default_factory=dict)
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the PageData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "PageData":
+        """Create a PageData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A PageData object initialized with the provided router_data.
         """
-        if router_data:
-            object.__setattr__(
-                self,
-                "host",
-                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", ""),
-            )
-            object.__setattr__(
-                self, "path", router_data.get(constants.RouteVar.PATH, "")
-            )
-            object.__setattr__(
-                self, "raw_path", router_data.get(constants.RouteVar.ORIGIN, "")
-            )
-            object.__setattr__(self, "full_path", f"{self.host}{self.path}")
-            object.__setattr__(self, "full_raw_path", f"{self.host}{self.raw_path}")
-            object.__setattr__(
-                self, "params", router_data.get(constants.RouteVar.QUERY, {})
-            )
-        else:
-            object.__setattr__(self, "host", "")
-            object.__setattr__(self, "path", "")
-            object.__setattr__(self, "raw_path", "")
-            object.__setattr__(self, "full_path", "")
-            object.__setattr__(self, "full_raw_path", "")
-            object.__setattr__(self, "params", {})
+        host = router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+        path = router_data.get(constants.RouteVar.PATH, "")
+        raw_path = router_data.get(constants.RouteVar.ORIGIN, "")
+        return cls(
+            host=host,
+            path=path,
+            raw_path=raw_path,
+            full_path=f"{host}{path}",
+            full_raw_path=f"{host}{raw_path}",
+            params=router_data.get(constants.RouteVar.QUERY, {}),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class SessionData:
     """An object containing session data."""
 
     client_token: str = ""
     client_ip: str = ""
     session_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the SessionData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "SessionData":
+        """Create a SessionData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A SessionData object initialized with the provided router_data.
         """
-        if router_data:
-            client_token = router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
-            client_ip = router_data.get(constants.RouteVar.CLIENT_IP, "")
-            session_id = router_data.get(constants.RouteVar.SESSION_ID, "")
-        else:
-            client_token = client_ip = session_id = ""
-        object.__setattr__(self, "client_token", client_token)
-        object.__setattr__(self, "client_ip", client_ip)
-        object.__setattr__(self, "session_id", session_id)
+        return cls(
+            client_token=router_data.get(constants.RouteVar.CLIENT_TOKEN, ""),
+            client_ip=router_data.get(constants.RouteVar.CLIENT_IP, ""),
+            session_id=router_data.get(constants.RouteVar.SESSION_ID, ""),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class RouterData:
     """An object containing RouterData."""
 
     session: SessionData = dataclasses.field(default_factory=SessionData)
     headers: HeaderData = dataclasses.field(default_factory=HeaderData)
-    page: PageData = dataclasses.field(default_factory=PageData)
+    _page: PageData = dataclasses.field(default_factory=PageData)
+    url: ReflexURL = dataclasses.field(default=ReflexURL(""))
+    route_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the RouterData object.
+    @property
+    def page(self) -> PageData:
+        """Get the page data.
+
+        Returns:
+            The PageData object.
+        """
+        console.deprecate(
+            "RouterData.page",
+            "Use RouterData.url instead",
+            deprecation_version="0.8.1",
+            removal_version="0.9.0",
+        )
+        return self._page
+
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "RouterData":
+        """Create a RouterData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A RouterData object initialized with the provided router_data.
         """
-        object.__setattr__(self, "session", SessionData(router_data))
-        object.__setattr__(self, "headers", HeaderData(router_data))
-        object.__setattr__(self, "page", PageData(router_data))
+        return cls(
+            session=SessionData.from_router_data(router_data),
+            headers=HeaderData.from_router_data(router_data),
+            _page=PageData.from_router_data(router_data),
+            url=ReflexURL(
+                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+                + router_data.get(constants.RouteVar.ORIGIN, "")
+            ),
+            route_id=router_data.get(constants.RouteVar.PATH, ""),
+        )
+
+
+@serializer(to=dict)
+def serialize_router_data(obj: RouterData) -> dict:
+    """Serialize a RouterData object to a dict.
+
+    Args:
+        obj: the RouterData object.
+
+    Returns:
+        A dict representation of the RouterData object.
+    """
+    return {
+        "session": obj.session,
+        "headers": obj.headers,
+        "page": obj._page,
+        "url": obj.url,
+        "route_id": obj.route_id,
+    }
diff --git a/reflex/state.py b/reflex/state.py
@@ -1204,15 +1204,15 @@ def setup_dynamic_args(cls, args: dict[str, str]):
 
         def argsingle_factory(param: str):
             def inner_func(self: BaseState) -> str:
-                return self.router.page.params.get(param, "")
+                return self.router._page.params.get(param, "")
 
             inner_func.__name__ = param
 
             return inner_func
 
         def arglist_factory(param: str):
             def inner_func(self: BaseState) -> list[str]:
-                return self.router.page.params.get(param, [])
+                return self.router._page.params.get(param, [])
 
             inner_func.__name__ = param
 
@@ -2466,7 +2466,7 @@ def on_load_internal(self) -> list[Event | EventSpec | event.EventCallback] | No
         """
         # Do not app._compile()!  It should be already compiled by now.
         load_events = prerequisites.get_and_validate_app().app.get_load_events(
-            self.router.page.path
+            self.router._page.path
         )
         if not load_events:
             self.is_hydrated = True
diff --git a/tests/units/test_app.py b/tests/units/test_app.py
@@ -1085,7 +1085,7 @@ def _dynamic_state_event(name, val, **kwargs):
             "token": token,
             **on_load_internal.router_data,
         }
-        exp_router = RouterData(exp_router_data)
+        exp_router = RouterData.from_router_data(exp_router_data)
         process_coro = process(
             app,
             event=on_load_internal,
@@ -1475,7 +1475,7 @@ def test_app_state_determination():
     assert a3._state is None
 
     # Referencing router enables state.
-    a3.add_page(rx.box(rx.text(State.router.page.full_path)), route="/")
+    a3.add_page(rx.box(rx.text(State.router._page.full_path)), route="/")
     a3._compile_page("index")
     assert a3._state is not None
 
diff --git a/tests/units/test_state.py b/tests/units/test_state.py
diff --git a/tests/units/utils/test_format.py b/tests/units/utils/test_format.py
