serverless_fn/
serializer.rs

1//! Serialization/Deserialization module.
2//!
3//! Provides abstraction over different serialization formats like JSON and Postcard.
4
5use serde::{Serialize, de::DeserializeOwned};
6
7use crate::error::ServerlessError;
8
9/// Enumeration of supported serializer types.
10#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11pub enum SerializerType {
12    /// JSON serialization.
13    Json,
14    /// Postcard serialization.
15    Postcard,
16}
17
18impl SerializerType {
19    /// Serializes a value to bytes.
20    ///
21    /// # Errors
22    ///
23    /// Returns an error if serialization fails.
24    pub fn serialize<T: Serialize>(&self, value: &T) -> Result<Vec<u8>, ServerlessError> {
25        match self {
26            SerializerType::Json => Ok(serde_json::to_vec(value)?),
27            SerializerType::Postcard => Ok(postcard::to_allocvec(value)?),
28        }
29    }
30
31    /// Deserializes bytes to a value.
32    ///
33    /// # Errors
34    ///
35    /// Returns an error if deserialization fails.
36    pub fn deserialize<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T, ServerlessError> {
37        match self {
38            SerializerType::Json => Ok(serde_json::from_slice(bytes)?),
39            SerializerType::Postcard => Ok(postcard::from_bytes(bytes)?),
40        }
41    }
42}
43
44/// Returns the default serializer type based on enabled features.
45#[must_use]
46pub fn get_default_serializer_type() -> SerializerType {
47    #[cfg(any(
48        feature = "json_serialization",
49        not(any(feature = "json_serialization", feature = "postcard_serialization"))
50    ))]
51    {
52        SerializerType::Json
53    }
54    #[cfg(all(
55        feature = "postcard_serialization",
56        not(feature = "json_serialization")
57    ))]
58    {
59        SerializerType::Postcard
60    }
61}
62
63/// A wrapper struct for serialization operations.
64#[derive(Clone)]
65pub struct Serializer {
66    serializer_type: SerializerType,
67}
68
69impl Serializer {
70    /// Creates a new serializer with the specified type.
71    #[must_use]
72    pub fn new(serializer_type: SerializerType) -> Self {
73        Self { serializer_type }
74    }
75
76    /// Serializes a value to bytes.
77    ///
78    /// # Errors
79    ///
80    /// Returns an error if serialization fails.
81    pub fn serialize<T: Serialize>(&self, value: &T) -> Result<Vec<u8>, ServerlessError> {
82        self.serializer_type.serialize(value)
83    }
84
85    /// Deserializes bytes to a value.
86    ///
87    /// # Errors
88    ///
89    /// Returns an error if deserialization fails.
90    pub fn deserialize<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T, ServerlessError> {
91        self.serializer_type.deserialize(bytes)
92    }
93}
94
95/// Returns the default serializer based on enabled features.
96#[must_use]
97pub fn get_default_serializer() -> Serializer {
98    Serializer::new(get_default_serializer_type())
99}
100
101#[cfg(test)]
102mod tests {
103    use super::*;
104    use serde::{Deserialize, Serialize};
105
106    #[derive(Serialize, Deserialize, Debug, PartialEq)]
107    struct TestData {
108        name: String,
109        value: u32,
110    }
111
112    #[test]
113    fn test_json_serializer() {
114        let serializer = Serializer::new(SerializerType::Json);
115        let data = TestData {
116            name: "test".to_string(),
117            value: 42,
118        };
119
120        let serialized = serializer.serialize(&data).unwrap();
121        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
122        assert_eq!(data, deserialized);
123    }
124
125    #[test]
126    fn test_postcard_serializer() {
127        let serializer = Serializer::new(SerializerType::Postcard);
128        let data = TestData {
129            name: "test".to_string(),
130            value: 42,
131        };
132
133        let serialized = serializer.serialize(&data).unwrap();
134        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
135        assert_eq!(data, deserialized);
136    }
137
138    #[test]
139    fn test_default_serializer() {
140        let serializer = get_default_serializer();
141        let data = TestData {
142            name: "test".to_string(),
143            value: 42,
144        };
145
146        let serialized = serializer.serialize(&data).unwrap();
147        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
148        assert_eq!(data, deserialized);
149    }
150}
serverless_fn/serializer.rs

serverless_fn/
serializer.rs
