Struct MultipartJsonStream 

pub struct MultipartJsonStream<S> { /* private fields */ }

A multipart/mixed streaming response, one JSON part per item.

Emits, per item: --<boundary>CRLF, Content-Type: application/json, Content-Length: <n>, CRLF, the JSON body, CRLF; and --<boundary>--CRLF on a clean end of the source stream.

The per-part Content-Length is what lets a reader emit each part from that part’s own bytes instead of waiting for the following delimiter — so a live stream is never delivered a part behind. It is a fast path, not a protocol fork: RFC 2046 §5.1 makes the delimiter authoritative, so a strict parser that ignores the header still reads the stream correctly.

Post-open domain error

The wrapped stream yields Result<T, E>. Once the 200 is on the wire a domain failure can no longer become an HTTP status, so an Err(e) is framed as a typed error part: one application/problem+json part carrying Into::<Problem>::into(e), immediately followed by the close delimiter. The stream therefore ends cleanly and the reader surfaces the error as a typed Err item, not a truncation — an Err is terminal, so any later source items are not framed.

If the error Problem itself would exceed [MAX_PART_BYTES], its unbounded fields (detail, context) are dropped so the typed error — status, type, error_code — still reaches the client; only a Problem that cannot fit or serialize even trimmed falls back to an abort.

Mid-stream serialization failure (genuine transport fault)

Distinct from the above: an Ok(item) that will not serialize, or one larger than [MAX_PART_BYTES], is not a domain error — it is a value the framer cannot put on the wire at all. There is no status left to send, so the response body is aborted and the failure is logged at error.

“Abort” specifically means yielding an error into the body stream, which truncates the chunked encoding and makes the reader report a transport error — not ending the stream, which would be a graceful EOF and which the reader treats as a clean end. A silently short stream is worse than a broken connection: the consumer’s reopen path already handles an ungraceful close, but it cannot detect a stream that simply stopped early.

Implementations

impl<S> MultipartJsonStream<S>

pub fn new(stream: S) -> Self

Wrap a stream of serializable items, with a generated boundary.

pub fn with_boundary( stream: S, boundary: impl Into<String>, ) -> Result<Self, BoundaryError>

Wrap a stream of serializable items, with a caller-chosen boundary.

The boundary must be RFC 2046-legal and an HTTP token: 1–70 characters drawn from A-Z a-z 0-9 ' + - . _ (see [validate_boundary]).

Returns BoundaryError if the boundary is rejected, leaving the fallback decision to the caller — typically MultipartJsonStream::new for a generated boundary — rather than silently substituting one, which would hide the caller’s mistake behind a boundary they never chose.

The boundary must also not occur inside any item’s JSON. A generated boundary makes that impossible in practice; a caller-chosen one makes it the caller’s responsibility.

Errors

Returns BoundaryError when boundary is empty, exceeds 70 characters, or contains a character outside the HTTP token set.

pub fn boundary(&self) -> &str

The boundary this response will frame its parts with.

Trait Implementations

impl<S, T, E> IntoResponse for MultipartJsonStream<S>

where S: Stream<Item = Result<T, E>> + Send + 'static, T: Serialize, E: Into<Problem>,

fn into_response(self) -> Response

Create a response.