tez 0.0.2

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
use std::{fmt, time::Duration};

use serde::de::DeserializeOwned;

use crate::{Error, Result};

/// One logical event decoded from a streaming response.
///
/// JSON, NDJSON, and JSON Lines events have only data. Server-sent events may
/// additionally expose their event name, identifier, and retry delay.
#[derive(Clone, Eq, PartialEq)]
pub struct Event {
    event: Option<String>,
    data: String,
    id: Option<String>,
    retry: Option<Duration>,
}

impl Event {
    pub(crate) fn new(data: String) -> Self {
        Self {
            event: None,
            data,
            id: None,
            retry: None,
        }
    }

    pub(crate) fn with_metadata(
        data: String,
        event: Option<String>,
        id: Option<String>,
        retry: Option<Duration>,
    ) -> Self {
        Self {
            event,
            data,
            id,
            retry,
        }
    }

    /// Returns the optional SSE event name.
    #[must_use]
    pub fn event(&self) -> Option<&str> {
        self.event.as_deref()
    }

    /// Returns the complete, newline-joined data field.
    #[must_use]
    pub fn data(&self) -> &str {
        &self.data
    }

    /// Returns the current event identifier, when one has been set.
    #[must_use]
    pub fn id(&self) -> Option<&str> {
        self.id.as_deref()
    }

    /// Returns the current reconnection delay requested by the server.
    #[must_use]
    pub fn retry(&self) -> Option<Duration> {
        self.retry
    }

    /// Decodes the event data as JSON.
    pub fn json<T>(&self) -> Result<T>
    where
        T: DeserializeOwned,
    {
        serde_json::from_str(&self.data)
            .map_err(|_| Error::decode("event JSON could not be decoded"))
    }
}

impl fmt::Debug for Event {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("Event")
            .field("has_event", &self.event.is_some())
            .field("data_len", &self.data.len())
            .field("has_id", &self.id.is_some())
            .field("retry", &self.retry)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn debug_never_exposes_event_contents() {
        let event = Event::with_metadata(
            "body secret".to_owned(),
            Some("event secret".to_owned()),
            Some("id secret".to_owned()),
            None,
        );

        let debug = format!("{event:?}");
        assert!(!debug.contains("event secret"));
        assert!(!debug.contains("body secret"));
        assert!(!debug.contains("id secret"));
        assert!(debug.contains("has_event"));
        assert!(debug.contains("data_len"));
    }
}