serverless-fn 0.1.0

//! Serialization/Deserialization module.
//!
//! Provides abstraction over different serialization formats like JSON and Postcard.

use serde::{Serialize, de::DeserializeOwned};

use crate::error::ServerlessError;

/// Enumeration of supported serializer types.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SerializerType {
    /// JSON serialization.
    Json,
    /// Postcard serialization.
    Postcard,
}

impl SerializerType {
    /// Serializes a value to bytes.
    ///
    /// # Errors
    ///
    /// Returns an error if serialization fails.
    pub fn serialize<T: Serialize>(&self, value: &T) -> Result<Vec<u8>, ServerlessError> {
        match self {
            SerializerType::Json => Ok(serde_json::to_vec(value)?),
            SerializerType::Postcard => Ok(postcard::to_allocvec(value)?),
        }
    }

    /// Deserializes bytes to a value.
    ///
    /// # Errors
    ///
    /// Returns an error if deserialization fails.
    pub fn deserialize<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T, ServerlessError> {
        match self {
            SerializerType::Json => Ok(serde_json::from_slice(bytes)?),
            SerializerType::Postcard => Ok(postcard::from_bytes(bytes)?),
        }
    }
}

/// Returns the default serializer type based on enabled features.
#[must_use]
pub fn get_default_serializer_type() -> SerializerType {
    #[cfg(any(
        feature = "json_serialization",
        not(any(feature = "json_serialization", feature = "postcard_serialization"))
    ))]
    {
        SerializerType::Json
    }
    #[cfg(all(
        feature = "postcard_serialization",
        not(feature = "json_serialization")
    ))]
    {
        SerializerType::Postcard
    }
}

/// A wrapper struct for serialization operations.
#[derive(Clone)]
pub struct Serializer {
    serializer_type: SerializerType,
}

impl Serializer {
    /// Creates a new serializer with the specified type.
    #[must_use]
    pub fn new(serializer_type: SerializerType) -> Self {
        Self { serializer_type }
    }

    /// Serializes a value to bytes.
    ///
    /// # Errors
    ///
    /// Returns an error if serialization fails.
    pub fn serialize<T: Serialize>(&self, value: &T) -> Result<Vec<u8>, ServerlessError> {
        self.serializer_type.serialize(value)
    }

    /// Deserializes bytes to a value.
    ///
    /// # Errors
    ///
    /// Returns an error if deserialization fails.
    pub fn deserialize<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T, ServerlessError> {
        self.serializer_type.deserialize(bytes)
    }
}

/// Returns the default serializer based on enabled features.
#[must_use]
pub fn get_default_serializer() -> Serializer {
    Serializer::new(get_default_serializer_type())
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::{Deserialize, Serialize};

    #[derive(Serialize, Deserialize, Debug, PartialEq)]
    struct TestData {
        name: String,
        value: u32,
    }

    #[test]
    fn test_json_serializer() {
        let serializer = Serializer::new(SerializerType::Json);
        let data = TestData {
            name: "test".to_string(),
            value: 42,
        };

        let serialized = serializer.serialize(&data).unwrap();
        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
        assert_eq!(data, deserialized);
    }

    #[test]
    fn test_postcard_serializer() {
        let serializer = Serializer::new(SerializerType::Postcard);
        let data = TestData {
            name: "test".to_string(),
            value: 42,
        };

        let serialized = serializer.serialize(&data).unwrap();
        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
        assert_eq!(data, deserialized);
    }

    #[test]
    fn test_default_serializer() {
        let serializer = get_default_serializer();
        let data = TestData {
            name: "test".to_string(),
            value: 42,
        };

        let serialized = serializer.serialize(&data).unwrap();
        let deserialized: TestData = serializer.deserialize(&serialized).unwrap();
        assert_eq!(data, deserialized);
    }
}