use futures::stream::{self, Stream, StreamExt};
use plexus_client::{Progress, RemoteError};
use serde::{Serialize, Serializer};
use std::pin::Pin;
use std::sync::Arc;
use super::context::PlexusContext;
use super::credential_envelope::{
assemble_envelope_content, serialize_with_credential_capture, CookieProjector,
};
use super::types::{PlexusStreamItem, StreamMetadata};
pub type PlexusStream = Pin<Box<dyn Stream<Item = PlexusStreamItem> + Send>>;
pub fn wrap_stream<T: Serialize + Send + 'static>(
stream: impl Stream<Item = T> + Send + 'static,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream {
let plexus_hash = PlexusContext::hash();
let metadata = Arc::new(StreamMetadata::new(provenance.clone(), plexus_hash.clone()));
let done = StreamMetadata::new(provenance, plexus_hash);
Box::pin(Wrapped::<_, DataForm> {
inner: stream,
metadata,
content_type,
done: Some(done),
ended: false,
form: std::marker::PhantomData,
})
}
enum Out<D, P> {
Data(D),
Progress(P),
}
struct WireResult<T, E>(Result<T, E>);
impl<T: Serialize, E: Serialize> Serialize for WireResult<T, E> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
plexus_client::wire_result::serialize(&self.0, serializer)
}
}
pub fn wrap_one<T: Serialize + Send + 'static>(
item: T,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream {
wrap_frames(
stream::once(futures::future::ready(Out::<T, ()>::Data(item))),
content_type,
provenance,
)
}
pub fn wrap_one_result<T, E>(
item: Result<T, E>,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream
where
T: Serialize + Send + 'static,
E: Serialize + Send + 'static,
{
wrap_frames(
stream::once(futures::future::ready(Out::<_, ()>::Data(WireResult(item)))),
content_type,
provenance,
)
}
pub fn wrap_result_stream<T, E>(
stream: impl Stream<Item = Result<T, E>> + Send + 'static,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream
where
T: Serialize + Send + 'static,
E: Serialize + Send + 'static,
{
wrap_frames(
stream.map(|r| Out::<_, ()>::Data(WireResult(r))),
content_type,
provenance,
)
}
pub fn wrap_progress_stream<T, P>(
stream: impl Stream<Item = Progress<T, P>> + Send + 'static,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream
where
T: Serialize + Send + 'static,
P: Serialize + Send + 'static,
{
wrap_frames(
stream.map(|step| match step {
Progress::Update(p) => Out::Progress(p),
Progress::Item(t) => Out::Data(t),
}),
content_type,
provenance,
)
}
pub fn wrap_result_progress_stream<T, P, E>(
stream: impl Stream<Item = Result<Progress<T, P>, E>> + Send + 'static,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream
where
T: Serialize + Send + 'static,
P: Serialize + Send + 'static,
E: Serialize + Send + 'static,
{
wrap_frames(
stream.map(|r| match r {
Ok(Progress::Update(p)) => Out::Progress(p),
Ok(Progress::Item(t)) => Out::Data(WireResult(Ok(t))),
Err(e) => Out::Data(WireResult(Err(e))),
}),
content_type,
provenance,
)
}
fn wrap_frames<D, P>(
stream: impl Stream<Item = Out<D, P>> + Send + 'static,
content_type: &'static str,
provenance: Vec<String>,
) -> PlexusStream
where
D: Serialize + Send + 'static,
P: Serialize + Send + 'static,
{
let plexus_hash = PlexusContext::hash();
let metadata = Arc::new(StreamMetadata::new(provenance.clone(), plexus_hash.clone()));
let done = StreamMetadata::new(provenance, plexus_hash);
Box::pin(Wrapped::<_, OutForm> {
inner: stream,
metadata,
content_type,
done: Some(done),
ended: false,
form: std::marker::PhantomData,
})
}
pin_project_lite::pin_project! {
struct Wrapped<S, K> {
#[pin]
inner: S,
metadata: Arc<StreamMetadata>,
content_type: &'static str,
done: Option<StreamMetadata>,
ended: bool,
form: std::marker::PhantomData<fn() -> K>,
}
}
trait Form<I> {
fn frame(item: I, metadata: &Arc<StreamMetadata>, content_type: &'static str) -> PlexusStreamItem;
}
struct DataForm;
impl<T: Serialize> Form<T> for DataForm {
fn frame(event: T, metadata: &Arc<StreamMetadata>, content_type: &'static str) -> PlexusStreamItem {
PlexusStreamItem::Data {
metadata: metadata.clone(),
content_type: std::borrow::Cow::Borrowed(content_type),
content: content_of(&event),
}
}
}
struct OutForm;
impl<D: Serialize, P: Serialize> Form<Out<D, P>> for OutForm {
fn frame(out: Out<D, P>, metadata: &Arc<StreamMetadata>, content_type: &'static str) -> PlexusStreamItem {
match out {
Out::Data(item) => DataForm::frame(item, metadata, content_type),
Out::Progress(p) => PlexusStreamItem::progress(
(**metadata).clone(),
content_type.to_string(),
serde_json::to_value(&p).unwrap_or(serde_json::Value::Null),
),
}
}
}
impl<S, K> Stream for Wrapped<S, K>
where
S: Stream,
K: Form<S::Item>,
{
type Item = PlexusStreamItem;
fn poll_next(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<Option<PlexusStreamItem>> {
use std::task::Poll;
let this = self.project();
if !*this.ended {
match super::wire::nested(|| this.inner.poll_next(cx)) {
Poll::Ready(Some(event)) => return Poll::Ready(Some(K::frame(event, this.metadata, this.content_type))),
Poll::Ready(None) => *this.ended = true,
Poll::Pending => return Poll::Pending,
}
}
Poll::Ready(this.done.take().map(|metadata| PlexusStreamItem::Done { metadata }))
}
}
fn content_of<T: Serialize>(event: &T) -> super::wire::Content {
if let Some(content) = super::wire::encode(event) {
return content;
}
let (payload, captured) = serialize_with_credential_capture(event);
let (content, _hints) = assemble_envelope_content(payload, captured, &CookieProjector::None);
super::wire::Content::from(content)
}
pub fn error_stream(
error: RemoteError,
provenance: Vec<String>,
recoverable: bool,
) -> PlexusStream {
let metadata = StreamMetadata::new(provenance, PlexusContext::hash());
Box::pin(stream::once(async move {
PlexusStreamItem::error(metadata, error, recoverable)
}))
}
pub fn done_stream(provenance: Vec<String>) -> PlexusStream {
let metadata = StreamMetadata::new(provenance, PlexusContext::hash());
Box::pin(stream::once(async move {
PlexusStreamItem::Done { metadata }
}))
}
pub fn progress_stream(
content_type: String,
content: serde_json::Value,
provenance: Vec<String>,
) -> PlexusStream {
let metadata = StreamMetadata::new(provenance, PlexusContext::hash());
Box::pin(stream::once(async move {
PlexusStreamItem::progress(metadata, content_type, content)
}))
}
#[cfg(test)]
mod tests {
use super::*;
use futures::StreamExt;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
struct TestEvent {
value: i32,
}
#[tokio::test]
async fn test_wrap_stream() {
let events = vec![TestEvent { value: 1 }, TestEvent { value: 2 }];
let input_stream = stream::iter(events);
let wrapped = wrap_stream(input_stream, "test.event", vec!["test".into()]);
let items: Vec<_> = wrapped.collect().await;
assert_eq!(items.len(), 3);
match &items[0] {
PlexusStreamItem::Data {
content_type,
content,
metadata,
} => {
assert_eq!(content_type, "test.event");
assert_eq!(content["value"], 1);
assert_eq!(metadata.provenance, vec!["test"]);
}
_ => panic!("Expected Data item"),
}
assert!(matches!(items[2], PlexusStreamItem::Done { .. }));
}
#[tokio::test]
async fn wrap_stream_credential_free_payload_is_wire_identical() {
let events = vec![TestEvent { value: 7 }];
let input_stream = stream::iter(events);
let wrapped = wrap_stream(input_stream, "test.event", vec!["t".into()]);
let items: Vec<_> = wrapped.collect().await;
assert_eq!(items.len(), 2); match &items[0] {
PlexusStreamItem::Data { content, .. } => {
let obj = content.as_object().expect("object");
assert_eq!(obj.get("value").unwrap(), &serde_json::json!(7));
assert!(
!obj.contains_key("_credentials"),
"_credentials key MUST NOT appear on non-credential payloads"
);
assert_eq!(obj.len(), 1, "no extra fields");
}
_ => panic!("Expected Data item"),
}
}
#[tokio::test]
async fn wrap_stream_credential_bearing_payload_emits_sentinel_in_body() {
use plexus_auth_core::{
AttachmentSite, Credential, CredentialIssuer, CredentialKind, CredentialMetadata,
CredentialMinter, CredentialScheme, HeaderName, MethodPath, Origin, Scope,
};
let _ = (
CredentialMinter::issuer, Credential::<String>::metadata,
CredentialIssuer::new(
Origin::new("ws://test"),
MethodPath::try_new("auth.login").unwrap(),
),
CredentialMetadata::new(
CredentialKind::Bearer,
AttachmentSite::Header {
name: HeaderName::try_new("authorization").unwrap(),
},
Some(CredentialScheme::new("Bearer ")),
Vec::<Scope>::new(),
None,
None,
None,
CredentialIssuer::new(
Origin::new("ws://test"),
MethodPath::try_new("auth.login").unwrap(),
),
),
);
#[derive(Serialize)]
struct LoginPayload {
user_id: String,
session: serde_json::Value,
}
let payload = LoginPayload {
user_id: "alice".into(),
session: serde_json::json!({ "$credential": "cred_0" }),
};
let input_stream = stream::iter(vec![payload]);
let wrapped = wrap_stream(input_stream, "auth.login.result", vec!["auth".into()]);
let items: Vec<_> = wrapped.collect().await;
let content = match &items[0] {
PlexusStreamItem::Data { content, .. } => content,
_ => panic!("Expected Data item"),
};
assert_eq!(
content.get("session").unwrap(),
&serde_json::json!({ "$credential": "cred_0" })
);
let obj = content.as_object().unwrap();
assert!(!obj.contains_key("_credentials"),
"sidecar absent until plexus-auth-core exposes DispatchCaptureGuard::install");
}
#[tokio::test]
async fn test_error_stream() {
let stream = error_stream(
RemoteError::Execution {
message: "Something failed".into(),
},
vec!["test".into()],
false,
);
let items: Vec<_> = stream.collect().await;
assert_eq!(items.len(), 1);
match &items[0] {
PlexusStreamItem::Error {
error,
recoverable,
metadata,
..
} => {
assert_eq!(
error,
&RemoteError::Execution {
message: "Something failed".into()
}
);
assert!(!recoverable);
assert_eq!(metadata.provenance, vec!["test"]);
}
_ => panic!("Expected Error item"),
}
}
#[tokio::test]
async fn test_error_stream_carries_recoverable() {
let stream = error_stream(RemoteError::Unauthenticated, vec!["test".into()], true);
let items: Vec<_> = stream.collect().await;
assert_eq!(items.len(), 1);
assert!(matches!(
&items[0],
PlexusStreamItem::Error {
error: RemoteError::Unauthenticated,
recoverable: true,
..
}
));
}
#[tokio::test]
async fn test_progress_stream() {
let stream = progress_stream(
"test.import".into(),
serde_json::json!({"message": "indexing", "percentage": 50.0}),
vec!["test".into()],
);
let items: Vec<_> = stream.collect().await;
assert_eq!(items.len(), 1);
match &items[0] {
PlexusStreamItem::Progress {
content_type,
content,
..
} => {
assert_eq!(content_type, "test.import");
let note: plexus_client::Note =
serde_json::from_value(content.clone()).expect("a Note");
assert_eq!(note, plexus_client::Note::new("indexing").with_percentage(50.0));
}
_ => panic!("Expected Progress item"),
}
}
async fn frames(stream: PlexusStream) -> Vec<(&'static str, serde_json::Value)> {
let items: Vec<_> = stream.collect().await;
let (last, body) = items.split_last().expect("at least a done");
assert!(matches!(last, PlexusStreamItem::Done { .. }), "ends in done");
body.iter()
.map(|item| match item {
PlexusStreamItem::Data { content_type, content, .. } => {
assert_eq!(content_type, "t.m");
("data", content.clone().into_value())
}
PlexusStreamItem::Progress { content_type, content, .. } => {
assert_eq!(content_type, "t.m");
("progress", content.clone())
}
PlexusStreamItem::Done { .. } => panic!("a second done"),
other => panic!("unexpected frame {other:?}"),
})
.collect()
}
#[tokio::test]
async fn wrap_one_is_one_data_frame_then_done() {
let got = frames(wrap_one(TestEvent { value: 1 }, "t.m", vec!["t".into()])).await;
assert_eq!(got, vec![("data", serde_json::json!({"value": 1}))]);
}
#[tokio::test]
async fn wrap_one_result_carries_ok_or_err() {
let ok: Result<u32, String> = Ok(7);
let err: Result<u32, String> = Err("no".into());
assert_eq!(
frames(wrap_one_result(ok, "t.m", vec!["t".into()])).await,
vec![("data", serde_json::json!({"ok": 7}))]
);
assert_eq!(
frames(wrap_one_result(err, "t.m", vec!["t".into()])).await,
vec![("data", serde_json::json!({"err": "no"}))]
);
}
#[tokio::test]
async fn wrap_result_stream_carries_on_past_an_err() {
let items: Vec<Result<u32, String>> = vec![Ok(1), Err("bad".into()), Ok(3)];
let got = frames(wrap_result_stream(stream::iter(items), "t.m", vec!["t".into()])).await;
assert_eq!(
got,
vec![
("data", serde_json::json!({"ok": 1})),
("data", serde_json::json!({"err": "bad"})),
("data", serde_json::json!({"ok": 3})),
]
);
}
#[tokio::test]
async fn wrap_progress_stream_splits_updates_from_items() {
let steps: Vec<Progress<u32>> = vec![
Progress::Update(plexus_client::Note::new("half").with_percentage(50.0)),
Progress::Item(9),
];
let got = frames(wrap_progress_stream(stream::iter(steps), "t.m", vec!["t".into()])).await;
assert_eq!(
got,
vec![
("progress", serde_json::json!({"message": "half", "percentage": 50.0})),
("data", serde_json::json!(9)),
]
);
}
#[tokio::test]
async fn wrap_result_progress_stream_maps_all_three_cases() {
let steps: Vec<Result<Progress<u32, String>, String>> = vec![
Ok(Progress::Update("step".into())),
Ok(Progress::Item(1)),
Err("refused".into()),
];
let got = frames(wrap_result_progress_stream(
stream::iter(steps),
"t.m",
vec!["t".into()],
))
.await;
assert_eq!(
got,
vec![
("progress", serde_json::json!("step")),
("data", serde_json::json!({"ok": 1})),
("data", serde_json::json!({"err": "refused"})),
]
);
}
}