parlov-core 0.7.0

//! Private serde helpers for `http` and `bytes` types that lack native serde support.
//!
//! Each submodule is used via `#[serde(with = "...")]` on the fields that need it. They are not
//! part of the public API and exist solely to satisfy the serde derive machinery.

/// Serializes `StatusCode` as its `u16` representation.
pub(crate) mod status_code_serde {
    use http::StatusCode;
    use serde::{Deserialize, Deserializer, Serialize, Serializer};

    // serde `with` module protocol requires `&T` — cannot pass StatusCode by value here.
    #[allow(clippy::trivially_copy_pass_by_ref)]
    pub fn serialize<S: Serializer>(code: &StatusCode, s: S) -> Result<S::Ok, S::Error> {
        code.as_u16().serialize(s)
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<StatusCode, D::Error> {
        let n = u16::deserialize(d)?;
        StatusCode::from_u16(n).map_err(serde::de::Error::custom)
    }
}

/// Serializes `Method` as its string representation (e.g. `"GET"`).
pub(crate) mod method_serde {
    use http::Method;
    use serde::{Deserialize, Deserializer, Serialize, Serializer};

    pub fn serialize<S: Serializer>(method: &Method, s: S) -> Result<S::Ok, S::Error> {
        method.as_str().serialize(s)
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Method, D::Error> {
        let s = String::deserialize(d)?;
        s.parse::<Method>().map_err(serde::de::Error::custom)
    }
}

/// Serializes `HeaderMap` as `[["name", "value"], ...]` pairs.
///
/// Preserves multi-valued headers (e.g. `Set-Cookie`, `Link`). Headers with non-UTF-8 values
/// are silently dropped — not expected in the probe/analysis pipeline.
pub(crate) mod header_map_serde {
    use http::HeaderMap;
    use serde::{Deserializer, Serializer};

    pub fn serialize<S: Serializer>(headers: &HeaderMap, s: S) -> Result<S::Ok, S::Error> {
        s.collect_seq(
            headers
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|v_str| (k.as_str(), v_str))),
        )
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<HeaderMap, D::Error> {
        use serde::Deserialize;
        let pairs = Vec::<(String, String)>::deserialize(d)?;
        let mut headers = HeaderMap::new();
        for (k, v) in pairs {
            let name = k
                .parse::<http::header::HeaderName>()
                .map_err(serde::de::Error::custom)?;
            let value = v
                .parse::<http::header::HeaderValue>()
                .map_err(serde::de::Error::custom)?;
            headers.append(name, value);
        }
        Ok(headers)
    }
}

/// Serializes `Bytes` as a byte sequence (`Vec<u8>`).
pub(crate) mod bytes_serde {
    use bytes::Bytes;
    use serde::{Deserialize, Deserializer, Serialize, Serializer};

    pub fn serialize<S: Serializer>(b: &Bytes, s: S) -> Result<S::Ok, S::Error> {
        b.as_ref().serialize(s)
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Bytes, D::Error> {
        let v = Vec::<u8>::deserialize(d)?;
        Ok(Bytes::from(v))
    }
}

/// Serializes `Option<Bytes>` as an optional byte sequence.
pub(crate) mod opt_bytes_serde {
    use bytes::Bytes;
    use serde::{Deserialize, Deserializer, Serializer};

    // serde `with` module protocol requires `&Option<T>` — cannot use `Option<&T>` here.
    #[allow(clippy::ref_option)]
    pub fn serialize<S: Serializer>(opt: &Option<Bytes>, s: S) -> Result<S::Ok, S::Error> {
        match opt {
            Some(b) => s.serialize_some(b.as_ref()),
            None => s.serialize_none(),
        }
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Bytes>, D::Error> {
        let opt = Option::<Vec<u8>>::deserialize(d)?;
        Ok(opt.map(Bytes::from))
    }
}