Struct SessionBuilder 

pub struct SessionBuilder<P, V, Target, State = NotReady, M = SubscriptionManager>
where
    P: TokenProvider + Send + Sync + Clone + 'static,
    V: Verifier + Send + Sync + Clone + 'static,
    M: SubscriptionOps,
{ /* private fields */ }

Unified generic builder for constructing session-related types.

This builder eliminates the need for multiple constructors with many parameters by providing a fluent, type-safe API for building session components.

Type Safety

The builder uses compile-time type states to ensure:

1. All required fields are set before building (enforced by ready())
2. The correct build method is available for each target type
3. No runtime panics due to missing fields

Supported Types

• SessionController - High-level controller that wraps participant/moderator

  • Use SessionBuilder::for_controller() or SessionController::builder()
  • Automatically creates moderator or participant based on config

• SessionParticipant - Direct participant construction (advanced)

  • Use SessionBuilder::for_participant() or SessionParticipant::builder()

• SessionModerator - Direct moderator construction (advanced)

  • Use SessionBuilder::for_moderator() or SessionModerator::builder()

Examples

Building a SessionController (Recommended)

use agntcy_slim_session::{SessionBuilder, SessionController};

let controller = SessionController::builder()
    .with_id(1)
    .with_source(source_name)
    .with_destination(dest_name)
    .with_config(session_config)
    .with_identity_provider(provider)
    .with_identity_verifier(verifier)
    .with_storage_path(storage_path)
    .with_tx(transmitter)
    .with_tx_to_session_layer(tx_channel)
    .ready()?  // Validates all fields are set
    .build()   // Constructs the SessionController
    .await?;

Building a SessionParticipant (Advanced)

let participant = SessionBuilder::for_participant()
    .with_id(1)
    .with_source(name)
    .with_destination(dest)
    .with_config(config)
    .with_identity_provider(provider)
    .with_identity_verifier(verifier)
    .with_storage_path(path)
    .with_tx(tx)
    .with_tx_to_session_layer(tx_channel)
    .ready()?
    .build()
    .await;

Building a SessionModerator (Advanced)

let moderator = SessionModerator::builder()
    .with_id(session_id)
    .with_source(moderator_name)
    .with_destination(group_name)
    .with_config(moderator_config)
    .with_identity_provider(provider)
    .with_identity_verifier(verifier)
    .with_storage_path(storage_path)
    .with_tx(tx)
    .with_tx_to_session_layer(tx_channel)
    .ready()?
    .build()
    .await;

Implementations

impl<P, V, Target, M> SessionBuilder<P, V, Target, NotReady, M>

where P: TokenProvider + Send + Sync + Clone + 'static, V: Verifier + Send + Sync + Clone + 'static, M: SubscriptionOps,

pub fn with_id(self, id: u32) -> Self

pub fn with_source(self, source: ProtoName) -> Self

pub fn with_destination(self, destination: ProtoName) -> Self

pub fn with_config(self, config: SessionConfig) -> Self

pub fn with_identity_provider(self, identity_provider: P) -> Self

pub fn with_identity_verifier(self, identity_verifier: V) -> Self

pub fn with_slim_tx(self, slim_tx: SlimChannelSender) -> Self

pub fn with_app_tx( self, app_tx: UnboundedSender<Result<ProtoMessage, SessionError>>, ) -> Self

pub fn with_tx_to_session_layer( self, tx_to_session_layer: Sender<Result<SessionMessage, SessionError>>, ) -> Self

pub fn with_graceful_shutdown_timeout(self, timeout: Duration) -> Self

pub fn with_direction(self, direction: Direction) -> Self

pub fn with_subscription_manager<N: SubscriptionOps>( self, manager: N, ) -> SessionBuilder<P, V, Target, NotReady, N>

Set a custom subscription manager. This method changes the manager type M, so it returns a new builder type SessionBuilder<P, V, Target, NotReady, N>. Call this before ready().

pub fn with_service_id(self, service_id: String) -> Self

pub fn ready( self, ) -> Result<SessionBuilder<P, V, Target, Ready, M>, SessionError>

impl<P, V, M> SessionBuilder<P, V, ForController, NotReady, M>

where P: TokenProvider + Send + Sync + Clone + 'static, V: Verifier + Send + Sync + Clone + 'static, M: SubscriptionOps,

pub fn for_controller() -> Self

Create a new builder for constructing a SessionController

impl<P, V, M> SessionBuilder<P, V, ForParticipant, NotReady, M>

where P: TokenProvider + Send + Sync + Clone + 'static, V: Verifier + Send + Sync + Clone + 'static, M: SubscriptionOps,

pub fn for_participant() -> Self

Create a new builder for constructing a SessionParticipant

impl<P, V, M> SessionBuilder<P, V, ForModerator, NotReady, M>

where P: TokenProvider + Send + Sync + Clone + 'static, V: Verifier + Send + Sync + Clone + 'static, M: SubscriptionOps,

pub fn for_moderator() -> Self

Create a new builder for constructing a SessionModerator

impl<P, V, M> SessionBuilder<P, V, ForController, Ready, M>

where P: TokenProvider + Send + Sync + Clone + 'static, V: Verifier + Send + Sync + Clone + 'static, M: SubscriptionOps,

pub fn build(self) -> Result<SessionController, SessionError>

Build a SessionController

Automatically determines whether to create a moderator or participant internally based on the session configuration’s initiator flag.