fix adapters

packages/liveview/src/adapters/axum_adapter.rs

@@ -11,13 +11,14 @@ pub fn axum_socket(ws: WebSocket) -> impl LiveViewSocket {
         .sink_map_err(|_| LiveViewError::SendingFailed)
 }
 
-fn transform_rx(message: Result<Message, axum::Error>) -> Result<String, LiveViewError> {
+fn transform_rx(message: Result<Message, axum::Error>) -> Result<Vec<u8>, LiveViewError> {
     message
         .map_err(|_| LiveViewError::SendingFailed)?
         .into_text()
+        .map(|s| s.into_bytes())
         .map_err(|_| LiveViewError::SendingFailed)
 }
 
-async fn transform_tx(message: String) -> Result<Message, axum::Error> {
+async fn transform_tx(message: Vec<u8>) -> Result<Message, axum::Error> {
-    Ok(Message::Text(message))
+    Ok(Message::Text(String::from_utf8_lossy(&message).to_string()))
 }

packages/liveview/src/adapters/salvo_adapter.rs

@@ -12,14 +12,12 @@ pub fn salvo_socket(ws: WebSocket) -> impl LiveViewSocket {
         .sink_map_err(|_| LiveViewError::SendingFailed)
 }
 
-fn transform_rx(message: Result<Message, salvo::Error>) -> Result<String, LiveViewError> {
+fn transform_rx(message: Result<Message, salvo::Error>) -> Result<Vec<u8>, LiveViewError> {
     let as_bytes = message.map_err(|_| LiveViewError::SendingFailed)?;
 
-    let msg = String::from_utf8(as_bytes.into_bytes()).map_err(|_| LiveViewError::SendingFailed)?;
+    Ok(as_bytes.into())
-
-    Ok(msg)
 }
 
-async fn transform_tx(message: String) -> Result<Message, salvo::Error> {
+async fn transform_tx(message: Vec<u8>) -> Result<Message, salvo::Error> {
-    Ok(Message::text(message))
+    Ok(Message::text(String::from_utf8_lossy(&message).to_string()))
 }

packages/liveview/src/adapters/warp_adapter.rs

@@ -11,18 +11,15 @@ pub fn warp_socket(ws: WebSocket) -> impl LiveViewSocket {
         .sink_map_err(|_| LiveViewError::SendingFailed)
 }
 
-fn transform_rx(message: Result<Message, warp::Error>) -> Result<String, LiveViewError> {
+fn transform_rx(message: Result<Message, warp::Error>) -> Result<Vec<u8>, 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> {
+async fn transform_tx(message: Vec<u8>) -> Result<Message, warp::Error> {
-    Ok(Message::text(message))
+    Ok(Message::text(String::from_utf8_lossy(&message).to_string()))
 }

packages/liveview/src/pool.rs

@@ -126,7 +126,7 @@ pub async fn run(mut vdom: VirtualDom, ws: impl LiveViewSocket) -> Result<(), Li
     pin_mut!(ws);
 
     // send the initial render to the client
-    ws.send(edits).await?;
+    ws.send(edits.into_bytes()).await?;
 
     // Create the a proxy for query engine
     let (query_tx, mut query_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -156,11 +156,11 @@ pub async fn run(mut vdom: VirtualDom, ws: impl LiveViewSocket) -> Result<(), Li
             evt = ws.next() => {
                 match evt.as_ref().map(|o| o.as_deref()) {
                     // respond with a pong every ping to keep the websocket alive
-                    Some(Ok("__ping__")) => {
+                    Some(Ok(b"__ping__")) => {
-                        ws.send("__pong__".to_string()).await?;
+                        ws.send(b"__pong__".to_vec()).await?;
                     }
                     Some(Ok(evt)) => {
-                        if let Ok(message) = serde_json::from_str::<IpcMessage>(evt) {
+                        if let Ok(message) = serde_json::from_str::<IpcMessage>(&*String::from_utf8_lossy(evt)) {
                             match message {
                                 IpcMessage::Event(evt) => {
                                     // Intercept the mounted event and insert a custom element type
@@ -196,7 +196,7 @@ pub async fn run(mut vdom: VirtualDom, ws: impl LiveViewSocket) -> Result<(), Li
 
             // handle any new queries
             Some(query) = query_rx.recv() => {
-                ws.send(serde_json::to_string(&ClientUpdate::Query(query)).unwrap()).await?;
+                ws.send(serde_json::to_string(&ClientUpdate::Query(query)).unwrap().into_bytes()).await?;
             }
 
             Some(msg) = hot_reload_wait => {
@@ -218,8 +218,12 @@ pub async fn run(mut vdom: VirtualDom, ws: impl LiveViewSocket) -> Result<(), Li
             .render_with_deadline(tokio::time::sleep(Duration::from_millis(10)))
             .await;
 
-        ws.send(serde_json::to_string(&ClientUpdate::Edits(edits)).unwrap())
+        ws.send(
-            .await?;
+            serde_json::to_string(&ClientUpdate::Edits(edits))
+                .unwrap()
+                .into_bytes(),
+        )
+        .await?;
     }
 }