use crate::envelope::StreamItem;
use crate::error::ClientError;
use crate::event::ClientEvent;
use crate::transport::ItemStream;
use futures_core::Stream;
use futures_util::{stream, StreamExt};
use serde::de::DeserializeOwned;
use std::pin::Pin;
#[cfg(not(target_arch = "wasm32"))]
pub type EventStream<'a, E> =
Pin<Box<dyn Stream<Item = Result<ClientEvent<E>, ClientError>> + Send + 'a>>;
#[cfg(target_arch = "wasm32")]
pub type EventStream<'a, E> = Pin<Box<dyn Stream<Item = Result<ClientEvent<E>, ClientError>> + 'a>>;
pub fn decode<'a, E>(items: ItemStream<'a>) -> EventStream<'a, E>
where
E: DeserializeOwned + 'a,
{
Box::pin(stream::unfold(Some(items), |state| async move {
let mut items = state?;
loop {
let next = items.next().await?;
match next {
Err(e) => return Some((Err(ClientError::Transport(e)), None)),
Ok(StreamItem::Done { .. }) => return None,
Ok(StreamItem::Data {
content,
content_type,
..
}) => {
return Some(match serde_json::from_value::<E>(content) {
Ok(event) => (Ok(ClientEvent::Data(event)), Some(items)),
Err(e) => (
Err(ClientError::Decode {
content_type,
message: e.to_string(),
}),
None,
),
})
}
Ok(StreamItem::Progress {
message,
percentage,
..
}) => {
return Some((
Ok(ClientEvent::Progress {
message,
percentage,
}),
Some(items),
))
}
Ok(StreamItem::Error {
message,
code,
recoverable,
..
}) => {
return Some((
Err(ClientError::Remote {
message,
code,
recoverable,
}),
None,
))
}
Ok(StreamItem::Request { .. }) => continue,
}
}
}))
}
pub fn error_stream<'a, E>(error: ClientError) -> EventStream<'a, E>
where
E: 'a,
{
Box::pin(stream::once(async move { Err(error) }))
}
pub async fn collect_data<E, S>(mut stream: S) -> Result<Vec<E>, ClientError>
where
S: Stream<Item = Result<ClientEvent<E>, ClientError>> + Unpin,
{
let mut out = Vec::new();
while let Some(item) = stream.next().await {
match item? {
ClientEvent::Data(e) => out.push(e),
ClientEvent::Progress { .. } => {}
}
}
Ok(out)
}