wip: simplify deps

DioxusLabs · jkelleyrtp · Aug 20, 2025 · Aug 20, 2025 · Aug 21, 2025 · Aug 22, 2025
commit c81dacb0b4d1da9e1af9a877dd1d0c4dc481f00c
@@ -66,7 +66,7 @@ signals = ["dep:dioxus-signals", "dep:dioxus-stores"]
 macro = ["dep:dioxus-core-macro"]
 html = ["dep:dioxus-html"]
 hooks = ["dep:dioxus-hooks"]
-devtools = ["dep:dioxus-devtools", "dioxus-web?/devtools", "dioxus-fullstack?/devtools"]
+devtools = ["dep:dioxus-devtools", "dioxus-web?/devtools"]
 mounted = ["dioxus-web?/mounted"]
 file_engine = ["dioxus-web?/file_engine"]
 asset = ["dep:manganis", "dep:dioxus-asset-resolver"]

@@ -41,7 +41,7 @@ hyper-util = { workspace = true, features = ["full"], optional = true }
 hyper = { workspace = true, optional = true }
 
 # Web Integration
-dioxus-web = { workspace = true, features = ["hydrate"], default-features = false, optional = true }
+# dioxus-web = { workspace = true, features = ["hydrate"], default-features = false, optional = true }
 dioxus-interpreter-js = { workspace = true, optional = true }
 
 tracing = { workspace = true }
