Generic Server Fn

examples/server_fns_axum/Cargo.toml

@@ -17,6 +17,7 @@ server_fn = { path = "../../server_fn", features = [
   "rkyv",
   "multipart",
   "postcard",
+  "ssr_generics",
 ] }
 log = "0.4.22"
 simple_logger = "5.0"

examples/server_fns_axum/src/app.rs

@@ -57,7 +57,8 @@ pub fn App() -> impl IntoView {
 #[component]
 pub fn HomePage() -> impl IntoView {
     view! {
-        <h2>"Some Simple Server Functions"</h2>
+
+      <h2>"Some Simple Server Functions"</h2>
         <SpawnLocal/>
         <WithAnAction/>
         <WithActionForm/>
@@ -72,6 +73,12 @@ pub fn HomePage() -> impl IntoView {
         <FileWatcher/>
         <CustomEncoding/>
         <CustomClientExample/>
+        <h2>"Generic Server Functions"</h2>
+        <SimpleGenericServerFnComponent/>
+        <GenericHelloWorld/>
+        <GenericHelloWorldWithDefaults/>
+        <GenericSsrOnlyTypes/>
+        <GenericServerFnResult/>
     }
 }
 
@@ -945,3 +952,228 @@ pub fn PostcardExample() -> impl IntoView {
         </Transition>
     }
 }
+
+use std::fmt::Display;
+
+/// This server function is generic over S which implements Display.
+/// It's registered for String and u8, which means that it will create unique routes for each specific type.
+#[server]
+#[register(<String>,<u8>)]
+pub async fn server_fn_to_string<S: Display>(
+    s: S,
+) -> Result<String, ServerFnError> {
+    println!("Type {} got arg {s}", std::any::type_name::<S>());
+    Ok(format!("{s}"))
+}
+
+#[component]
+pub fn SimpleGenericServerFnComponent() -> impl IntoView {
+    let string_to_string = Resource::new(
+        || (),
+        |_| server_fn_to_string(String::from("I'm a String.")),
+    );
+    let u8_to_string = Resource::new(
+        move || (),
+        |_| async move { server_fn_to_string::<u8>(42).await },
+    );
+    view! {
+        <h3>Using generic function over display</h3>
+        <p>"This example demonstrates creating a generic function that takes any type that implements display that we've registered."</p>
+
+        <ErrorBoundary fallback=move |err|leptos::logging::log!("{err:?}")>
+
+        <Suspense >
+       <h4>Result 1</h4>
+           <p>
+            {
+                move || string_to_string.get()
+            }
+           </p>
+           <h4>Result 2</h4>
+           <p>
+           {
+               move || u8_to_string.get()
+           }
+           </p>
+        </Suspense>
+        </ErrorBoundary >
+
+
+    }
+}
+
+pub trait SomeTrait {
+    fn some_method() -> String;
+}
+
+pub struct AStruct;
+pub struct AStruct2;
+impl SomeTrait for AStruct {
+    fn some_method() -> String {
+        String::from("Hello world...")
+    }
+}
+impl SomeTrait for AStruct2 {
+    fn some_method() -> String {
+        String::from("HELLO WORLD")
+    }
+}
+
+#[server]
+#[register(<AStruct>,<AStruct2>)]
+pub async fn server_hello_world_generic<S: SomeTrait>(
+) -> Result<String, ServerFnError> {
+    Ok(S::some_method())
+}
+
+#[component]
+pub fn GenericHelloWorld() -> impl IntoView {
+    let s = RwSignal::new(String::new());
+    Effect::new(move |_| {
+        spawn_local(async move {
+            match server_hello_world_generic::<AStruct>().await {
+                Ok(hello) => s.set(hello),
+                Err(err) => leptos::logging::log!("{err:?}"),
+            }
+        })
+    });
+    let s2 = RwSignal::new(String::new());
+    Effect::new(move |_| {
+        spawn_local(async move {
+            match server_hello_world_generic::<AStruct2>().await {
+                Ok(hello) => s2.set(hello),
+                Err(err) => leptos::logging::log!("{err:?}"),
+            }
+        })
+    });
+    view! {
+        <h3>Using generic functions without generic inputs</h3>
+        <p>"This example demonstrates creating a generic server function that doesn't take any generic input."</p>
+        <h4>{"Results"}</h4>
+        <p>{ move || format!("With generic specified to {} we get {} from the server", std::any::type_name::<AStruct>(), s.get())}</p>
+        <p>{ move || format!("With generic specified to {} we get {} from the server", std::any::type_name::<AStruct2>(), s2.get())}</p>
+
+    }
+}
+
+#[derive(Clone)]
+struct SomeDefault;
+impl SomeTrait for SomeDefault {
+    fn some_method() -> String {
+        String::from("just a default hello world...")
+    }
+}
+
+#[server]
+#[register(<SomeDefault>)]
+pub async fn server_hello_world_generic_with_default<
+    S: SomeTrait = SomeDefault,
+>() -> Result<String, ServerFnError> {
+    Ok(S::some_method())
+}
+
+#[component]
+pub fn GenericHelloWorldWithDefaults() -> impl IntoView {
+    let action = ServerAction::<ServerHelloWorldGenericWithDefault>::new();
+    Effect::new(move |_| {
+        action.dispatch(ServerHelloWorldGenericWithDefault {
+            _marker: std::marker::PhantomData,
+        });
+    });
+
+    view! {
+        <h3>Using generic functions without generic inputs but a specified default type</h3>
+        <p>"This example demonstrates creating a generic server function that doesn't take any generic input and has a default generic type."</p>
+        <h4>{"Results"}</h4>
+        <p>{ move || action.value_local().read_only().get().map(|s|s.map(|s|format!("With default generic we get {s} from the server", )))}</p>
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub struct ServerOnlyStruct;
+#[cfg(feature = "ssr")]
+pub struct SsrOnlyStructButDifferent;
+#[cfg(feature = "ssr")]
+pub trait ServerOnlyTrait {
+    fn some_method() -> String {
+        String::from("I'm a backend!")
+    }
+}
+
+#[cfg(feature = "ssr")]
+impl ServerOnlyTrait for ServerOnlyStruct {}
+#[cfg(feature = "ssr")]
+impl ServerOnlyTrait for SsrOnlyStructButDifferent {
+    fn some_method() -> String {
+        String::from("I'm a different backend!")
+    }
+}
+server_fn::ssr_type_shim! {ServerOnlyStruct, SsrOnlyStructButDifferent}
+server_fn::ssr_trait_shim! {ServerOnlyTrait}
+server_fn::ssr_impl_shim! {ServerOnlyStruct:ServerOnlyTrait,SsrOnlyStructButDifferent:ServerOnlyTrait}
+
+#[server]
+#[register(<ServerOnlyStructPhantom:ServerOnlyTraitConstraint>,
+    <SsrOnlyStructButDifferentPhantom:ServerOnlyTraitConstraint>
+)]
+pub async fn generic_server_with_ssr_only_types<T: ServerOnlyTrait>(
+) -> Result<String, ServerFnError> {
+    Ok(T::some_method())
+}
+
+#[component]
+pub fn GenericSsrOnlyTypes() -> impl IntoView {
+    let s = RwSignal::new(String::new());
+    // spawn on the client
+    Effect::new(move |_| {
+        spawn_local(async move {
+            match generic_server_with_ssr_only_types::<ServerOnlyStructPhantom>(
+            )
+            .await
+            {
+                Ok(hello) => s.set(hello),
+                Err(err) => leptos::logging::log!("{err:?}"),
+            }
+        });
+    });
+
+    let s2 = RwSignal::new(String::new());
+    // spawn on the client
+    Effect::new(move |_| {
+        spawn_local(async move {
+            match generic_server_with_ssr_only_types::<
+                SsrOnlyStructButDifferentPhantom,
+            >()
+            .await
+            {
+                Ok(hello) => s2.set(hello),
+                Err(err) => leptos::logging::log!("{err:?}"),
+            }
+        });
+    });
+    view! {
+        <h3>Using generic functions with a type that only exists on the server.</h3>
+        <p>"This example demonstrates how to make use of the helper macros and phantom types to make your backend generic and specifiable from your frontend."</p>
+        <h4>{"Results"}</h4>
+        <p>{ move || format!("With backend 1 we get {} from the server", s.get())}</p>
+        <p>{ move || format!("With backend 2 we get {} from the server", s2.get())}</p>
+
+    }
+}
+
+#[server]
+#[register(<String>,<u8>)]
+pub async fn generic_default_result<R: Default>() -> Result<R, ServerFnError> {
+    Ok(R::default())
+}
+
+#[component]
+pub fn GenericServerFnResult() -> impl IntoView {
+    Suspend::new(async move {
+        format!(
+            " Default u8 is {} \n Default String is {}",
+            generic_default_result::<String>().await.unwrap(),
+            generic_default_result::<u8>().await.unwrap(),
+        )
+    })
+}

server_fn/Cargo.toml

@@ -75,6 +75,8 @@ reqwest = { version = "0.12.9", default-features = false, optional = true, featu
 ] }
 url = "2"
 pin-project-lite = "0.2.15"
