create server package

packages/server/src/adapters/axum_adapter.rs

@@ -0,0 +1,23 @@
+use crate::{LiveViewError, LiveViewSocket};
+use axum::extract::ws::{Message, WebSocket};
+use futures_util::{SinkExt, StreamExt};
+
+/// Convert a warp websocket into a LiveViewSocket
+///
+/// This is required to launch a LiveView app using the warp web framework
+pub fn axum_socket(ws: WebSocket) -> impl LiveViewSocket {
+    ws.map(transform_rx)
+        .with(transform_tx)
+        .sink_map_err(|_| LiveViewError::SendingFailed)
+}
+
+fn transform_rx(message: Result<Message, axum::Error>) -> Result<String, LiveViewError> {
+    message
+        .map_err(|_| LiveViewError::SendingFailed)?
+        .into_text()
+        .map_err(|_| LiveViewError::SendingFailed)
+}
+
+async fn transform_tx(message: String) -> Result<Message, axum::Error> {
+    Ok(Message::Text(message))
+}

packages/server/src/adapters/salvo_adapter.rs

@@ -0,0 +1,25 @@
+use futures_util::{SinkExt, StreamExt};
+use salvo::ws::{Message, WebSocket};
+
+use crate::{LiveViewError, LiveViewSocket};
+
+/// Convert a salvo websocket into a LiveViewSocket
+///
+/// This is required to launch a LiveView app using the warp web framework
+pub fn salvo_socket(ws: WebSocket) -> impl LiveViewSocket {
+    ws.map(transform_rx)
+        .with(transform_tx)
+        .sink_map_err(|_| LiveViewError::SendingFailed)
+}
+
+fn transform_rx(message: Result<Message, salvo::Error>) -> Result<String, LiveViewError> {
+    let as_bytes = message.map_err(|_| LiveViewError::SendingFailed)?;
+
+    let msg = String::from_utf8(as_bytes.into_bytes()).map_err(|_| LiveViewError::SendingFailed)?;
+
+    Ok(msg)
+}
+
+async fn transform_tx(message: String) -> Result<Message, salvo::Error> {
+    Ok(Message::text(message))
+}

packages/server/src/adapters/warp_adapter.rs

@@ -0,0 +1,28 @@
+use crate::{LiveViewError, LiveViewSocket};
+use futures_util::{SinkExt, StreamExt};
+use warp::ws::{Message, WebSocket};
+
+/// Convert a warp websocket into a LiveViewSocket
+///
+/// This is required to launch a LiveView app using the warp web framework
+pub fn warp_socket(ws: WebSocket) -> impl LiveViewSocket {
+    ws.map(transform_rx)
+        .with(transform_tx)
+        .sink_map_err(|_| LiveViewError::SendingFailed)
+}
+
+fn transform_rx(message: Result<Message, warp::Error>) -> Result<String, LiveViewError> {
+    // destructure the message into the buffer we got from warp
+    let msg = message
+        .map_err(|_| LiveViewError::SendingFailed)?
+        .into_bytes();
+
+    // transform it back into a string, saving us the allocation
+    let msg = String::from_utf8(msg).map_err(|_| LiveViewError::SendingFailed)?;
+
+    Ok(msg)
+}
+
+async fn transform_tx(message: String) -> Result<Message, warp::Error> {
+    Ok(Message::text(message))
+}

packages/server/src/lib.rs

@@ -0,0 +1,85 @@
+use dioxus::prelude::*;
+use serde::{de::DeserializeOwned, Deserializer, Serialize, Serializer};
+
+// We use deref specialization to make it possible to pass either a value that implements
+pub trait SerializeToRemoteWrapper {
+    fn serialize_to_remote<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
+}
+
+impl<T: Serialize> SerializeToRemoteWrapper for &T {
+    fn serialize_to_remote<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> {
+        self.serialize(serializer)
+    }
+}
+
+impl<S: SerializeToRemote> SerializeToRemoteWrapper for &mut &S {
+    fn serialize_to_remote<S2: Serializer>(
+        &self,
+        serializer: S2,
+    ) -> Result<<S2 as Serializer>::Ok, <S2 as Serializer>::Error> {
+        (**self).serialize_to_remote(serializer)
+    }
+}
+
+pub trait SerializeToRemote {
+    fn serialize_to_remote<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
+}
+
+impl<S: Serialize> SerializeToRemote for UseState<S> {
+    fn serialize_to_remote<S2: Serializer>(
+        &self,
+        serializer: S2,
+    ) -> Result<<S2 as Serializer>::Ok, <S2 as Serializer>::Error> {
+        self.current().serialize(serializer)
+    }
+}
+
+// We use deref specialization to make it possible to pass either a value that implements
+pub trait DeserializeOnRemoteWrapper {
+    type Output;
+
+    fn deserialize_on_remote<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Self::Output, D::Error>;
+}
+
+impl<T: DeserializeOwned> DeserializeOnRemoteWrapper for &T {
+    type Output = T;
+
+    fn deserialize_on_remote<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Self::Output, D::Error> {
+        T::deserialize(deserializer)
+    }
+}
+
+impl<D: DeserializeOnRemote> DeserializeOnRemoteWrapper for &mut &D {
+    type Output = D::Output;
+
+    fn deserialize_on_remote<'a, D2: Deserializer<'a>>(
+        deserializer: D2,
+    ) -> Result<Self::Output, D2::Error> {
+        D::deserialize_on_remote(deserializer)
+    }
+}
+
+pub trait DeserializeOnRemote {
+    type Output;
+
+    fn deserialize_on_remote<'a, D: Deserializer<'a>>(
+        deserializer: D,
+    ) -> Result<Self::Output, D::Error>;
+}
+
+impl<D: DeserializeOwned> DeserializeOnRemote for UseState<D> {
+    type Output = D;
+
+    fn deserialize_on_remote<'a, D2: Deserializer<'a>>(
+        deserializer: D2,
+    ) -> Result<Self::Output, D2::Error> {
+        D::deserialize(deserializer)
+    }
+}