refactor(proto): start replacing anyhow with thiserror

proto/src/message/backend.rs

@@ -3,6 +3,7 @@ use crate::message::primitive::pglist::PgList;
 use crate::message::primitive::pgstring::PgString;
 use crate::message::proto_message::ProtoMessage;
 use bincode::{Decode, Encode};
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 #[derive(Debug)]
 pub enum BackendMessage {
@@ -34,7 +35,7 @@ impl ProtoMessage for BackendMessage {
         }
     }
 
-    fn serialize(&self) -> anyhow::Result<Vec<u8>> {
+    fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError> {
         match self {
             BackendMessage::AuthenticationOk(data) => data.serialize(),
             BackendMessage::BackendKeyData(data) => data.serialize(),
@@ -49,7 +50,7 @@ impl ProtoMessage for BackendMessage {
         }
     }
 
-    fn deserialize(variant: u8, data: &[u8]) -> anyhow::Result<BackendMessage> {
+    fn deserialize(variant: u8, data: &[u8]) -> Result<BackendMessage, ProtoDeserializeError> {
         match variant {
             b'R' => Ok(BackendMessage::AuthenticationOk(
                 AuthenticationOkData::deserialize(data)?,
@@ -84,7 +85,7 @@ impl ProtoMessage for BackendMessage {
                 let data = RowDescriptionData::deserialize(data)?;
                 Ok(BackendMessage::RowDescription(data))
             }
-            v => Err(anyhow::anyhow!("Unknown backend message variant: {v}")),
+            v => Err(ProtoDeserializeError::InvalidVariant(v)),
         }
     }
 }
@@ -354,4 +355,13 @@ mod tests {
             _ => false,
         },)
     }
+
+    #[test]
+    fn test_unknown_variant() {
+        let variant = 0;
+        let data = vec![1, 2, 3];
+
+        let message = BackendMessage::deserialize(variant, &data);
+        assert!(matches!(message, Err(ProtoDeserializeError::InvalidVariant(0))));
+    }
 }

proto/src/message/errors.rs

@@ -0,0 +1,16 @@
+use bincode::error::{DecodeError, EncodeError};
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ProtoDeserializeError {
+    #[error("invalid message variant: {0}")]
+    InvalidVariant(u8),
+    #[error("decoding of inner data failed")]
+    DecodeData(#[from] DecodeError),
+}
+
+#[derive(Debug, Error)]
+pub enum ProtoSerializeError {
+    #[error("encoding of inner data failed")]
+    EncodeData(#[from] EncodeError),
+}

proto/src/message/frontend.rs

@@ -2,6 +2,7 @@ use crate::message::primitive::data::MessageData;
 use crate::message::primitive::pgstring::PgString;
 use crate::message::proto_message::ProtoMessage;
 use bincode::{Decode, Encode};
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 #[derive(Debug)]
 pub enum FrontendMessage {
@@ -17,18 +18,18 @@ impl ProtoMessage for FrontendMessage {
         }
     }
 
-    fn serialize(&self) -> anyhow::Result<Vec<u8>> {
+    fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError> {
         match self {
             FrontendMessage::Query(data) => data.serialize(),
             FrontendMessage::Terminate => Ok(Vec::with_capacity(0)),
         }
     }
 
-    fn deserialize(variant: u8, data: &[u8]) -> anyhow::Result<Self> {
+    fn deserialize(variant: u8, data: &[u8]) -> Result<Self, ProtoDeserializeError> {
         match variant {
             b'Q' => Ok(FrontendMessage::Query(QueryData::deserialize(data)?)),
             b'X' => Ok(FrontendMessage::Terminate),
-            v => Err(anyhow::anyhow!("Unknown frontend message variant: {v}")),
+            v => Err(ProtoDeserializeError::InvalidVariant(v)),
         }
     }
 }
@@ -40,6 +41,7 @@ pub struct QueryData {
 
 #[cfg(test)]
 mod tests {
+    use crate::message::backend::BackendMessage;
     use super::*;
 
     #[test]
@@ -65,4 +67,13 @@ mod tests {
         let message = FrontendMessage::deserialize(variant, &raw).unwrap();
         assert!(matches!(message, FrontendMessage::Terminate));
     }
+
+    #[test]
+    fn test_unknown_variant() {
+        let variant = 0;
+        let data = vec![1, 2, 3];
+
+        let message = BackendMessage::deserialize(variant, &data);
+        assert!(matches!(message, Err(ProtoDeserializeError::InvalidVariant(0))));
+    }
 }

proto/src/message/mod.rs

@@ -3,3 +3,4 @@ pub mod frontend;
 pub mod primitive;
 pub mod proto_message;
 pub mod special;
+pub mod errors;

proto/src/message/primitive/data.rs

@@ -1,9 +1,10 @@
 use crate::message::primitive::config::pg_proto_config;
 use bincode::{Decode, Encode};
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 pub trait MessageData: Sized {
-    fn deserialize(data: &[u8]) -> anyhow::Result<Self>;
-    fn serialize(&self) -> anyhow::Result<Vec<u8>>;
+    fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError>;
+    fn deserialize(data: &[u8]) -> Result<Self, ProtoDeserializeError>;
 }
 
 impl<T> MessageData for T
@@ -11,12 +12,12 @@ where
     T: Encode + Decode,
 {
     #[inline]
-    fn deserialize(data: &[u8]) -> anyhow::Result<Self> {
-        Ok(bincode::decode_from_slice(data, pg_proto_config())?.0)
+    fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError> {
+        Ok(bincode::encode_to_vec(self, pg_proto_config())?)
     }
 
     #[inline]
-    fn serialize(&self) -> anyhow::Result<Vec<u8>> {
-        Ok(bincode::encode_to_vec(self, pg_proto_config())?)
+    fn deserialize(data: &[u8]) -> Result<Self, ProtoDeserializeError> {
+        Ok(bincode::decode_from_slice(data, pg_proto_config())?.0)
     }
 }

proto/src/message/proto_message.rs

@@ -1,5 +1,7 @@
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
+
 pub trait ProtoMessage: Sized {
     fn variant(&self) -> u8;
-    fn serialize(&self) -> anyhow::Result<Vec<u8>>;
-    fn deserialize(variant: u8, data: &[u8]) -> anyhow::Result<Self>;
+    fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError>;
+    fn deserialize(variant: u8, data: &[u8]) -> Result<Self, ProtoDeserializeError>;
 }