@@ -89,7 +89,7 @@ web-sys = { version = "0.3.77", optional = true, features = [
 subsecond = { workspace =  true }
 dioxus-cli-config = { workspace = true, optional = true }
 tokio-tungstenite = { workspace = true }
-dioxus-devtools = { workspace = true, optional = true }
+dioxus-devtools = { workspace = true }
 aws-lc-rs = { version = "1.13.1", optional = true }
 dioxus-history = { workspace = true }
 http.workspace = true
@@ -115,12 +115,9 @@ dioxus = { workspace = true, features = ["fullstack"] }
 tokio = { workspace = true, features = ["full"] }
 
 [features]
-default = ["devtools", "document", "file_engine", "mounted", "client", "server", "router"]
-devtools = ["dioxus-web?/devtools", "dep:dioxus-devtools"]
-mounted = ["dioxus-web?/mounted"]
-file_engine = ["dioxus-web?/file_engine"]
-document = ["dioxus-web?/document"]
-web = ["dep:dioxus-web", "dep:web-sys", "dioxus-fullstack-hooks/web"]
+default = ["router", "document", "client", "server"]
+document = []
+web = ["dep:web-sys", "dioxus-fullstack-hooks/web"]
 router = ["dep:dioxus-router"]
 default-tls = []
 rustls = ["dep:rustls", "dep:hyper-rustls"]
@@ -154,6 +151,10 @@ server-core = [
 ]
 aws-lc-rs = ["dep:aws-lc-rs"]
 
+# document = ["dioxus-web?/document"]
+# devtools = ["dioxus-web?/devtools", "dep:dioxus-devtools"]
+# web = ["dep:dioxus-web", "dep:web-sys", "dioxus-fullstack-hooks/web"]
+
 [package.metadata.docs.rs]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 features = ["axum", "web", "aws-lc-rs"]
diff --git a/packages/fullstack/examples/simple-host.rs b/packages/fullstack/examples/simple-host.rs
@@ -1,5 +1,5 @@
 use dioxus::prelude::*;
-use dioxus_fullstack::{codec::Json, make_server_fn, AxumServerFn, Http, Websocket};
+use dioxus_fullstack::{codec::Json, make_server_fn, Http, ServerFunction, WebSocket};
 use std::future::Future;
 
 #[tokio::main]
@@ -32,13 +32,13 @@ async fn do_thing(a: i32, b: String) -> dioxus::Result<()> {
         }
 
         inventory::submit! {
-            AxumServerFn::new(
+            ServerFunction::new(
                 http::Method::GET,
                 "/thing",
                 |req| {
-                    Box::pin(async move {
-                        todo!()
-                    })
+                    // this_protocol::run_on_server(req)
+                    // this_protocol::run_on_client(req)
+                    todo!()
                 },
                 None
             )
@@ -53,8 +53,8 @@ async fn do_thing(a: i32, b: String) -> dioxus::Result<()> {
     }
 }
 
-async fn make_websocket() -> dioxus::Result<Websocket> {
-    Ok(Websocket::new(|tx, rx| async move {
+async fn make_websocket() -> dioxus::Result<WebSocket> {
+    Ok(WebSocket::new(|tx, rx| async move {
         //
     }))
 }

diff --git a/packages/fullstack/src/codec/json.rs b/packages/fullstack/src/codec/json.rs
@@ -14,21 +14,15 @@ impl FormatType for JsonEncoding {
     const FORMAT_TYPE: Format = Format::Text;
 }
 
-impl<T> Encodes<T> for JsonEncoding
-where
-    T: Serialize,
-{
+impl<T: Serialize> Encodes<T> for JsonEncoding {
     type Error = serde_json::Error;
 
     fn encode(output: &T) -> Result<Bytes, Self::Error> {
         serde_json::to_vec(output).map(Bytes::from)
     }
 }
 
-impl<T> Decodes<T> for JsonEncoding
-where
-    T: DeserializeOwned,
-{
+impl<T: DeserializeOwned> Decodes<T> for JsonEncoding {
     type Error = serde_json::Error;
 
     fn decode(bytes: Bytes) -> Result<T, Self::Error> {

diff --git a/packages/fullstack/src/codec/mod.rs b/packages/fullstack/src/codec/mod.rs
@@ -63,11 +63,11 @@ use futures::Future;
 use http::Method;
 // pub use stream::*;
 
-pub trait Codec<Encoding>: Sized {
+pub trait Codec<Encoding>: Sized + Send {
     fn into_req(self, path: &str, accepts: &str) -> Result<HybridRequest, HybridError>;
-    async fn from_req(req: HybridRequest) -> Result<Self, HybridError>;
-    async fn into_res(self) -> Result<HybridResponse, HybridError>;
-    async fn from_res(res: HybridResponse) -> Result<Self, HybridError>;
+    fn from_req(req: HybridRequest) -> impl Future<Output = Result<Self, HybridError>> + Send;
+    fn into_res(self) -> impl Future<Output = Result<HybridResponse, HybridError>> + Send;
+    fn from_res(res: HybridResponse) -> impl Future<Output = Result<Self, HybridError>> + Send;
 }
 
 /// Defines a particular encoding format, which can be used for serializing or deserializing data.

diff --git a/packages/fullstack/src/context.rs b/packages/fullstack/src/context.rs
@@ -5,6 +5,8 @@ use std::collections::HashMap;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 
+use crate::ContextProviders;
+
 type SendSyncAnyMap = std::collections::HashMap<std::any::TypeId, ContextType>;
 
 #[derive(EnumSetType)]
@@ -94,6 +96,15 @@ impl Default for DioxusServerContext {
     }
 }
 
+impl DioxusServerContext {
+    pub(crate) fn add_server_context(&self, context_providers: &ContextProviders) {
+        for index in 0..context_providers.len() {
+            let context_providers = context_providers.clone();
+            self.insert_boxed_factory(Box::new(move || context_providers[index]()));
+        }
+    }
+}
+
 mod server_fn_impl {
     use super::*;
     use parking_lot::{MappedRwLockWriteGuard, RwLockReadGuard, RwLockWriteGuard};

diff --git a/packages/fullstack/src/encoding.rs b/packages/fullstack/src/encoding.rs
@@ -8,23 +8,23 @@ use crate::{FromServerFnError, ServerFnError};
 // #[cfg(feature = "form-redirects")]
 // use super::error::ServerFnUrlError;
 
-use super::middleware::{BoxedService, Layer, Service};
-use super::redirect::call_redirect_hook;
+// use super::middleware::{BoxedService, Layer, Service};
+// use super::redirect::call_redirect_hook;
 // use super::response::{Res, TryRes};
 // use super::response::{ClientRes, Res, TryRes};
 use bytes::{BufMut, Bytes, BytesMut};
-use dashmap::DashMap;
-use futures::{pin_mut, SinkExt, Stream, StreamExt};
-use http::Method;
+// use dashmap::DashMap;
+// use futures::{pin_mut, SinkExt, Stream, StreamExt};
+// use http::Method;
 
 // use super::server::Server;
 use std::{
     fmt::{Debug, Display},
-    future::Future,
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-    pin::Pin,
-    sync::{Arc, LazyLock},
+    // future::Future,
+    // marker::PhantomData,
+    // ops::{Deref, DerefMut},
+    // pin::Pin,
+    // sync::{Arc, LazyLock},
 };
 
 /// A trait for types that can be encoded into a bytes for a request body.
@@ -87,7 +87,7 @@ pub trait FormatType {
 // Format: [tag: u8][content: Bytes]
 // - Tag 0: Ok variant
 // - Tag 1: Err variant
-pub fn serialize_result(result: Result<Bytes, Bytes>) -> Bytes {
+pub(crate) fn serialize_result(result: Result<Bytes, Bytes>) -> Bytes {
     match result {
         Ok(bytes) => {
             let mut buf = BytesMut::with_capacity(1 + bytes.len());
@@ -105,7 +105,7 @@ pub fn serialize_result(result: Result<Bytes, Bytes>) -> Bytes {
 }
 
 // Deserializes a Bytes instance back into a Result<Bytes, Bytes>.
-pub fn deserialize_result<E: FromServerFnError>(bytes: Bytes) -> Result<Bytes, Bytes> {
+pub(crate) fn deserialize_result<E: FromServerFnError>(bytes: Bytes) -> Result<Bytes, Bytes> {
     if bytes.is_empty() {
         return Err(E::from_server_fn_error(ServerFnError::Deserialization(
             "Data is empty".into(),

diff --git a/packages/fullstack/src/launch.rs b/packages/fullstack/src/launch.rs
@@ -1,8 +1,8 @@
 //! A launch function that creates an axum router for the LaunchBuilder
 
 use crate::{
-    collect_raw_server_fns, render_handler, server::DioxusRouterExt, RenderHandleState, SSRState,
-    ServeConfig, ServeConfigBuilder,
+    render_handler, server::DioxusRouterExt, RenderHandleState, SSRState, ServeConfig,
+    ServeConfigBuilder,
 };
 use axum::{
     body::Body,
@@ -147,12 +147,14 @@ async fn serve_server(
                     DevserverMsg::HotReload(hot_reload_msg) => {
                         if hot_reload_msg.for_build_id == Some(dioxus_cli_config::build_id()) {
                             if let Some(table) = hot_reload_msg.jump_table {
+                                use crate::ServerFunction;
+
                                 unsafe { dioxus_devtools::subsecond::apply_patch(table).unwrap() };
 
                                 let mut new_router = axum::Router::new().serve_static_assets();
                                 let new_cfg = ServeConfig::new().unwrap();
 
-                                let server_fn_iter = collect_raw_server_fns();
+                                let server_fn_iter = ServerFunction::collect_static();
 
                                 // de-duplicate iteratively by preferring the most recent (first, since it's linked)
                                 let mut server_fn_map: HashMap<_, _> = HashMap::new();
@@ -166,8 +168,7 @@ async fn serve_server(
                                         fn_.path(),
                                         fn_.method()
                                     );
-                                    new_router = crate::register_server_fn_on_router(
-                                        fn_,
+                                    new_router = fn_.register_server_fn_on_router(
                                         new_router,
                                         new_cfg.context_providers.clone(),
                                     );

@@ -1,14 +1,16 @@
 #![doc = include_str!("../README.md")]
 #![doc(html_logo_url = "https://avatars.githubusercontent.com/u/79236386")]
 #![doc(html_favicon_url = "https://avatars.githubusercontent.com/u/79236386")]
-#![warn(missing_docs)]
+// #![warn(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![forbid(unexpected_cfgs)]
 
 pub mod http_fn;
 pub mod ws_fn;
 
 pub mod fetch;
+pub mod protocols;
+pub use protocols::*;
 
 pub mod websocket;
 pub use websocket::*;
@@ -209,7 +211,7 @@ macro_rules! make_server_fn {
                 }
 
                 inventory::submit! {
-                    AxumServerFn::new(
+                    ServerFunction::new(
                         http::Method::GET,
                         "/thing",
                         |req| {

diff --git a/packages/fullstack/src/old.rs b/packages/fullstack/src/old.rs
@@ -148,28 +148,6 @@
 // InputStreamError = Error,
 // OutputStreamError = Error,
 
-// /// The protocol that a server function uses to communicate with the client. This trait handles
-// /// the server and client side of running a server function. It is implemented for the [`Http`] and
-// /// [`Websocket`] protocols and can be used to implement custom protocols.
-// pub trait Protocol<Input, Output> {
-//     /// The HTTP method used for requests.
-//     const METHOD: Method;
-
-//     /// Run the server function on the server. The implementation should handle deserializing the
-//     /// input, running the server function, and serializing the output.
-//     async fn run_server<F, Fut>(
-//         request: HybridRequest,
-//         server_fn: F,
-//     ) -> Result<HybridResponse, HybridError>
-//     where
-//         F: Fn(Input) -> Fut + Send,
-//         Fut: Future<Output = Result<Output, HybridError>>;
-
-//     /// Run the server function on the client. The implementation should handle serializing the
-//     /// input, sending the request, and deserializing the output.
-//     async fn run_client(path: &str, input: Input) -> Result<Output, HybridError>;
-// }
-
 // /// A client defines a pair of request/response types and the logic to send
 // /// and receive them.
 // ///