2nd self review

Author: Archmonger

src/reactpy_django/auth/components.py

@@ -20,6 +20,8 @@
 
 @component
 def root_manager(child: Any):
+    """This component is serves as the parent component for any ReactPy component tree,
+    which allows for the management of the entire component tree."""
     scope = hooks.use_connection().scope
     _, set_rerender = hooks.use_state(uuid4)
 
@@ -29,7 +31,7 @@ def setup_asgi_scope():
         any relevant actions."""
         scope["reactpy"]["rerender"] = rerender
 
-    async def rerender():
+    def rerender():
         """Event that can force a rerender of the entire component tree."""
         set_rerender(uuid4())
 
@@ -44,7 +46,7 @@ def auth_manager():
     Used to force persistent authentication between Django's websocket and HTTP stack."""
     from reactpy_django import config
 
-    synchronize_requested, set_synchronize_requested = hooks.use_state(False)
+    sync_needed, set_sync_needed = hooks.use_state(False)
     token = hooks.use_ref("")
     scope = hooks.use_connection().scope
 
@@ -54,19 +56,19 @@ def setup_asgi_scope():
         any relevant actions."""
         scope["reactpy"]["synchronize_auth"] = synchronize_auth
 
-    @hooks.use_effect(dependencies=[synchronize_requested])
+    @hooks.use_effect(dependencies=[sync_needed])
     async def synchronize_auth_watchdog():
-        """Detected if the client has taken too long to request a auth session synchronization.
+        """Detect if the client has taken too long to request a auth session synchronization.
 
         This effect will automatically be cancelled if the session is successfully
         synchronized (via effect dependencies)."""
-        if synchronize_requested:
+        if sync_needed:
             await asyncio.sleep(config.REACTPY_AUTH_TOKEN_TIMEOUT + 0.1)
             await asyncio.to_thread(
                 _logger.warning,
                 f"Client did not switch authentication sessions within {config.REACTPY_AUTH_TOKEN_TIMEOUT} (REACTPY_AUTH_TOKEN_TIMEOUT) seconds.",
             )
-            set_synchronize_requested(False)
+            set_sync_needed(False)
 
     async def synchronize_auth():
         """Event that can command the client to switch HTTP auth sessions (to match the websocket session)."""
@@ -88,12 +90,12 @@ async def synchronize_auth():
         # Begin the process of synchronizing HTTP and websocket auth sessions
         obj = await AuthToken.objects.acreate(value=token.current, session_key=session.session_key)
         await obj.asave()
-        set_synchronize_requested(True)
+        set_sync_needed(True)
 
     async def synchronize_auth_callback(status_code: int, response: str):
         """This callback acts as a communication bridge, allowing the client to notify the server
         of the status of auth session switch."""
-        set_synchronize_requested(False)
+        set_sync_needed(False)
         if status_code >= 300 or status_code < 200:
             await asyncio.to_thread(
                 _logger.error,
@@ -103,7 +105,7 @@ async def synchronize_auth_callback(status_code: int, response: str):
     # If needed, synchronize authenication sessions by configuring all relevant session cookies.
     # This is achieved by commanding the client to perform a HTTP request to our session manager endpoint,
     # which will set any required cookies.
-    if synchronize_requested:
+    if sync_needed:
         return HttpRequest(
             {
                 "method": "GET",

src/reactpy_django/hooks.py

@@ -33,6 +33,7 @@
     Mutation,
     Query,
     SyncPostprocessor,
+    UseAuthTuple,
     UserData,
 )
 from reactpy_django.utils import django_query_postprocessor, ensure_async, generate_obj_name, get_pk
@@ -417,37 +418,35 @@ def use_root_id() -> str:
     return scope["reactpy"]["id"]
 
 
-def use_auth():
+def use_rerender() -> Callable[[], None]:
+    """Provides a callable that can re-render the entire component tree without disconnecting the websocket."""
+    scope = use_scope()
+    return scope["reactpy"]["rerender"]
+
+
+def use_auth() -> UseAuthTuple:
     """Provides the ability to login/logout a user using Django's authentication framework."""
     from reactpy_django import config
 
     scope = use_scope()
+    trigger_rerender = use_rerender()
 
-    async def login(user: AbstractUser, rerender: bool = True):
-        """Login a user.
-
-        Args:
-            user: The user to login.
-            rerender: If True, the root component will be re-rendered after the user is logged in."""
+    async def login(user: AbstractUser, rerender: bool = True) -> None:
         await channels_auth.login(scope, user, backend=config.REACTPY_AUTH_BACKEND)
         session_save_method = getattr(scope["session"], "asave", scope["session"].save)
         await ensure_async(session_save_method)()
         await scope["reactpy"]["synchronize_auth"]()
 
         if rerender:
-            await scope["reactpy"]["rerender"]()
-
-    async def logout(rerender: bool = True):
-        """Logout the current user.
+            trigger_rerender()
 
-        Args:
-            rerender: If True, the root component will be re-rendered after the user is logged out."""
+    async def logout(rerender: bool = True) -> None:
         await channels_auth.logout(scope)
 
         if rerender:
-            await scope["reactpy"]["rerender"]()
+            trigger_rerender()
 
-    return login, logout
+    return UseAuthTuple(login=login, logout=logout)
 
 
 async def _get_user_data(user: AbstractUser, default_data: None | dict, save_default_data: bool) -> dict | None:

src/reactpy_django/types.py

@@ -19,6 +19,7 @@
 if TYPE_CHECKING:
     from collections.abc import MutableMapping, Sequence
 
+    from django.contrib.auth.models import AbstractUser
     from django.forms import Form, ModelForm
 
     from reactpy_django.websocket.consumer import ReactpyAsyncWebsocketConsumer
@@ -108,3 +109,26 @@ def __call__(
 
 class ViewToIframeConstructor(Protocol):
     def __call__(self, *args: Any, key: Key | None = None, **kwargs: Any) -> ComponentType: ...
+
+
+class UseAuthLogin(Protocol):
+    async def __call__(self, user: AbstractUser, rerender: bool = True) -> None: ...
+
+
+class UseAuthLogout(Protocol):
+    async def __call__(self, rerender: bool = True) -> None: ...
+
+
+class UseAuthTuple(NamedTuple):
+    login: UseAuthLogin
+    """Login a user.
+
+        Args:
+            user: The user to login.
+            rerender: If True, the root component will be re-rendered after the user is logged in."""
+
+    logout: UseAuthLogout
+    """Logout the current user.
+
+        Args:
+            rerender: If True, the root component will be re-rendered after the user is logged out."""