use std::{
fmt,
pin::Pin,
task::{Context, Poll},
};
use bytes::Bytes;
use futures_util::Stream;
use http_body::Body as _;
use http_body::{Frame, SizeHint};
use serde::de::DeserializeOwned;
mod json;
mod sse;
pub(crate) use json::{
CONTENT_TYPE as NDJSON_CONTENT_TYPE, DOCUMENT_CONTENT_TYPE as JSON_CONTENT_TYPE,
encode as ndjson_body, encode_array as json_array_body,
};
pub(crate) use sse::{CONTENT_TYPE as SSE_CONTENT_TYPE, encode as sse_body};
use crate::{Body, Error, Event, Result};
const TERMINAL_DATA: &str = "[DONE]";
enum Item {
Json(Bytes),
Event(Event),
}
struct Decoder {
framing: Framing,
}
enum Framing {
Json(json::Document),
Ndjson(json::Lines),
Sse(sse::Decoder),
}
impl Decoder {
fn json(limit: usize) -> Self {
Self {
framing: Framing::Json(json::Document::new(limit)),
}
}
fn ndjson(limit: usize) -> Self {
Self {
framing: Framing::Ndjson(json::Lines::new(limit)),
}
}
fn sse(limit: usize) -> Self {
Self {
framing: Framing::Sse(sse::Decoder::new(limit)),
}
}
fn push_one(&mut self, bytes: &[u8], offset: &mut usize) -> Result<Option<Item>> {
match &mut self.framing {
Framing::Json(decoder) => decoder
.push_one(bytes, offset)
.map(|item| item.map(Item::Json)),
Framing::Ndjson(decoder) => decoder
.push_one(bytes, offset)
.map(|item| item.map(Item::Json)),
Framing::Sse(decoder) => decoder
.push_one(bytes, offset)
.map(|item| item.map(Item::Event)),
}
}
fn finish(&mut self) -> Result<Option<Item>> {
match &mut self.framing {
Framing::Json(decoder) => Ok(decoder.finish().map(Item::Json)),
Framing::Ndjson(decoder) => decoder.finish().map(|item| item.map(Item::Json)),
Framing::Sse(decoder) => decoder.finish().map(|item| item.map(Item::Event)),
}
}
}
pub struct ResponseStream {
body: Body,
item_limit: usize,
}
impl ResponseStream {
pub(crate) fn new(body: Body, item_limit: usize) -> Self {
Self { body, item_limit }
}
#[must_use]
pub fn json<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream::new(self.body, Decoder::json(self.item_limit), decode_json)
}
#[must_use]
pub fn ndjson<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream::new(self.body, Decoder::ndjson(self.item_limit), decode_json)
}
#[must_use]
pub fn sse(self) -> EventStream {
EventStream {
inner: FramedStream::new(self.body, Decoder::sse(self.item_limit), keep_event),
}
}
#[must_use]
pub fn into_body(self) -> Body {
self.body
}
pub async fn next(&mut self) -> Result<Option<Bytes>> {
std::future::poll_fn(|context| Pin::new(&mut *self).poll_next(context))
.await
.transpose()
}
}
impl Stream for ResponseStream {
type Item = Result<Bytes>;
fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
loop {
match Pin::new(&mut self.body).poll_frame(context) {
Poll::Ready(Some(Ok(frame))) => {
if let Ok(data) = frame.into_data()
&& !data.is_empty()
{
return Poll::Ready(Some(Ok(data)));
}
}
Poll::Ready(Some(Err(error))) => return Poll::Ready(Some(Err(error))),
Poll::Ready(None) => return Poll::Ready(None),
Poll::Pending => return Poll::Pending,
}
}
}
}
impl http_body::Body for ResponseStream {
type Data = Bytes;
type Error = Error;
fn poll_frame(
self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Option<std::result::Result<Frame<Self::Data>, Self::Error>>> {
Pin::new(&mut self.get_mut().body).poll_frame(context)
}
fn is_end_stream(&self) -> bool {
self.body.is_end_stream()
}
fn size_hint(&self) -> SizeHint {
self.body.size_hint()
}
}
impl fmt::Debug for ResponseStream {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ResponseStream")
.field("item_limit", &self.item_limit)
.finish_non_exhaustive()
}
}
pub struct EventStream {
inner: FramedStream<Event>,
}
impl EventStream {
#[must_use]
pub fn json<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream::new_from(self.inner, decode_event_json)
}
#[must_use]
pub fn json_until_done<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream::new_from(self.inner, decode_event_json_until_done)
}
pub async fn next(&mut self) -> Result<Option<Event>> {
std::future::poll_fn(|context| Pin::new(&mut *self).poll_next(context))
.await
.transpose()
}
}
impl Stream for EventStream {
type Item = Result<Event>;
fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.inner).poll_next(context)
}
}
impl fmt::Debug for EventStream {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("EventStream")
.finish_non_exhaustive()
}
}
pub struct JsonStream<T> {
inner: FramedStream<T>,
}
impl<T> JsonStream<T> {
fn new(body: Body, decoder: Decoder, decode: fn(Item) -> Decoded<T>) -> Self {
Self {
inner: FramedStream::new(body, decoder, decode),
}
}
fn new_from<U>(inner: FramedStream<U>, decode: fn(Item) -> Decoded<T>) -> Self {
Self {
inner: FramedStream {
body: inner.body,
decoder: inner.decoder,
pending_data: inner.pending_data,
data_offset: inner.data_offset,
decode,
finished: inner.finished,
},
}
}
pub async fn next(&mut self) -> Result<Option<T>> {
std::future::poll_fn(|context| Pin::new(&mut *self).poll_next(context))
.await
.transpose()
}
}
impl<T> Stream for JsonStream<T> {
type Item = Result<T>;
fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.inner).poll_next(context)
}
}
impl<T> fmt::Debug for JsonStream<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.debug_struct("JsonStream").finish_non_exhaustive()
}
}
struct FramedStream<T> {
body: Body,
decoder: Decoder,
pending_data: Option<Bytes>,
data_offset: usize,
decode: fn(Item) -> Decoded<T>,
finished: bool,
}
enum Decoded<T> {
Item(T),
Finished,
Error(Error),
}
impl<T> FramedStream<T> {
fn new(body: Body, decoder: Decoder, decode: fn(Item) -> Decoded<T>) -> Self {
Self {
body,
decoder,
pending_data: None,
data_offset: 0,
decode,
finished: false,
}
}
fn poll_item(&mut self, context: &mut Context<'_>) -> Poll<Option<Result<Item>>> {
loop {
if let Some(data) = self.pending_data.take() {
let mut offset = self.data_offset;
let next_item = self.decoder.push_one(&data, &mut offset);
if offset < data.len() {
self.pending_data = Some(data);
self.data_offset = offset;
} else {
self.data_offset = 0;
}
match next_item {
Ok(Some(item)) => return Poll::Ready(Some(Ok(item))),
Ok(None) => {}
Err(error) => {
self.finished = true;
self.pending_data = None;
return Poll::Ready(Some(Err(error)));
}
}
}
if self.finished {
return Poll::Ready(None);
}
match Pin::new(&mut self.body).poll_frame(context) {
Poll::Ready(Some(Ok(frame))) => {
if let Ok(data) = frame.into_data() {
self.pending_data = Some(data);
self.data_offset = 0;
}
}
Poll::Ready(Some(Err(error))) => {
self.finished = true;
return Poll::Ready(Some(Err(error)));
}
Poll::Ready(None) => {
self.finished = true;
return match self.decoder.finish() {
Ok(Some(item)) => Poll::Ready(Some(Ok(item))),
Ok(None) => Poll::Ready(None),
Err(error) => Poll::Ready(Some(Err(error))),
};
}
Poll::Pending => return Poll::Pending,
}
}
}
}
impl<T> Stream for FramedStream<T> {
type Item = Result<T>;
fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
if self.finished {
return Poll::Ready(None);
}
match self.poll_item(context) {
Poll::Ready(Some(Ok(item))) => match (self.decode)(item) {
Decoded::Item(item) => Poll::Ready(Some(Ok(item))),
Decoded::Finished => {
self.finished = true;
Poll::Ready(None)
}
Decoded::Error(error) => {
self.finished = true;
Poll::Ready(Some(Err(error)))
}
},
Poll::Ready(Some(Err(error))) => {
self.finished = true;
Poll::Ready(Some(Err(error)))
}
Poll::Ready(None) => {
self.finished = true;
Poll::Ready(None)
}
Poll::Pending => Poll::Pending,
}
}
}
fn keep_event(item: Item) -> Decoded<Event> {
match item {
Item::Event(event) => Decoded::Item(event),
Item::Json(_) => Decoded::Error(Error::decode("stream framing produced an invalid item")),
}
}
fn decode_json<T>(item: Item) -> Decoded<T>
where
T: DeserializeOwned,
{
let Item::Json(data) = item else {
return Decoded::Error(Error::decode("stream framing produced an invalid item"));
};
match crate::content::decode_json(&data, "stream JSON could not be decoded") {
Ok(value) => Decoded::Item(value),
Err(error) => Decoded::Error(error),
}
}
fn decode_event_json<T>(item: Item) -> Decoded<T>
where
T: DeserializeOwned,
{
let Item::Event(event) = item else {
return Decoded::Error(Error::decode("stream framing produced an invalid item"));
};
match crate::content::decode_json(event.data().as_bytes(), "event JSON could not be decoded") {
Ok(value) => Decoded::Item(value),
Err(error) => Decoded::Error(error),
}
}
fn decode_event_json_until_done<T>(item: Item) -> Decoded<T>
where
T: DeserializeOwned,
{
if matches!(&item, Item::Event(event) if event.data() == TERMINAL_DATA) {
return Decoded::Finished;
}
decode_event_json(item)
}