|
|
@@ -1,30 +1,76 @@
|
|
|
use crate::server_context::DioxusServerContext;
|
|
|
|
|
|
#[cfg(any(feature = "ssr", doc))]
|
|
|
+#[derive(Clone)]
|
|
|
/// A trait object for a function that be called on serializable arguments and returns a serializable result.
|
|
|
-pub type ServerFnTraitObj = server_fn::ServerFnTraitObj<DioxusServerContext>;
|
|
|
+pub struct ServerFnTraitObj(server_fn::ServerFnTraitObj<DioxusServerContext>);
|
|
|
+
|
|
|
+#[cfg(any(feature = "ssr", doc))]
|
|
|
+impl std::ops::Deref for ServerFnTraitObj {
|
|
|
+ type Target = server_fn::ServerFnTraitObj<DioxusServerContext>;
|
|
|
+
|
|
|
+ fn deref(&self) -> &Self::Target {
|
|
|
+ &self.0
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[cfg(any(feature = "ssr", doc))]
|
|
|
+impl std::ops::DerefMut for ServerFnTraitObj {
|
|
|
+ fn deref_mut(&mut self) -> &mut Self::Target {
|
|
|
+ &mut self.0
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[cfg(any(feature = "ssr", doc))]
|
|
|
+impl ServerFnTraitObj {
|
|
|
+ fn new(
|
|
|
+ prefix: &'static str,
|
|
|
+ url: &'static str,
|
|
|
+ encoding: server_fn::Encoding,
|
|
|
+ run: ServerFunction,
|
|
|
+ ) -> Self {
|
|
|
+ Self(server_fn::ServerFnTraitObj::new(prefix, url, encoding, run))
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Create a new `ServerFnTraitObj` from a `server_fn::ServerFnTraitObj`.
|
|
|
+ pub const fn from_generic_server_fn(
|
|
|
+ server_fn: server_fn::ServerFnTraitObj<DioxusServerContext>,
|
|
|
+ ) -> Self {
|
|
|
+ Self(server_fn)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[cfg(any(feature = "ssr", doc))]
|
|
|
+server_fn::inventory::collect!(ServerFnTraitObj);
|
|
|
|
|
|
#[cfg(any(feature = "ssr", doc))]
|
|
|
/// A server function that can be called on serializable arguments and returns a serializable result.
|
|
|
-pub type ServerFunction = server_fn::ServerFunction<DioxusServerContext>;
|
|
|
+pub type ServerFunction = server_fn::SerializedFnTraitObj<DioxusServerContext>;
|
|
|
|
|
|
#[cfg(any(feature = "ssr", doc))]
|
|
|
#[allow(clippy::type_complexity)]
|
|
|
static REGISTERED_SERVER_FUNCTIONS: once_cell::sync::Lazy<
|
|
|
- std::sync::Arc<std::sync::RwLock<std::collections::HashMap<&'static str, ServerFunction>>>,
|
|
|
-> = once_cell::sync::Lazy::new(Default::default);
|
|
|
+ std::sync::Arc<std::sync::RwLock<std::collections::HashMap<&'static str, ServerFnTraitObj>>>,
|
|
|
+> = once_cell::sync::Lazy::new(|| {
|
|
|
+ let mut map = std::collections::HashMap::new();
|
|
|
+ for server_fn in server_fn::inventory::iter::<ServerFnTraitObj> {
|
|
|
+ map.insert(server_fn.0.url(), server_fn.clone());
|
|
|
+ }
|
|
|
+ std::sync::Arc::new(std::sync::RwLock::new(map))
|
|
|
+});
|
|
|
|
|
|
#[cfg(any(feature = "ssr", doc))]
|
|
|
/// The registry of all Dioxus server functions.
|
|
|
pub struct DioxusServerFnRegistry;
|
|
|
|
|
|
-#[cfg(any(feature = "ssr"))]
|
|
|
+#[cfg(feature = "ssr")]
|
|
|
impl server_fn::ServerFunctionRegistry<DioxusServerContext> for DioxusServerFnRegistry {
|
|
|
type Error = ServerRegistrationFnError;
|
|
|
|
|
|
- fn register(
|
|
|
+ fn register_explicit(
|
|
|
+ prefix: &'static str,
|
|
|
url: &'static str,
|
|
|
- server_function: std::sync::Arc<ServerFnTraitObj>,
|
|
|
+ server_function: ServerFunction,
|
|
|
encoding: server_fn::Encoding,
|
|
|
) -> Result<(), Self::Error> {
|
|
|
// store it in the hashmap
|
|
|
@@ -33,10 +79,7 @@ impl server_fn::ServerFunctionRegistry<DioxusServerContext> for DioxusServerFnRe
|
|
|
.map_err(|e| ServerRegistrationFnError::Poisoned(e.to_string()))?;
|
|
|
let prev = write.insert(
|
|
|
url,
|
|
|
- ServerFunction {
|
|
|
- trait_obj: server_function,
|
|
|
- encoding,
|
|
|
- },
|
|
|
+ ServerFnTraitObj::new(prefix, url, encoding, server_function),
|
|
|
);
|
|
|
|
|
|
// if there was already a server function with this key,
|
|
|
@@ -53,27 +96,32 @@ impl server_fn::ServerFunctionRegistry<DioxusServerContext> for DioxusServerFnRe
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+ fn register(
|
|
|
+ url: &'static str,
|
|
|
+ server_function: ServerFunction,
|
|
|
+ encoding: server_fn::Encoding,
|
|
|
+ ) -> Result<(), Self::Error> {
|
|
|
+ Self::register_explicit("", url, server_function, encoding)
|
|
|
+ }
|
|
|
+
|
|
|
/// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
|
|
|
- fn get(url: &str) -> Option<ServerFunction> {
|
|
|
+ fn get(url: &str) -> Option<server_fn::ServerFnTraitObj<DioxusServerContext>> {
|
|
|
REGISTERED_SERVER_FUNCTIONS
|
|
|
.read()
|
|
|
.ok()
|
|
|
- .and_then(|fns| fns.get(url).cloned())
|
|
|
+ .and_then(|fns| fns.get(url).map(|inner| inner.0.clone()))
|
|
|
}
|
|
|
|
|
|
/// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
|
|
|
- fn get_trait_obj(url: &str) -> Option<std::sync::Arc<ServerFnTraitObj>> {
|
|
|
- REGISTERED_SERVER_FUNCTIONS
|
|
|
- .read()
|
|
|
- .ok()
|
|
|
- .and_then(|fns| fns.get(url).map(|f| f.trait_obj.clone()))
|
|
|
+ fn get_trait_obj(url: &str) -> Option<server_fn::ServerFnTraitObj<DioxusServerContext>> {
|
|
|
+ Self::get(url)
|
|
|
}
|
|
|
|
|
|
fn get_encoding(url: &str) -> Option<server_fn::Encoding> {
|
|
|
REGISTERED_SERVER_FUNCTIONS
|
|
|
.read()
|
|
|
.ok()
|
|
|
- .and_then(|fns| fns.get(url).map(|f| f.encoding.clone()))
|
|
|
+ .and_then(|fns| fns.get(url).map(|f| f.encoding()))
|
|
|
}
|
|
|
|
|
|
/// Returns a list of all registered server functions.
|
|
|
@@ -103,16 +151,16 @@ pub enum ServerRegistrationFnError {
|
|
|
///
|
|
|
/// Server functions are created using the `server` macro.
|
|
|
///
|
|
|
-/// The function should be registered by calling `ServerFn::register()`. The set of server functions
|
|
|
+/// The set of server functions
|
|
|
/// can be queried on the server for routing purposes by calling [server_fn::ServerFunctionRegistry::get].
|
|
|
///
|
|
|
/// Technically, the trait is implemented on a type that describes the server function's arguments, not the function itself.
|
|
|
-pub trait ServerFn: server_fn::ServerFn<DioxusServerContext> {
|
|
|
+pub trait DioxusServerFn: server_fn::ServerFn<DioxusServerContext> {
|
|
|
/// Registers the server function, allowing the client to query it by URL.
|
|
|
#[cfg(any(feature = "ssr", doc))]
|
|
|
- fn register() -> Result<(), server_fn::ServerFnError> {
|
|
|
- Self::register_in::<DioxusServerFnRegistry>()
|
|
|
+ fn register_explicit() -> Result<(), server_fn::ServerFnError> {
|
|
|
+ Self::register_in_explicit::<DioxusServerFnRegistry>()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-impl<T> ServerFn for T where T: server_fn::ServerFn<DioxusServerContext> {}
|
|
|
+impl<T> DioxusServerFn for T where T: server_fn::ServerFn<DioxusServerContext> {}
|
Evan Almloff