feat: with subscription

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/crunch-in-memory/src/lib.rs

@@ -1,8 +1,10 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, pin::Pin};
 
 use async_trait::async_trait;
 use crunch_traits::{errors::TransportError, EventInfo, Transport};
+use futures::Stream;
 use tokio::sync::broadcast::{Receiver, Sender};
+use tokio_stream::{wrappers::BroadcastStream, StreamExt};
 
 #[derive(Clone)]
 struct TransportEnvelope {
@@ -20,6 +22,22 @@ impl InMemoryTransport {
             events: tokio::sync::RwLock::default(),
         }
     }
+
+    async fn register_channel(&self, event_info: &EventInfo) {
+        let transport_key = event_info.transport_name();
+
+        // Possibly create a trait register handle instead, as this requires a write and then read. It may not matter for in memory though
+        let mut events = self.events.write().await;
+        if let None = events.get(&transport_key) {
+            let (sender, mut receiver) = tokio::sync::broadcast::channel(100);
+            events.insert(transport_key.clone(), sender);
+            tokio::spawn(async move {
+                while let Ok(item) = receiver.recv().await {
+                    tracing::info!("default receiver: {}", item.info.transport_name());
+                }
+            });
+        }
+    }
 }
 
 impl Default for InMemoryTransport {
@@ -30,27 +48,16 @@ impl Default for InMemoryTransport {
 
 #[async_trait]
 impl Transport for InMemoryTransport {
+    type Stream = Pin<Box<dyn Stream<Item = Vec<u8>> + Send>>;
+
     async fn publish(
         &self,
         event_info: &EventInfo,
         content: Vec<u8>,
     ) -> Result<(), TransportError> {
+        self.register_channel(event_info).await;
+
         let transport_key = event_info.transport_name();
-
-        // Possibly create a register handle instead, as this requires a write and then read. It may not matter for in memory though
-        {
-            let mut events = self.events.write().await;
-            if let None = events.get(&transport_key) {
-                let (sender, mut receiver) = tokio::sync::broadcast::channel(100);
-                events.insert(transport_key.clone(), sender);
-                tokio::spawn(async move {
-                    while let Ok(item) = receiver.recv().await {
-                        tracing::info!("default receiver: {}", item.info.transport_name());
-                    }
-                });
-            }
-        }
-
         let events = self.events.read().await;
         let sender = events
             .get(&transport_key)
@@ -65,6 +72,24 @@ impl Transport for InMemoryTransport {
 
         Ok(())
     }
+
+    async fn subscriber(
+        &self,
+        event_info: &EventInfo,
+    ) -> Result<Option<Self::Stream>, TransportError> {
+        self.register_channel(event_info).await;
+
+        let events = self.events.read().await;
+        match events.get(&event_info.transport_name()) {
+            Some(rx) => Ok(Some(Box::pin(
+                BroadcastStream::new(rx.subscribe()).filter_map(|m| match m {
+                    Ok(m) => Some(m.content),
+                    Err(_) => None,
+                }),
+            ))),
+            None => Ok(None),
+        }
+    }
 }
 
 trait EventInfoExt {