support redirecting from extractors

dprkh · dprkh · commit c6ec0255d49b · 2025-12-16T14:10:08.000-05:00
diff --git a/packages/core/src/control_flow.rs b/packages/core/src/control_flow.rs
@@ -0,0 +1,19 @@
+use std::fmt;
+
+/// Marker error type used to indicate an error is expected control-flow (not an actual failure).
+///
+/// This is intentionally defined in `dioxus-core` so integrations (like fullstack) can attach it as a
+/// `source()` to their own error types without introducing dependency cycles.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+#[doc(hidden)]
+pub struct RedirectControlFlow;
+
+impl fmt::Display for RedirectControlFlow {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("redirect control-flow")
+    }
+}
+
+impl std::error::Error for RedirectControlFlow {}
+
+
diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs
@@ -10,6 +10,7 @@ mod effect;
 mod error_boundary;
 mod events;
 mod fragment;
+mod control_flow;
 mod generational_box;
 mod global_context;
 mod launch;
@@ -30,6 +31,11 @@ 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 {
diff --git a/packages/core/src/scope_arena.rs b/packages/core/src/scope_arena.rs
@@ -108,7 +108,20 @@ impl VirtualDom {
     fn handle_element_return(&self, node: &mut Element, scope: &Scope) {
         match node {
             Err(RenderError::Error(e)) => {
-                tracing::error!("Error while rendering component `{}`: {e}", scope.name);
+                // 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);
+                }
                 self.runtime.throw_error(scope.id, e.clone());
             }
             Err(RenderError::Suspended(e)) => {
diff --git a/packages/fullstack-core/src/error.rs b/packages/fullstack-core/src/error.rs
@@ -81,6 +81,23 @@ 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,
+    },
 }
 
 impl ServerFnError {
@@ -93,6 +110,15 @@ 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 {
+            code,
+            location: location.into(),
+            control_flow: dioxus_core::RedirectControlFlow::default(),
+        }
+    }
+
     /// 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();
@@ -138,6 +164,9 @@ 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),
@@ -166,6 +195,7 @@ 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);
@@ -195,6 +225,23 @@ 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,
diff --git a/packages/fullstack-core/src/streaming.rs b/packages/fullstack-core/src/streaming.rs
@@ -2,6 +2,7 @@ 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;
@@ -146,6 +147,19 @@ 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)
             }
         }
@@ -336,3 +350,60 @@ pub fn status_code_from_error(error: &CapturedError) -> StatusCode {
 
     StatusCode::INTERNAL_SERVER_ERROR
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum_core::extract::{FromRequest, Request};
+    use http::header::LOCATION;
+
+    #[derive(Debug)]
+    struct RedirectingExtractor;
+
+    impl FromRequest<FullstackContext, ()> for RedirectingExtractor {
+        type Rejection = (StatusCode, HeaderMap);
+
+        fn from_request(
+            _req: Request,
+            _state: &FullstackContext,
+        ) -> impl std::future::Future<Output = Result<Self, Self::Rejection>> + Send {
+            async move {
+                let mut headers = HeaderMap::new();
+                headers.insert(LOCATION, http::HeaderValue::from_static("/sign-in"));
+                Err((StatusCode::TEMPORARY_REDIRECT, headers))
+            }
+        }
+    }
+
+    #[test]
+    fn extract_preserves_redirect_location() {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .build()
+            .unwrap();
+
+        rt.block_on(async move {
+            let parts = axum_core::extract::Request::builder()
+                .method("GET")
+                .uri("/")
+                .body(())
+                .unwrap()
+                .into_parts()
+                .0;
+
+            let ctx = FullstackContext::new(parts);
+            let err = ctx
+                .clone()
+                .scope(async move { FullstackContext::extract::<RedirectingExtractor, ()>().await })
+                .await
+                .unwrap_err();
+
+            match err {
+                ServerFnError::Redirect { code, location, .. } => {
+                    assert_eq!(code, StatusCode::TEMPORARY_REDIRECT.as_u16());
+                    assert_eq!(location, "/sign-in");
+                }
+                other => panic!("expected ServerFnError::Redirect, got {other:?}"),
+            }
+        });
+    }
+}
diff --git a/packages/fullstack-server/src/server.rs b/packages/fullstack-server/src/server.rs
@@ -374,15 +374,29 @@ impl FullstackState {
                     .into_response()
             }
 
