+3

crates/jacquard-common/src/lib.rs

··· 227 227 #[cfg(feature = "streaming")] 228 228 pub use stream::{ByteStream, ByteSink, StreamError, StreamErrorKind}; 229 229 230 230 + #[cfg(feature = "streaming")] 231 231 + pub use xrpc::StreamingResponse; 232 232 + 230 233 pub use types::value::*; 231 234 232 235 /// Authorization token types for XRPC requests.

+7

crates/jacquard-common/src/xrpc.rs

··· 9 9 //! can inspect `error="invalid_token"` or `error="use_dpop_nonce"` and refresh/retry. 10 10 //! If the header is absent, parse the body and map auth errors to 11 11 //! `AuthError::TokenExpired`/`InvalidToken`. 12 12 + 13 13 + #[cfg(feature = "streaming")] 14 14 + pub mod streaming; 15 15 + 16 16 + #[cfg(feature = "streaming")] 17 17 + pub use streaming::StreamingResponse; 18 18 + 12 19 use bytes::Bytes; 13 20 use http::{ 14 21 HeaderName, HeaderValue, Request, StatusCode,

+82

crates/jacquard-common/src/xrpc/streaming.rs

··· 1 1 + //! Streaming support for XRPC requests and responses 2 2 + 3 3 + use crate::stream::ByteStream; 4 4 + use http::StatusCode; 5 5 + 6 6 + /// XRPC streaming response 7 7 + /// 8 8 + /// Similar to `Response<R>` but holds a streaming body instead of a buffer. 9 9 + pub struct StreamingResponse { 10 10 + parts: http::response::Parts, 11 11 + body: ByteStream, 12 12 + } 13 13 + 14 14 + impl StreamingResponse { 15 15 + /// Create a new streaming response 16 16 + pub fn new(parts: http::response::Parts, body: ByteStream) -> Self { 17 17 + Self { parts, body } 18 18 + } 19 19 + 20 20 + /// Get the HTTP status code 21 21 + pub fn status(&self) -> StatusCode { 22 22 + self.parts.status 23 23 + } 24 24 + 25 25 + /// Get the response headers 26 26 + pub fn headers(&self) -> &http::HeaderMap { 27 27 + &self.parts.headers 28 28 + } 29 29 + 30 30 + /// Get the response version 31 31 + pub fn version(&self) -> http::Version { 32 32 + self.parts.version 33 33 + } 34 34 + 35 35 + /// Consume the response and return parts and body separately 36 36 + pub fn into_parts(self) -> (http::response::Parts, ByteStream) { 37 37 + (self.parts, self.body) 38 38 + } 39 39 + 40 40 + /// Get mutable access to the body stream 41 41 + pub fn body_mut(&mut self) -> &mut ByteStream { 42 42 + &mut self.body 43 43 + } 44 44 + 45 45 + /// Get a reference to the body stream 46 46 + pub fn body(&self) -> &ByteStream { 47 47 + &self.body 48 48 + } 49 49 + } 50 50 + 51 51 + impl std::fmt::Debug for StreamingResponse { 52 52 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 53 53 + f.debug_struct("StreamingResponse") 54 54 + .field("status", &self.parts.status) 55 55 + .field("version", &self.parts.version) 56 56 + .field("headers", &self.parts.headers) 57 57 + .finish_non_exhaustive() 58 58 + } 59 59 + } 60 60 + 61 61 + #[cfg(test)] 62 62 + mod tests { 63 63 + use super::*; 64 64 + use bytes::Bytes; 65 65 + use futures::stream; 66 66 + 67 67 + #[test] 68 68 + fn streaming_response_holds_parts_and_body() { 69 69 + // Build parts from a Response and extract them 70 70 + let response = http::Response::builder() 71 71 + .status(StatusCode::OK) 72 72 + .body(()) 73 73 + .unwrap(); 74 74 + let (parts, _) = response.into_parts(); 75 75 + 76 76 + let stream = stream::iter(vec![Ok(Bytes::from("test"))]); 77 77 + let body = ByteStream::new(stream); 78 78 + 79 79 + let response = StreamingResponse::new(parts, body); 80 80 + assert_eq!(response.status(), StatusCode::OK); 81 81 + } 82 82 + }