fix: switch to built-in MsgPack codec and sync leptos versions

frontend/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-leptos = { version = "0.8.15", features = ["csr"] }
+leptos = { version = "0.8.15", features = ["csr", "msgpack"] }
 leptos_router = { version = "0.8.11" }
 
 console_error_panic_hook = "0.1"

shared/Cargo.toml

@@ -12,7 +12,7 @@ bytes = "1"
 http = "1"
 
 # Leptos 0.8.7
-leptos = { version = "0.8.7", features = ["nightly"] }
+leptos = { version = "0.8.15", features = ["nightly", "msgpack"] }
 leptos_router = { version = "0.8.7", features = ["nightly"] }
 leptos_axum = { version = "0.8.7", optional = true }
 axum = { version = "0.8", features = ["macros"], optional = true }

shared/src/codec.rs

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

shared/src/server_fns/auth.rs

@@ -1,6 +1,6 @@
 use leptos::prelude::*;
 use serde::{Deserialize, Serialize};
-use crate::codec::MessagePack;
+use crate::codec::MsgPack;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct UserResponse {
@@ -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 = "MsgPack")]
 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 = "MsgPack")]
 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 = "MsgPack")]
 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 = "MsgPack")]
 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 = "MsgPack")]
 pub async fn get_user() -> Result<Option<UserResponse>, ServerFnError> {
     use axum::http::HeaderMap;
     use leptos_axum::extract;