Struct JetStreamContext

Source

pub struct JetStreamContext<C: CodecType> { /* private fields */ }

Expand description

A typed JetStream context with configurable codec.

Provides methods for creating streams, publishing messages, and managing JetStream resources.

§Type Parameters

C - The codec type used for message serialization

Implementations§

Source §

impl<C: CodecType> JetStreamContext<C>

Source

pub fn inner(&self) -> &Context

Get the underlying async-nats JetStream context.

Source

pub fn stream_builder(&self, name: &str) -> StreamBuilder<C>

Create a stream builder for configuring and creating a stream.

§Example

use intercom::{Client, MsgPackCodec};

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

let stream = jetstream
    .stream_builder("my-stream")
    .subjects(vec!["events.>".to_string()])
    .max_messages(1_000_000)
    .create()
    .await?;

Source

pub async fn get_stream(&self, name: &str) -> Result<Stream<C>>

Get an existing stream by name.

§Example

use intercom::{Client, MsgPackCodec};

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

let stream = jetstream.get_stream("my-stream").await?;

Source

pub async fn delete_stream(&self, name: &str) -> Result<()>

Delete a stream by name.

§Example

use intercom::{Client, MsgPackCodec};

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

jetstream.delete_stream("my-stream").await?;

Source

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

Publish a typed message to a JetStream subject.

§Type Parameters

T - The message type (must implement Serialize)

§Example

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

#[derive(Serialize, Deserialize)]
struct Event { id: u64, data: String }

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

let ack = jetstream.publish::<Event>("events.user", &Event {
    id: 1,
    data: "created".to_string(),
}).await?;

println!("Published to stream: {}, seq: {}", ack.stream, ack.sequence);

Source

pub async fn publish_async<T: Serialize>( &self, subject: &str, message: &T, ) -> Result<PublishAckFuture>

Publish a typed message and get the ack future immediately.

This allows for more efficient batching by not waiting for the ack.

§Type Parameters

T - The message type (must implement Serialize)

§Example

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

#[derive(Serialize, Deserialize)]
struct Event { id: u64 }

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

// Publish without waiting for ack
let ack_future = jetstream.publish_async::<Event>("events.user", &Event { id: 1 }).await?;

// Do other work...

// Now wait for the ack
let ack = ack_future.await?;