Struct Publisher 

pub struct Publisher<T, C: CodecType> { /* private fields */ }

A typed publisher that implements Sink.

Type Parameters

• T - The message type that will be serialized for publishing.
• C - The codec type used for serialization.

Note on Error Handling

The Sink implementation uses fire-and-forget semantics for efficiency. Publish errors are not propagated back through the Sink interface. For applications requiring guaranteed delivery or error handling:

• Use Publisher::publish for direct publish with error handling
• Use Client::publish for basic NATS
• Use JetStreamContext::publish for JetStream

Example

use intercom::{Client, MsgPackCodec};
use serde::{Deserialize, Serialize};
use futures::SinkExt;

#[derive(Serialize, Deserialize)]
struct MyMessage {
    content: String,
}

let client = Client::<MsgPackCodec>::connect("nats://localhost:4222").await?;
let mut publisher = client.publisher::<MyMessage>("subject");

// Use Sink trait methods
publisher.send(MyMessage { content: "hello".into() }).await?;

// Or use feed + flush for batching
publisher.feed(MyMessage { content: "msg1".into() }).await?;
publisher.feed(MyMessage { content: "msg2".into() }).await?;
publisher.flush().await?;

Implementations

impl<T, C: CodecType> Publisher<T, C>

pub fn subject(&self) -> &str

Get the subject this publisher publishes to.

pub fn client(&self) -> &Client

Get the underlying async-nats client.

impl<T: Serialize, C: CodecType> Publisher<T, C>

pub async fn publish(&self, message: &T) -> Result<()>

Publish a message directly with error handling.

Unlike the Sink implementation, this method returns any publish errors.

Example

use intercom::{Client, MsgPackCodec};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct MyMessage { content: String }

let client = Client::<MsgPackCodec>::connect("nats://localhost:4222").await?;
let publisher = client.publisher::<MyMessage>("subject");

// Direct publish with error handling
publisher.publish(&MyMessage { content: "hello".into() }).await?;

Trait Implementations

impl<T, C: CodecType> Clone for Publisher<T, C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Serialize + Unpin, C: CodecType + Unpin> Sink<T> for Publisher<T, C>

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.