added support for serde-lite

Author: maccesch

Cargo.toml

@@ -20,16 +20,20 @@ rkyv = { version = "0.7", optional = true, features = ["validation", "strict"] }
 rmp-serde = { version = "1.1", optional = true }
 serde = { version = "1", optional = true }
 serde_json = { version = "1", optional = true }
+serde-lite = { version = "0.5", optional = true }
 thiserror = "1.0.61"
 
 [features]
 prost = ["dep:prost"]
 json_serde = ["dep:serde_json", "dep:serde"]
 msgpack_serde = ["dep:rmp-serde", "dep:serde"]
 bincode_serde = ["dep:bincode", "dep:serde"]
+serde_lite = ["dep:serde-lite"]
+
 
 [dev-dependencies]
 serde = { version = "1", features = ["derive"] }
+serde-lite = { version = "0.5", features = ["derive"] }
 leptos = "0.6"
 leptos-use = "0.10"
 

src/lib.rs

@@ -159,18 +159,13 @@
 pub mod binary;
 mod error;
 mod hybrid;
+#[cfg(feature = "serde_lite")]
+mod serde_lite;
 pub mod string;
 mod traits;
 
 pub use error::*;
 pub use hybrid::*;
+#[cfg(feature = "serde_lite")]
+pub use serde_lite::*;
 pub use traits::*;
-
-// #[cfg(test)]
-// mod tests {
-//     #[test]
-//     fn it_works() {
-//         let result = add(2, 2);
-//         assert_eq!(result, 4);
-//     }
-// }

src/serde_lite.rs

@@ -0,0 +1,78 @@
+use crate::{Decoder, Encoder};
+use serde_lite::{Deserialize, Intermediate, Serialize};
+
+/// A wrapper codec that relies on [`serde_lite`]. With this, you can wrap serde based codecs that
+/// also work with serde-lite like the [`JsonSerdeCodec`] or the [`MsgpackSerdeCodec`].
+///
+/// Only available with the **`serde_lite` feature** enabled plus the feature you need for the
+/// wrapped codec.
+///
+/// ## Example
+///
+/// ```
+/// use codee::{Encoder, Decoder, SerdeLite, string::JsonSerdeCodec, binary::MsgpackSerdeCodec};
+/// use serde_lite::{Deserialize, Serialize};
+///
+/// #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+/// struct Test {
+///     s: String,
+///     i: i32,
+/// }
+///
+/// let t = Test {
+///     s: String::from("party time 🎉"),
+///     i: 42,
+/// };
+///
+/// let enc = SerdeLite::<JsonSerdeCodec>::encode(&t).unwrap();
+/// let dec: Test = SerdeLite::<JsonSerdeCodec>::decode(&enc).unwrap();
+///
+/// let enc = SerdeLite::<MsgpackSerdeCodec>::encode(&t).unwrap();
+/// let dec: Test = SerdeLite::<MsgpackSerdeCodec>::decode(&enc).unwrap();
+/// assert_eq!(dec, t);
+/// ```
+pub struct SerdeLite<C>(C);
+
+#[derive(Debug, thiserror::Error)]
+pub enum SerdeLiteEncodeError<E> {
+    #[error("Error from serde-lite: {0}")]
+    SerdeLite(serde_lite::Error),
+    #[error("Error from wrapped encoder")]
+    Encoder(#[from] E),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum SerdeLiteDecodeError<E> {
+    #[error("Error from serde-lite: {0}")]
+    SerdeLite(serde_lite::Error),
+    #[error("Error from wrapped decoder")]
+    Decoder(#[from] E),
+}
+
+impl<T, E> Encoder<T> for SerdeLite<E>
+where
+    T: Serialize,
+    E: Encoder<Intermediate>,
+{
+    type Error = SerdeLiteEncodeError<<E as Encoder<Intermediate>>::Error>;
+    type Encoded = <E as Encoder<Intermediate>>::Encoded;
+
+    fn encode(val: &T) -> Result<Self::Encoded, Self::Error> {
+        let intermediate = val.serialize().map_err(SerdeLiteEncodeError::SerdeLite)?;
+        Ok(E::encode(&intermediate)?)
+    }
+}
+
+impl<T, D> Decoder<T> for SerdeLite<D>
+where
+    T: Deserialize,
+    D: Decoder<Intermediate>,
+{
+    type Error = SerdeLiteDecodeError<<D as Decoder<Intermediate>>::Error>;
+    type Encoded = <D as Decoder<Intermediate>>::Encoded;
+
+    fn decode(val: &Self::Encoded) -> Result<T, Self::Error> {
+        let intermediate = D::decode(val)?;
+        Ok(T::deserialize(&intermediate).map_err(SerdeLiteDecodeError::SerdeLite)?)
+    }
+}

src/string/json_serde.rs

@@ -1,4 +1,5 @@
 use crate::{Decoder, Encoder};
+use serde::{Deserialize, Serialize};
 
 /// A codec for encoding JSON messages that relies on [`serde_json`].
 ///
@@ -28,7 +29,7 @@ use crate::{Decoder, Encoder};
 /// ```
 pub struct JsonSerdeCodec;
 
-impl<T: serde::Serialize> Encoder<T> for JsonSerdeCodec {
+impl<T: Serialize> Encoder<T> for JsonSerdeCodec {
     type Error = serde_json::Error;
     type Encoded = String;
 
@@ -37,7 +38,10 @@ impl<T: serde::Serialize> Encoder<T> for JsonSerdeCodec {
     }
 }
 
-impl<T: serde::de::DeserializeOwned> Decoder<T> for JsonSerdeCodec {
+impl<T> Decoder<T> for JsonSerdeCodec
+where
+    for<'de> T: Deserialize<'de>,
+{
     type Error = serde_json::Error;
     type Encoded = str;
 
@@ -52,7 +56,7 @@ mod tests {
 
     #[test]
     fn test_json_codec() {
-        #[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
         struct Test {
             s: String,
             i: i32,