Struct JetStreamPublish 

pub struct JetStreamPublish { /* private fields */ }

The JetStream publish policy: pure declaration, constructible anywhere.

It carries what belongs to the publisher rather than to a message, which on JetStream is one thing: the stream the subject must be served by. A publisher that states expect_stream("ORDERS") fails loudly if its subject is routed elsewhere, instead of writing somewhere unintended.

The sequence and message-id expectations are not here. They belong to one message - an expected last sequence fixed for the life of a publisher can hold for at most one publish - so they are JetStreamOptions fields, set by the JetStreamPublishSteps steps at the call site.

Examples

use ruststream_nats::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Payment {
    order: u64,
}

#[derive(Serialize, Outgoing)]
#[outgoing(name = "orders.paid")]
struct Paid {
    order: u64,
}

#[subscriber("payments.settled", reply)]
async fn record(payment: &Payment) -> Paid {
    Paid { order: payment.order }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("payments", "0.1.0")).with_broker(
        NatsBroker::new("nats://localhost:4222"),
        |b| {
            // The reply is stored, and a subject the ORDERS stream does not serve is an error.
            b.include(record)
                .out_reply(JetStreamPublish::default().expect_stream("ORDERS"));
        },
    )
}

Implementations

impl JetStreamPublish

pub fn expect_stream(self, stream: impl Into<String>) -> Self

Requires the subject to be served by the named stream. The server rejects the publish otherwise, so a misrouted subject surfaces as an error rather than a silent write.

Trait Implementations

impl Clone for JetStreamPublish

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JetStreamPublish

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JetStreamPublish

fn default() -> Self

Returns the “default value” for a type.

impl Eq for JetStreamPublish

impl NatsPublishPolicy for JetStreamPublish

fn bind(self, connected: &ConnectedNatsBroker) -> Self::Live

Pairs the policy with the connected broker, producing the live publisher.

impl PartialEq for JetStreamPublish

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PublishPolicy<ConnectedNatsBroker> for JetStreamPublish

fn channel_bindings(&self, channel: &str) -> Bindings

The stream this publisher requires, and the subject it requires that stream to serve.

The nats binding has no field for either, so both travel under this crate’s extension key. channel is the destination the mount site resolved, and naming it next to the stream is what makes the requirement readable: a reader sees which subject the stream has to carry, including where a naming transform decides the address per delivery and the channel reports none. A publisher that requires no stream has no requirement to state and contributes nothing.

There is no reply address here: on a JetStream delivery the protocol’s reply field is the acknowledgement inbox, not a request’s, so a request is answered over Core NATS and NatsPublish is what reports it.

type Live = JetStreamPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

fn pair( self, connected: &ConnectedNatsBroker, ) -> impl Future<Output = Result<Self::Live, PairError>>

Pairs the policy with a connected broker, producing the live publisher.

fn operation_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its send operation in the document.

fn message_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to the messages that leave through it.

fn reply_address_location(&self) -> Option<&'static str>

Where a client finds the address of a reply this policy publishes, as a runtime expression.

impl StructuralPartialEq for JetStreamPublish