encode redirect as server error

Author: dprkh

packages/core/src/control_flow.rs

@@ -10,7 +10,6 @@ mod effect;
 mod error_boundary;
 mod events;
 mod fragment;
-mod control_flow;
 mod generational_box;
 mod global_context;
 mod launch;
@@ -31,11 +30,6 @@ mod virtual_dom;
 
 mod hotreload_utils;
 
-// This is intentionally public (but hidden from docs) so integration crates can use it without
-// creating dependency cycles back into core.
-#[doc(hidden)]
-pub use control_flow::RedirectControlFlow;
-
 /// Items exported from this module are used in macros and should not be used directly.
 #[doc(hidden)]
 pub mod internal {

packages/core/src/lib.rs

@@ -108,20 +108,7 @@ impl VirtualDom {
     fn handle_element_return(&self, node: &mut Element, scope: &Scope) {
         match node {
             Err(RenderError::Error(e)) => {
-                // Redirects are expected control-flow in some integrations (like fullstack SSR)
-                // and shouldn't be logged as errors.
-                //
-                // We detect these via a core-owned marker error (`RedirectControlFlow`) attached
-                // as a `source()` by integration crates to avoid dependency cycles.
-                let is_redirect = e
-                    .chain()
-                    .any(|cause| cause.is::<crate::RedirectControlFlow>());
-
-                if is_redirect {
-                    tracing::info!("Redirect while rendering component `{}`: {e}", scope.name);
-                } else {
-                    tracing::error!("Error while rendering component `{}`: {e}", scope.name);
-                }
+                tracing::error!("Error while rendering component `{}`: {e}", scope.name);
                 self.runtime.throw_error(scope.id, e.clone());
             }
             Err(RenderError::Suspended(e)) => {

packages/core/src/scope_arena.rs

@@ -1,8 +1,8 @@
 use axum_core::response::IntoResponse;
 use futures_util::TryStreamExt;
+use http::header::LOCATION;
 use http::StatusCode;
 use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
 
 use crate::HttpError;
 
@@ -30,7 +30,7 @@ pub enum ServerFnError {
     /// The `details` field can optionally contain additional structured information about the error.
     /// When passing typed errors from the server to the client, the `details` field contains the serialized
     /// representation of the error.
-    #[error("error running server function: {message} (details: {details:#?})")]
+    #[error("error running server function: {message} (details: {details:?})")]
     ServerError {
         /// A human-readable message describing the error.
         message: String,
@@ -81,23 +81,19 @@ pub enum ServerFnError {
     /// Occurs on the server if there is an error creating an HTTP response.
     #[error("error creating response {0}")]
     Response(String),
+}
 
-    /// A redirect response returned while running a server function or extractor.
-    ///
-    /// This is treated as control-flow rather than an ordinary error so we can preserve the
-    /// `Location` header (which is otherwise lost when converting axum responses into `ServerFnError`).
-    #[error("redirect ({code}) to {location}")]
-    Redirect {
-        /// HTTP status code associated with the redirect (typically 302/303/307/308).
-        code: u16,
-        /// The value of the `Location` header.
-        location: String,
-        /// Marker source to let core treat this as expected control-flow (not an error log).
-        #[doc(hidden)]
-        #[serde(skip, default)]
-        #[source]
-        control_flow: dioxus_core::RedirectControlFlow,
-    },
+// Reserved key used to encode redirects in `ServerFnError::ServerError.details`.
+const REDIRECT_DETAILS_KEY: &str = "__dioxus_redirect";
+
+fn is_redirection_code(code: u16) -> bool {
+    (300..400).contains(&code)
+}
+
+fn redirect_location_from_details(details: &Option<serde_json::Value>) -> Option<&str> {
+    let details = details.as_ref()?;
+    let obj = details.as_object()?;
+    obj.get(REDIRECT_DETAILS_KEY)?.as_str()
 }
 
 impl ServerFnError {
@@ -112,18 +108,38 @@ impl ServerFnError {
 
     /// Create a redirect error (control-flow) with a status code and `Location`.
     pub fn redirect(code: u16, location: impl Into<String>) -> Self {
-        ServerFnError::Redirect {
+        let location = location.into();
+        ServerFnError::ServerError {
+            message: format!("redirect ({code}) to {location}"),
+            details: Some(serde_json::json!({ REDIRECT_DETAILS_KEY: location })),
             code,
-            location: location.into(),
-            control_flow: dioxus_core::RedirectControlFlow::default(),
+        }
+    }
+
+    /// Returns the redirect location if this error represents a redirect.
+    pub fn redirect_location(&self) -> Option<&str> {
+        match self {
+            ServerFnError::ServerError { code, details, .. } if is_redirection_code(*code) => {
+                redirect_location_from_details(details)
+            }
+            _ => None,
         }
     }
 
     /// Create a new server error (status code 500) with a message and details.
     pub async fn from_axum_response(resp: axum_core::response::Response) -> Self {
-        let status = resp.status();
-        let message = resp
-            .into_body()
+        let (parts, body) = resp.into_parts();
+        let status = parts.status;
+
+        // If this is a redirect, preserve the location in structured details so other layers
+        // (like SSR) can turn it back into a redirect response.
+        if status.is_redirection() {
+            if let Some(location) = parts.headers.get(LOCATION).and_then(|v| v.to_str().ok()) {
+                return ServerFnError::redirect(status.as_u16(), location);
+            }
+        }
+
+        let message = body
             .into_data_stream()
             .try_fold(Vec::new(), |mut acc, chunk| async move {
                 acc.extend_from_slice(&chunk);
@@ -164,9 +180,6 @@ impl From<ServerFnError> for http::StatusCode {
             ServerFnError::ServerError { code, .. } => {
                 http::StatusCode::from_u16(code).unwrap_or(http::StatusCode::INTERNAL_SERVER_ERROR)
             }
-            ServerFnError::Redirect { code, .. } => {
-                http::StatusCode::from_u16(code).unwrap_or(http::StatusCode::INTERNAL_SERVER_ERROR)
-            }
             ServerFnError::Request(err) => match err {
                 RequestError::Status(_, code) => http::StatusCode::from_u16(code)
                     .unwrap_or(http::StatusCode::INTERNAL_SERVER_ERROR),
@@ -195,7 +208,6 @@ impl From<ServerFnError> for HttpError {
     fn from(value: ServerFnError) -> Self {
         let status = StatusCode::from_u16(match &value {
             ServerFnError::ServerError { code, .. } => *code,
-            ServerFnError::Redirect { code, .. } => *code,
             _ => 500,
         })
         .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
@@ -225,23 +237,6 @@ impl From<HttpError> for ServerFnError {
 impl IntoResponse for ServerFnError {
     fn into_response(self) -> axum_core::response::Response {
         match self {
-            Self::Redirect { code, location, .. } => {
-                use http::header::LOCATION;
-                let status =
-                    StatusCode::from_u16(code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
-                axum_core::response::Response::builder()
-                    .status(status)
-                    .header(LOCATION, location)
-                    .body(axum_core::body::Body::empty())
-                    .unwrap_or_else(|_| {
-                        axum_core::response::Response::builder()
-                            .status(StatusCode::INTERNAL_SERVER_ERROR)
-                            .body(axum_core::body::Body::from(
-                                "{\"error\":\"Internal Server Error\"}",
-                            ))
-                            .unwrap()
-                    })
-            }
             Self::ServerError {
                 message,
                 code,

packages/fullstack-core/src/error.rs

@@ -2,7 +2,6 @@ use crate::{HttpError, ServerFnError};
 use axum_core::extract::FromRequest;
 use axum_core::response::IntoResponse;
 use dioxus_core::{CapturedError, ReactiveContext};
-use http::header::LOCATION;
 use http::StatusCode;
 use http::{request::Parts, HeaderMap};
 use parking_lot::RwLock;
@@ -147,19 +146,6 @@ impl FullstackContext {
             Ok(res) => Ok(res),
             Err(err) => {
                 let resp = err.into_response();
-
-                // Preserve redirects from axum-style extractors (3xx + Location) as control-flow.
-                // If we collapse this response into `ServerFnError::ServerError`, we lose headers like
-                // `Location` and redirects silently stop working.
-                let status = resp.status();
-                if status.is_redirection() {
-                    if let Some(location) = resp.headers().get(LOCATION) {
-                        if let Ok(location) = location.to_str() {
-                            return Err(ServerFnError::redirect(status.as_u16(), location));
-                        }
-                    }
-                }
-
                 Err(ServerFnError::from_axum_response(resp).await)
             }
         }
@@ -397,12 +383,12 @@ mod tests {
                 .await
                 .unwrap_err();
 
-            match err {
-                ServerFnError::Redirect { code, location, .. } => {
-                    assert_eq!(code, StatusCode::TEMPORARY_REDIRECT.as_u16());
-                    assert_eq!(location, "/sign-in");
+            match &err {
+                ServerFnError::ServerError { code, .. } => {
+                    assert_eq!(*code, StatusCode::TEMPORARY_REDIRECT.as_u16());
+                    assert_eq!(err.redirect_location(), Some("/sign-in"));
                 }
-                other => panic!("expected ServerFnError::Redirect, got {other:?}"),
+                other => panic!("expected redirect-like ServerFnError, got {other:?}"),
             }
         });
     }

packages/fullstack-core/src/streaming.rs

@@ -262,28 +262,28 @@ impl SsrRendererPool {
                 // todo - the user is allowed to return anything that impls `From<ServerFnError>`
                 // we need to eventually be able to downcast that and get the status code from it
                 if let Some(server_fn_error) = error.downcast_ref::<ServerFnError>() {
-                    match server_fn_error {
-                        ServerFnError::ServerError { message, code, .. } => {
+                    // Redirects are encoded as `ServerError` with a redirect status and structured details.
+                    if let Some(location) = server_fn_error.redirect_location() {
+                        if let ServerFnError::ServerError { code, .. } = server_fn_error {
                             status_code = Some(
                                 (*code)
                                     .try_into()
                                     .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
                             );
-                            out_message = Some(message.clone());
                         }
-                        ServerFnError::Redirect { code, location, .. } => {
-                            status_code = Some(
-                                (*code)
-                                    .try_into()
-                                    .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-                            );
-                            // Redirects are control-flow; no message body by default.
-                            out_message = None;
-                            if let Ok(value) = HeaderValue::from_str(location) {
-                                out_headers.insert(LOCATION, value);
-                            }
+                        // Redirects are control-flow; no message body by default.
+                        out_message = None;
+                        if let Ok(value) = HeaderValue::from_str(location) {
+                            out_headers.insert(LOCATION, value);
                         }
-                        _ => {}
+                    } else if let ServerFnError::ServerError { message, code, .. } = server_fn_error
+                    {
+                        status_code = Some(
+                            (*code)
+                                .try_into()
+                                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
+                        );
+                        out_message = Some(message.clone());
                     }
                 }
 

packages/fullstack-server/src/ssr.rs

@@ -428,11 +428,6 @@ mod decode_ok {
                                 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
                         }
 
-                        ServerFnError::Redirect { code, .. } => {
-                            Err(StatusCode::from_u16(code)
-                                .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
-                        }
-
                         ServerFnError::Registration(_) | ServerFnError::MiddlewareError(_) => {
                             Err(StatusCode::INTERNAL_SERVER_ERROR)
                         }