delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
use std::sync::Arc;

use async_trait::async_trait;
use futures::{stream::BoxStream, StreamExt};
use tokio::sync::broadcast;
use tokio_stream::wrappers::BroadcastStream;

use crate::{
    error::DeltaError,
    transport::{RealtimeTransport, TransportMessage},
};

#[derive(Debug, Clone)]
pub struct LocalTransport {
    tx: Arc<broadcast::Sender<TransportMessage>>,
}

impl Default for LocalTransport {
    fn default() -> Self {
        let (tx, _) = broadcast::channel(1024);
        Self { tx: Arc::new(tx) }
    }
}

#[async_trait]
impl RealtimeTransport for LocalTransport {
    async fn publish(&self, topic: &str, payload: Vec<u8>) -> Result<(), DeltaError> {
        let _ = self.tx.send(TransportMessage {
            topic: topic.to_string(),
            payload,
        });
        Ok(())
    }

    async fn subscribe(
        &self,
        topics: Vec<String>,
    ) -> Result<BoxStream<'static, Result<TransportMessage, DeltaError>>, DeltaError> {
        let rx = self.tx.subscribe();
        let stream = BroadcastStream::new(rx).filter_map(move |item| {
            let topics = topics.clone();
            async move {
                match item {
                    Ok(message) if topics.iter().any(|topic| topic == &message.topic) => {
                        Some(Ok(message))
                    }
                    Ok(_) => None,
                    Err(err) => Some(Err(DeltaError::Transport(err.to_string()))),
                }
            }
        });
        Ok(Box::pin(stream))
    }
}