-            Err(SSRError::HttpError { status, message }) => Response::builder()
-                .status(status)
-                .body(Body::from(message.unwrap_or_else(|| {
-                    status
-                        .canonical_reason()
-                        .unwrap_or("An unknown error occurred")
-                        .to_string()
-                })))
-                .unwrap(),
+            Err(SSRError::HttpError {
+                status,
+                message,
+                headers,
+            }) => {
+                let mut response = Response::builder()
+                    .status(status)
+                    .body(Body::from(message.unwrap_or_else(|| {
+                        status
+                            .canonical_reason()
+                            .unwrap_or("An unknown error occurred")
+                            .to_string()
+                    })))
+                    .unwrap();
+
+                for (key, value) in headers.into_iter() {
+                    if let Some(key) = key {
+                        response.headers_mut().insert(key, value);
+                    }
+                }
+
+                response
+            }
         }
     }
 }
diff --git a/packages/fullstack-server/src/ssr.rs b/packages/fullstack-server/src/ssr.rs
@@ -17,7 +17,7 @@ use dioxus_router::ParseRouteError;
 use dioxus_ssr::Renderer;
 use futures_channel::mpsc::Sender;
 use futures_util::{Stream, StreamExt};
-use http::{request::Parts, HeaderMap, StatusCode};
+use http::{header::LOCATION, request::Parts, HeaderMap, HeaderValue, StatusCode};
 use std::{
     collections::HashMap,
     fmt::Write,
@@ -37,6 +37,7 @@ pub enum SSRError {
     HttpError {
         status: StatusCode,
         message: Option<String>,
+        headers: HeaderMap,
     },
 }
 
@@ -140,6 +141,7 @@ impl SsrRendererPool {
             .ok_or_else(|| SSRError::HttpError {
                 status: StatusCode::BAD_REQUEST,
                 message: None,
+                headers: HeaderMap::new(),
             })?
             .to_string();
 
@@ -244,6 +246,7 @@ impl SsrRendererPool {
             if let Some(error) = error {
                 let mut status_code = None;
                 let mut out_message = None;
+                let mut out_headers = HeaderMap::new();
 
                 // If the errors include an `HttpError` or `StatusCode` or `ServerFnError`, we need
                 // to try and return the appropriate status code
@@ -258,15 +261,30 @@ 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(ServerFnError::ServerError { message, code, .. }) = error.downcast_ref()
-                {
-                    status_code = Some(
-                        (*code)
-                            .try_into()
-                            .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-                    );
-
-                    out_message = Some(message.clone());
+                if let Some(server_fn_error) = error.downcast_ref::<ServerFnError>() {
+                    match server_fn_error {
+                        ServerFnError::ServerError { message, code, .. } => {
+                            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);
+                            }
+                        }
+                        _ => {}
+                    }
                 }
 
                 // If there was an error while routing, return the error with a 404 status
@@ -281,6 +299,7 @@ impl SsrRendererPool {
                     _ = initial_result_tx.send(Err(SSRError::HttpError {
                         status: status_code,
                         message: out_message,
+                        headers: out_headers,
                     }));
                     return;
                 }
diff --git a/packages/fullstack/src/magic.rs b/packages/fullstack/src/magic.rs
@@ -428,6 +428,11 @@ 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)
                         }

Original file line number	Diff line number	Diff line change
`@@ -428,6 +428,11 @@ mod decode_ok {`
`428`	`428`	`.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))`
`429`	`429`	`}`
`430`	`430`
	`431`	`+ ServerFnError::Redirect { code, .. } => {`
	`432`	`+ Err(StatusCode::from_u16(code)`
	`433`	`+ .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))`
	`434`	`+ }`
	`435`	`+`
`431`	`436`	`ServerFnError::Registration(_) \| ServerFnError::MiddlewareError(_) => {`
`432`	`437`	`Err(StatusCode::INTERNAL_SERVER_ERROR)`
`433`	`438`	`}`