tako/

body.rs

//! HTTP request and response body handling utilities for efficient data processing.
//!
//! This module provides `TakoBody`, a flexible wrapper around HTTP body implementations
//! that supports various data sources including static content, streams, and dynamic
//! generation. It integrates with Hyper's body system while providing convenience methods
//! for common use cases like creating empty bodies, streaming data, and converting from
//! different input types with efficient memory management.
//!
//! # Examples
//!
//! ```rust
//! use tako::body::TakoBody;
//! use bytes::Bytes;
//! use futures_util::stream;
//!
//! // Create empty body
//! let empty = TakoBody::empty();
//!
//! // Create from string
//! let text_body = TakoBody::from("Hello, World!");
//!
//! // Create from bytes
//! let bytes_body = TakoBody::from(Bytes::from("Binary data"));
//!
//! // Create from stream
//! let stream_data = stream::iter(vec![
//!     Ok(Bytes::from("chunk1")),
//!     Ok(Bytes::from("chunk2")),
//! ]);
//! let stream_body = TakoBody::from_stream(stream_data);
//! ```

use std::{
  fmt::Debug,
  pin::Pin,
  task::{Context, Poll},
};

use bytes::Bytes;

use anyhow::Result;
use futures_util::{Stream, TryStream, TryStreamExt};
use http_body::{Body, Frame, SizeHint};
use http_body_util::{BodyExt, Empty, StreamBody};

use crate::types::{BoxBody, BoxError};

/// HTTP body wrapper with streaming and conversion support.
///
/// `TakoBody` provides a unified interface for handling HTTP request and response bodies
/// with support for various data sources. It wraps Hyper's body system with additional
/// convenience methods and efficient conversion capabilities. The implementation supports
/// both static content and streaming data while maintaining performance through zero-copy
/// operations where possible.
///
/// # Examples
///
/// ```rust
/// use tako::body::TakoBody;
/// use http_body_util::Full;
/// use bytes::Bytes;
///
/// // Static content
/// let static_body = TakoBody::from("Static response");
///
/// // Dynamic content
/// let dynamic = format!("User count: {}", 42);
/// let dynamic_body = TakoBody::from(dynamic);
///
/// // Binary data
/// let binary_data = vec![0u8, 1, 2, 3, 4];
/// let binary_body = TakoBody::from(binary_data);
///
/// // Empty response
/// let empty_body = TakoBody::empty();
/// ```
pub struct TakoBody(BoxBody);

impl TakoBody {
  /// Creates a new body from any type implementing the `Body` trait.
  pub fn new<B>(body: B) -> Self
  where
    B: Body<Data = Bytes> + Send + 'static,
    B::Error: Into<BoxError>,
  {
    Self(body.map_err(|e| e.into()).boxed_unsync())
  }

  /// Creates a body from a stream of byte results.
  pub fn from_stream<S, E>(stream: S) -> Self
  where
    S: Stream<Item = Result<Bytes, E>> + Send + 'static,
    E: Into<BoxError> + Debug + 'static,
  {
    let stream = stream.map_err(Into::into).map_ok(http_body::Frame::data);
    let body = StreamBody::new(stream).boxed_unsync();
    Self(body)
  }

  /// Creates a body from a stream of HTTP frames.
  pub fn from_try_stream<S, E>(stream: S) -> Self
  where
    S: TryStream<Ok = Frame<Bytes>, Error = E> + Send + 'static,
    E: Into<BoxError> + 'static,
  {
    let body = StreamBody::new(stream.map_err(Into::into)).boxed_unsync();
    Self(body)
  }

  /// Creates an empty body with no content.
  pub fn empty() -> Self {
    Self::new(Empty::new())
  }
}

/// Provides a default empty body implementation.
impl Default for TakoBody {
  fn default() -> Self {
    Self::empty()
  }
}

impl From<()> for TakoBody {
  fn from(_: ()) -> Self {
    Self::empty()
  }
}

impl From<&str> for TakoBody {
  fn from(buf: &str) -> Self {
    let owned = buf.to_owned();
    Self::new(http_body_util::Full::from(owned))
  }
}

/// Macro for implementing `From` conversions for various types.
macro_rules! body_from_impl {
  ($ty:ty) => {
    impl From<$ty> for TakoBody {
      fn from(buf: $ty) -> Self {
        Self::new(http_body_util::Full::from(buf))
      }
    }
  };
}

body_from_impl!(String);
body_from_impl!(Vec<u8>);
body_from_impl!(Bytes);

/// Implements the HTTP `Body` trait for streaming and polling operations.
///
/// This implementation enables `TakoBody` to be used as an HTTP body in Hyper
/// and other HTTP libraries. It delegates all operations to the inner boxed
/// body while providing the required type information and polling behavior.
///
/// # Examples
///
/// ```rust,no_run
/// use tako::body::TakoBody;
/// use http_body::Body;
/// use std::pin::Pin;
/// use std::task::{Context, Poll};
///
/// async fn consume_body(mut body: TakoBody) {
///     // Body can be polled for frames
///     let size_hint = body.size_hint();
///     let is_empty = body.is_end_stream();
/// }
/// ```
impl Body for TakoBody {
  type Data = Bytes;
  type Error = BoxError;

  /// Polls for the next frame of body data.
  #[inline]
  fn poll_frame(
    mut self: Pin<&mut Self>,
    cx: &mut Context<'_>,
  ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
    Pin::new(&mut self.0).poll_frame(cx)
  }

  /// Provides size hints for the body content.
  #[inline]
  fn size_hint(&self) -> SizeHint {
    self.0.size_hint()
  }

  /// Indicates whether the body has reached the end of the stream.
  #[inline]
  fn is_end_stream(&self) -> bool {
    self.0.is_end_stream()
  }
}