fix: resolve messagepack codec trait bounds and literals

shared/src/codec.rs

@@ -1,83 +1,88 @@
+use leptos::prelude::*;
 use leptos::server_fn::codec::{Encoding, FromReq, FromRes, IntoReq, IntoRes};
 use leptos::server_fn::request::{ClientReq, Req};
-use leptos::server_fn::response::{ClientRes, Res};
+use leptos::server_fn::response::{ClientRes, Res, TryRes};
-use leptos::server_fn::error::ServerFnError;
+use http::Method;
+use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 use std::future::Future;
 
 pub struct MessagePack;
 
-impl leptos::server_fn::codec::ContentType for MessagePack {
+impl leptos::server_fn::ContentType for MessagePack {
     const CONTENT_TYPE: &'static str = "application/msgpack";
 }
 
 impl Encoding for MessagePack {
-    const METHOD: leptos::server_fn::request::Method = leptos::server_fn::request::Method::POST;
+    const METHOD: Method = Method::POST;
 }
 
 #[cfg(any(feature = "ssr", feature = "hydrate"))]
-impl<Input, Output> IntoReq<MessagePack, Input, Output> for MessagePack
+impl<T, Request, Error> IntoReq<MessagePack, Request, Error> for T
 where
-    Input: Serialize + Send,
+    Request: ClientReq<Error>,
-    Output: Send,
+    T: Serialize + Send,
+    Error: Send,
 {
-    fn into_req(self, args: Input, path: &str) -> Result<ClientReq, ServerFnError> {
+    fn into_req(self, path: &str, accepts: &str) -> Result<Request, Error> {
-        let data = rmp_serde::to_vec(&args)
+        let data = rmp_serde::to_vec(&self)
-            .map_err(|e| ServerFnError::Serialization(e.to_string()))?;
+            .map_err(|e| ServerFnError::new(e.to_string()).into())?;
-
+            
-        ClientReq::try_new(
+        // Use try_new_post_bytes which should be available on ClientReq trait
-            leptos::server_fn::request::Method::POST,
+        Request::try_new_post_bytes(
             path,
-            leptos::server_fn::request::Payload::Binary(bytes::Bytes::from(data))
+            MessagePack::CONTENT_TYPE,
+            accepts,
+            Bytes::from(data)
         )
     }
 }
 
 #[cfg(any(feature = "ssr", feature = "hydrate"))]
-impl<Input, Output> FromRes<MessagePack, Input, Output> for MessagePack
+impl<T, Response, Error> FromRes<MessagePack, Response, Error> for T
 where
-    Input: Send,
+    Response: ClientRes<Error> + Send,
-    Output: DeserializeOwned + Send,
+    T: DeserializeOwned + Send,
+    Error: Send,
 {
-    fn from_res(res: ClientRes) -> impl Future<Output = Result<Output, ServerFnError>> + Send {
+    fn from_res(res: Response) -> impl Future<Output = Result<Self, Error>> + Send {
         async move {
             let data = res.try_into_bytes().await?;
             rmp_serde::from_slice(&data)
-                .map_err(|e| ServerFnError::Deserialization(e.to_string()))
+                .map_err(|e| ServerFnError::new(e.to_string()).into())
         }
     }
 }
 
 #[cfg(feature = "ssr")]
-impl<Input, Output> FromReq<MessagePack, Input, Output> for MessagePack
+impl<T, Request, Error> FromReq<MessagePack, Request, Error> for T
 where
-    Input: DeserializeOwned + Send,
+    Request: Req<Error> + Send,
-    Output: Send,
+    T: DeserializeOwned,
+    Error: Send,
 {
-    fn from_req(req: Req) -> impl Future<Output = Result<Input, ServerFnError>> + Send {
+    fn from_req(req: Request) -> impl Future<Output = Result<Self, Error>> + Send {
         async move {
-            let body_bytes = req.try_into_bytes().await?;
+            let data = req.try_into_bytes().await?;
-            rmp_serde::from_slice(&body_bytes)
+            rmp_serde::from_slice(&data)
-                .map_err(|e| ServerFnError::Args(e.to_string()))
+                .map_err(|e| ServerFnError::new(e.to_string()).into())
         }
     }
 }
 
 #[cfg(feature = "ssr")]
-impl<Input, Output> IntoRes<MessagePack, Input, Output> for MessagePack
+impl<T, Response, Error> IntoRes<MessagePack, Response, Error> for T
 where
-    Input: Send,
+    Response: TryRes<Error> + Send,
-    Output: Serialize + Send,
+    T: Serialize + Send,
+    Error: Send,
 {
-    fn into_res(res: Output) -> impl Future<Output = Result<Res, ServerFnError>> + Send {
+    fn into_res(self) -> impl Future<Output = Result<Response, Error>> + Send {
         async move {
-            let data = rmp_serde::to_vec(&res)
+            let data = rmp_serde::to_vec(&self)
-            .map_err(|e| ServerFnError::Serialization(e.to_string()))?;
+                .map_err(|e| ServerFnError::new(e.to_string()).into())?;
             
-            Res::try_from_bytes(
+            Response::try_from_bytes(MessagePack::CONTENT_TYPE, Bytes::from(data))
-                bytes::Bytes::from(data), 
-                "application/msgpack"
-            )
         }
     }
 }

shared/src/server_fns/auth.rs

@@ -20,7 +20,7 @@ pub struct SetupStatus {
     pub completed: bool,
 }
 
-#[server(GetSetupStatus, "/api/server_fns/GetSetupStatus", encoding = MessagePack)]
+#[server(GetSetupStatus, "/api/server_fns/GetSetupStatus", encoding = "MessagePack")]
 pub async fn get_setup_status() -> Result<SetupStatus, ServerFnError> {
     use crate::DbContext;
 
@@ -33,7 +33,7 @@ pub async fn get_setup_status() -> Result<SetupStatus, ServerFnError> {
     })
 }
 
-#[server(Setup, "/api/server_fns/Setup", encoding = MessagePack)]
+#[server(Setup, "/api/server_fns/Setup", encoding = "MessagePack")]
 pub async fn setup(username: String, password: String) -> Result<(), ServerFnError> {
     use crate::DbContext;
 
@@ -55,7 +55,7 @@ pub async fn setup(username: String, password: String) -> Result<(), ServerFnErr
     Ok(())
 }
 
-#[server(Login, "/api/server_fns/Login", encoding = MessagePack)]
+#[server(Login, "/api/server_fns/Login", encoding = "MessagePack")]
 pub async fn login(username: String, password: String) -> Result<UserResponse, ServerFnError> {
     use crate::DbContext;
     use leptos_axum::ResponseOptions;
@@ -111,7 +111,7 @@ pub async fn login(username: String, password: String) -> Result<UserResponse, S
     }
 }
 
-#[server(Logout, "/api/server_fns/Logout", encoding = MessagePack)]
+#[server(Logout, "/api/server_fns/Logout", encoding = "MessagePack")]
 pub async fn logout() -> Result<(), ServerFnError> {
     use leptos_axum::ResponseOptions;
     use cookie::{Cookie, SameSite};
@@ -132,7 +132,7 @@ pub async fn logout() -> Result<(), ServerFnError> {
     Ok(())
 }
 
-#[server(GetUser, "/api/server_fns/GetUser", encoding = MessagePack)]
+#[server(GetUser, "/api/server_fns/GetUser", encoding = "MessagePack")]
 pub async fn get_user() -> Result<Option<UserResponse>, ServerFnError> {
     use axum::http::HeaderMap;
     use leptos_axum::extract;