+# server-fn generics
+paste = { version = "1.0.15", optional = true }
 
 [features]
 default = ["json"]
@@ -112,6 +114,7 @@ rustls = ["reqwest?/rustls-tls"]
 reqwest = ["dep:reqwest"]
 ssr = ["inventory"]
 generic = []
+ssr_generics = ["dep:paste"]
 
 [package.metadata.docs.rs]
 all-features = true

server_fn/server_fn_macro_default/src/lib.rs

@@ -68,6 +68,94 @@ use syn::__private::ToTokens;
 ///   // etc.
 /// }
 /// ```
+///
+/// ## Generic Server Functions
+/// You can make your server function generic by writing the function generically and adding a register attribute which will works like (and overrides) the endpoint attribute.
+/// but for specific identities of your generic server function.
+///
+/// When a generic type is not found in the inputs and is instead only found in the return type or the body the server function struct will include a `PhantomData<T>`
+/// Where T is the not found type. Or in the case of multiple not found types T,...,Tn will include them in a tuple. i.e `PhantomData<(T,...,Tn)>`
+///
+/// ```rust, ignore
+/// #[server]
+/// #[register(
+///     <SpecificT,DefaultU>,
+///     <OtherSpecificT,NotDefaultU>="other_struct_has_specific_route"
+/// )]
+/// pub async fn my_generic_server_fn<T : SomeTrait, U = DefaultU>(input:T) -> Result<(), ServerFnError>
+///     where
+///     U: ThisTraitIsInAWhereClause
+///  {
+///     todo!()
+/// }
+///
+/// // expands to
+/// #[derive(Deserialize, Serialize)]
+/// struct MyGenericServerFn<T,U>
+///     where
+///        // we require these traits always for generic fn input
+///        T : SomeTrait + Send + Serialize + DeserializeOwned + 'static,
+///        U : ThisTraitIsInAWhereClause  {
+///     _marker:PhantomData<U>
+///     input: T
+/// }
+///
+/// impl ServerFn for MyGenericServerFn<SpecificT,DefaultU> {
+///  // where our endpoint will be generated for us and unique to this type
+///   const PATH: &'static str = "/api/...generated_endpoint...";
+///     // ...
+/// }
+///
+/// impl ServerFn for MyGenericServerFn<OtherSpecificT,NotDefaultU> {
+///   const PATH: &'static str = "/api/other_struct_has_specific_route";
+///     // ..
+/// }
+/// ```
+///
+/// If your server function is generic over types that are not isomorphic, i.e a backend type or a database connection. You can use the `generic_fn`
+/// module helper shims to create
+/// the traits types and impls that the server macro will use to map the client side code onto the backend.
+///
+/// You can find more details about the macros in their respective `generic_fn` module.
+///
+/// ```rust,ignore
+/// ssr_type_shim!(BackendType);
+/// // generates
+/// pub struct BackendTypePhantom;
+/// #[cfg(feature="ssr")]
+/// impl ServerType for BackendTypePhantom{
+///     type ServerType = BackendType;
+/// }
+/// ssr_trait_shim!(BackendTrait);
+/// // generates
+/// pub trait BackendTraitConstraint{}
+/// ssr_impl_shim!(BackendType:BackendTrait);
+/// // generates
+/// impl BackendTypeConstraint for BackendTypePhantom{}
+///
+/// // see below how we are now registered with the phantom struct and not the original struct,
+/// // the server macro will "move through" the phantom struct via it's ServerType implemented above to find the server type and pass that to your server function.
+/// // We do this for any specified struct, in a register attribute, with no generic parameters that ends in the word Phantom. i.e Type1Phantom, DbPhantom, Phantom, PhantomPhantom, etc.
+/// #[server]
+/// #[register(<BackendTypePhantom,DefaultU>)]
+/// pub async fn generic_fn<T:BackendTrait,U = DefaultU>() -> Result<U,ServerFnError> {
+///     todo!()
+/// }
+///
+/// // expands to
+/// #[derive(Deserialize, Serialize)]
+/// struct GenericFc<T,U>
+///     where
+///        T : BackendTraitConstraint, {
+///     _marker:PhantomData<(T,U)>
+/// }
+///
+/// impl ServerFn for GenericFn<BackendTypePhantom,DefaultU> {
+///     // same as above...
+/// }
+/// ```
+///
+/// And can be referenced in your frontend code a `T:BackendTraitConstraint`.
 #[proc_macro_attribute]
 pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
     match server_macro_impl(

server_fn/src/lib.rs

@@ -114,6 +114,9 @@ pub mod request;
 /// Types and traits for HTTP responses.
 pub mod response;
 
+/// Helpers for creating isomorphic generic code.
+#[cfg(feature = "ssr_generics")]
+pub mod ssr_generics;
 #[cfg(feature = "actix")]
 #[doc(hidden)]
 pub use ::actix_web as actix_export;
@@ -126,6 +129,9 @@ pub use ::bytes as bytes_export;
 #[cfg(feature = "generic")]
 #[doc(hidden)]
 pub use ::http as http_export;
+#[cfg(feature = "ssr_generics")]
+#[doc(hidden)]
+pub use ::paste as paste_export;
 use client::Client;
 use codec::{Encoding, FromReq, FromRes, IntoReq, IntoRes};
 #[doc(hidden)]