make server function API more flexible

packages/server/src/adapters/axum_adapter.rs

@@ -2,7 +2,8 @@ use std::{error::Error, sync::Arc};
 
 use axum::{
     body::{self, Body, BoxBody, Full},
-    extract::{FromRef, State},
+    extract::State,
+    handler::Handler,
     http::{HeaderMap, Request, Response, StatusCode},
     response::IntoResponse,
     routing::{get, post},
@@ -14,61 +15,89 @@ use tokio::task::spawn_blocking;
 use crate::{
     render::SSRState,
     serve::ServeConfig,
-    server_fn::{DioxusServerContext, DioxusServerFnRegistry, ServerFnTraitObj},
+    server_context::DioxusServerContext,
+    server_fn::{DioxusServerFnRegistry, ServerFnTraitObj},
 };
 
-pub trait DioxusRouterExt {
+pub trait DioxusRouterExt<S> {
+    fn register_server_fns_with_handler<H, T>(
+        self,
+        server_fn_route: &'static str,
+        handler: impl Fn(Arc<ServerFnTraitObj>) -> H,
+    ) -> Self
+    where
+        H: Handler<T, S>,
+        T: 'static,
+        S: Clone + Send + Sync + 'static;
     fn register_server_fns(self, server_fn_route: &'static str) -> Self;
+
     fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
         self,
-        cfg: ServeConfig<P>,
-        server_fn_route: Option<&'static str>,
+        server_fn_route: &'static str,
+        cfg: impl Into<ServeConfig<P>>,
     ) -> Self;
 }
 
-impl<S> DioxusRouterExt for Router<S>
+impl<S> DioxusRouterExt<S> for Router<S>
 where
-    SSRState: FromRef<S>,
     S: Send + Sync + Clone + 'static,
 {
-    fn register_server_fns(self, server_fn_route: &'static str) -> Self {
+    fn register_server_fns_with_handler<H, T>(
+        self,
+        server_fn_route: &'static str,
+        mut handler: impl FnMut(Arc<ServerFnTraitObj>) -> H,
+    ) -> Self
+    where
+        H: Handler<T, S, Body>,
+        T: 'static,
+        S: Clone + Send + Sync + 'static,
+    {
         let mut router = self;
         for server_fn_path in DioxusServerFnRegistry::paths_registered() {
             let func = DioxusServerFnRegistry::get(server_fn_path).unwrap();
             let full_route = format!("{server_fn_route}/{server_fn_path}");
-            router = router.route(
-                &full_route,
-                post(move |headers: HeaderMap, body: Request<Body>| async move {
-                    server_fn_handler(DioxusServerContext {}, func.clone(), headers, body).await
-                }),
-            );
+            router = router.route(&full_route, post(handler(func)));
         }
         router
     }
 
+    fn register_server_fns(self, server_fn_route: &'static str) -> Self {
+        self.register_server_fns_with_handler(server_fn_route, |func| {
+            move |headers: HeaderMap, body: Request<Body>| async move {
+                server_fn_handler(DioxusServerContext::default(), func.clone(), headers, body).await
+            }
+        })
+    }
+
     fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
         self,
-        cfg: ServeConfig<P>,
-        server_fn_route: Option<&'static str>,
+        server_fn_route: &'static str,
+        cfg: impl Into<ServeConfig<P>>,
     ) -> Self {
         use tower_http::services::ServeDir;
 
-        // Serve the dist folder and the index.html file
-        let serve_dir = ServeDir::new("dist");
+        let cfg = cfg.into();
 
-        self.register_server_fns(server_fn_route.unwrap_or_default())
-            .route(
+        // Serve the dist folder and the index.html file
+        let serve_dir = ServeDir::new(cfg.assets_path);
+
+        self.register_server_fns(server_fn_route)
+            .nest_service("/assets", serve_dir)
+            .route_service(
                 "/",
-                get(move |State(ssr_state): State<SSRState>| {
-                    let rendered = ssr_state.render(&cfg);
-                    async move { Full::from(rendered) }
-                }),
+                get(render_handler).with_state((cfg, SSRState::default())),
             )
-            .fallback_service(serve_dir)
     }
 }
 
-async fn server_fn_handler(
+async fn render_handler<P: Clone + Send + Sync + 'static>(
+    State((cfg, ssr_state)): State<(ServeConfig<P>, SSRState)>,
+) -> impl IntoResponse {
+    let rendered = ssr_state.render(&cfg);
+    Full::from(rendered)
+}
+
+pub async fn server_fn_handler(
     server_context: DioxusServerContext,
     function: Arc<ServerFnTraitObj>,
     headers: HeaderMap,

packages/server/src/adapters/salvo_adapter.rs

@@ -9,43 +9,65 @@ use server_fn::{Payload, ServerFunctionRegistry};
 use tokio::task::spawn_blocking;
 
 use crate::{
-    dioxus_ssr_html,
+    prelude::DioxusServerContext,
+    prelude::SSRState,
     serve::ServeConfig,
-    server_fn::{DioxusServerContext, DioxusServerFnRegistry, ServerFnTraitObj},
+    server_fn::{DioxusServerFnRegistry, ServerFnTraitObj},
 };
 
 pub trait DioxusRouterExt {
     fn register_server_fns(self, server_fn_route: &'static str) -> Self;
+    fn register_server_fns_with_handler<H>(
+        self,
+        server_fn_route: &'static str,
+        handler: impl Fn(Arc<ServerFnTraitObj>) -> H,
+    ) -> Self
+    where
+        H: Handler + 'static;
     fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
         self,
-        cfg: ServeConfig<P>,
+        server_fn_path: &'static str,
+        cfg: impl Into<ServeConfig<P>>,
     ) -> Self;
 }
 
 impl DioxusRouterExt for Router {
-    fn register_server_fns(self, server_fn_route: &'static str) -> Self {
+    fn register_server_fns_with_handler<H>(
+        self,
+        server_fn_route: &'static str,
+        mut handler: impl FnMut(Arc<ServerFnTraitObj>) -> H,
+    ) -> Self
+    where
+        H: Handler + 'static,
+    {
         let mut router = self;
         for server_fn_path in DioxusServerFnRegistry::paths_registered() {
             let func = DioxusServerFnRegistry::get(server_fn_path).unwrap();
             let full_route = format!("{server_fn_route}/{server_fn_path}");
-            router = router.push(Router::with_path(&full_route).post(ServerFnHandler {
-                server_context: DioxusServerContext {},
-                function: func,
-            }));
+            router = router.push(Router::with_path(&full_route).post(handler(func)));
         }
         router
     }
 
+    fn register_server_fns(self, server_fn_route: &'static str) -> Self {
+        self.register_server_fns_with_handler(|| ServerFnHandler {
+            server_context: DioxusServerContext::default(),
+            function: func,
+        })
+    }
+
     fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
         self,
-        cfg: ServeConfig<P>,
+        server_fn_route: &'static str,
+        cfg: impl Into<ServeConfig<P>>,
     ) -> Self {
+        let cfg = cfg.into();
         // Serve the dist folder and the index.html file
-        let serve_dir = StaticDir::new(["dist"]);
+        let serve_dir = StaticDir::new([cfg.assets_path]);
 
-        self.register_server_fns(cfg.server_fn_route.unwrap_or_default())
+        self.register_server_fns(server_fn_route)
             .push(Router::with_path("/").get(SSRHandler { cfg }))
-            .push(Router::with_path("<**path>").get(serve_dir))
+            .push(Router::with_path("assets/<**path>").get(serve_dir))
     }
 }
 
@@ -58,19 +80,36 @@ impl<P: Clone + Send + Sync + 'static> Handler for SSRHandler<P> {
     async fn handle(
         &self,
         _req: &mut Request,
-        _depot: &mut Depot,
+        depot: &mut Depot,
         res: &mut Response,
         _flow: &mut FlowCtrl,
     ) {
-        res.write_body(dioxus_ssr_html(&self.cfg)).unwrap();
+        // Get the SSR renderer from the depot or create a new one if it doesn't exist
+        let renderer_pool = if let Some(renderer) = depot.obtain::<SSRState>() {
+            renderer.clone()
+        } else {
+            let renderer = SSRState::default();
+            depot.inject(renderer.clone());
+            renderer
+        };
+        res.write_body(renderer_pool.render(&self.cfg)).unwrap();
     }
 }
 
-struct ServerFnHandler {
+pub struct ServerFnHandler {
     server_context: DioxusServerContext,
     function: Arc<ServerFnTraitObj>,
 }
 
+impl ServerFnHandler {
+    pub fn new(server_context: DioxusServerContext, function: Arc<ServerFnTraitObj>) -> Self {
+        Self {
+            server_context,
+            function,
+        }
+    }
+}
+
 #[handler]
 impl ServerFnHandler {
     async fn handle(&self, req: &mut Request, _depot: &mut Depot, res: &mut Response) {

packages/server/src/adapters/warp_adapter.rs

@@ -10,50 +10,75 @@ use warp::{
 };
 
 use crate::{
-    dioxus_ssr_html,
+    prelude::{DioxusServerContext, SSRState},
     serve::ServeConfig,
-    server_fn::{DioxusServerContext, DioxusServerFnRegistry, ServerFnTraitObj},
+    server_fn::{DioxusServerFnRegistry, ServerFnTraitObj},
 };
 
-pub fn register_server_fns(server_fn_route: &'static str) -> BoxedFilter<(impl Reply,)> {
-    let mut filter: Option<BoxedFilter<(_,)>> = None;
+pub fn register_server_fns_with_handler<H, F, R>(
+    server_fn_route: &'static str,
+    mut handler: H,
+) -> BoxedFilter<(R,)>
+where
+    H: FnMut(String, Arc<ServerFnTraitObj>) -> F,
+    F: Filter<Extract = (R,), Error = warp::Rejection> + Send + Sync + 'static,
+    F::Extract: Send,
+    R: Reply + 'static,
+{
+    let mut filter: Option<BoxedFilter<F::Extract>> = None;
     for server_fn_path in DioxusServerFnRegistry::paths_registered() {
         let func = DioxusServerFnRegistry::get(server_fn_path).unwrap();
         let full_route = format!("{server_fn_route}/{server_fn_path}")
             .trim_start_matches('/')
             .to_string();
-        let route = path(full_route)
-            .and(warp::post())
-            .and(warp::header::headers_cloned())
-            .and(warp::body::bytes())
-            .and_then(move |headers: HeaderMap, body| {
-                let func = func.clone();
-                async move { server_fn_handler(DioxusServerContext {}, func, headers, body).await }
-            })
-            .boxed();
+        let route = handler(full_route, func.clone()).boxed();
         if let Some(boxed_filter) = filter.take() {
             filter = Some(boxed_filter.or(route).unify().boxed());
         } else {
-            filter = Some(route.boxed());
+            filter = Some(route);
         }
     }
     filter.expect("No server functions found")
 }
 
-pub fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
-    cfg: ServeConfig<P>,
-) -> BoxedFilter<(impl Reply,)> {
-    // Serve the dist folder and the index.html file
-    let serve_dir = warp::fs::dir("./dist");
+pub fn register_server_fns(server_fn_route: &'static str) -> BoxedFilter<(impl Reply,)> {
+    register_server_fns_with_handler(server_fn_route, |full_route, func| {
+        path(full_route)
+            .and(warp::post())
+            .and(warp::header::headers_cloned())
+            .and(warp::body::bytes())
+            .and_then(move |headers: HeaderMap, body| {
+                let func = func.clone();
+                async move {
+                    server_fn_handler(DioxusServerContext::default(), func, headers, body).await
+                }
+            })
+    })
+}
 
-    register_server_fns(cfg.server_fn_route.unwrap_or_default())
+pub fn serve_dioxus_application<P: Clone + Send + Sync + 'static>(
+    server_fn_route: &'static str,
+    cfg: impl Into<ServeConfig<P>>,
+) -> BoxedFilter<(impl Reply,)> {
+    let cfg = cfg.into();
+    // Serve the dist folder and the index.html file
+    let serve_dir = warp::fs::dir(cfg.assets_path);
+
+    register_server_fns(server_fn_route)
         .or(warp::path::end()
             .and(warp::get())
-            .map(move || warp::reply::html(dioxus_ssr_html(&cfg))))
-        .or(serve_dir)
+            .and(with_ssr_state())
+            .map(move |renderer: SSRState| warp::reply::html(renderer.render(&cfg))))
+        .or(warp::path("assets").and(serve_dir))
         .boxed()
 }
 
+fn with_ssr_state() -> impl Filter<Extract = (SSRState,), Error = std::convert::Infallible> + Clone
+{
+    let renderer = SSRState::default();
+    warp::any().map(move || renderer.clone())
+}
+
 #[derive(Debug)]
 struct FailedToReadBody(String);
 

packages/server/src/lib.rs

@@ -6,6 +6,7 @@ mod adapters;
 pub mod render;
 #[cfg(feature = "ssr")]
 mod serve;
+mod server_context;
 mod server_fn;
 
 pub mod prelude {
@@ -18,8 +19,11 @@ pub mod prelude {
     #[cfg(feature = "ssr")]
     pub use crate::render::*;
     #[cfg(feature = "ssr")]
-    pub use crate::serve::ServeConfig;
-    pub use crate::server_fn::{DioxusServerContext, ServerFn};
+    pub use crate::serve::{ServeConfig, ServeConfigBuilder};
+    pub use crate::server_context::DioxusServerContext;
+    pub use crate::server_fn::ServerFn;
+    #[cfg(feature = "ssr")]
+    pub use crate::server_fn::ServerFnTraitObj;
     pub use server_fn::{self, ServerFn as _, ServerFnError};
     pub use server_macro::*;
 }

packages/server/src/server_context.rs

@@ -0,0 +1,35 @@
+use std::sync::{Arc, PoisonError, RwLock, RwLockWriteGuard};
+
+use anymap::{any::Any, Map};
+
+type SendSyncAnyMap = Map<dyn Any + Send + Sync + 'static>;
+
+/// A shared context for server functions. This allows you to pass data between your server and the server functions like authentication session data.
+#[derive(Clone)]
+pub struct DioxusServerContext {
+    shared_context: Arc<RwLock<SendSyncAnyMap>>,
+}
+
+impl Default for DioxusServerContext {
+    fn default() -> Self {
+        Self {
+            shared_context: Arc::new(RwLock::new(SendSyncAnyMap::new())),
+        }
+    }
+}
+
+impl DioxusServerContext {
+    pub fn get<T: Any + Send + Sync + Clone + 'static>(&self) -> Option<T> {
+        self.shared_context.read().ok()?.get::<T>().cloned()
+    }
+
+    pub fn insert<T: Any + Send + Sync + 'static>(
+        &mut self,
+        value: T,
+    ) -> Result<(), PoisonError<RwLockWriteGuard<'_, SendSyncAnyMap>>> {
+        self.shared_context
+            .write()
+            .map(|mut map| map.insert(value))
+            .map(|_| ())
+    }
+}

packages/server/src/server_fn.rs

@@ -1,5 +1,4 @@
-#[derive(Clone)]
-pub struct DioxusServerContext {}
+use crate::server_context::DioxusServerContext;
 
 #[cfg(any(feature = "ssr", doc))]
 pub type ServerFnTraitObj = server_fn::ServerFnTraitObj<DioxusServerContext>;