feat: add subscriptions

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

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

@@ -0,0 +1,81 @@
+use std::collections::BTreeMap;
+
+use async_trait::async_trait;
+use crunch_traits::{errors::TransportError, EventInfo, Transport};
+use tokio::sync::broadcast::{Receiver, Sender};
+
+#[derive(Clone)]
+struct TransportEnvelope {
+    info: EventInfo,
+    content: Vec<u8>,
+}
+
+pub struct InMemoryTransport {
+    events: tokio::sync::RwLock<BTreeMap<String, Sender<TransportEnvelope>>>,
+}
+
+impl InMemoryTransport {
+    pub fn new() -> Self {
+        Self {
+            events: tokio::sync::RwLock::default(),
+        }
+    }
+}
+
+impl Default for InMemoryTransport {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl Transport for InMemoryTransport {
+    async fn publish(
+        &self,
+        event_info: &EventInfo,
+        content: Vec<u8>,
+    ) -> Result<(), TransportError> {
+        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)
+            .expect("transport to be available, as we just created it");
+        sender
+            .send(TransportEnvelope {
+                info: event_info.clone(),
+                content,
+            })
+            .map_err(|e| anyhow::anyhow!(e.to_string()))
+            .map_err(TransportError::Err)?;
+
+        Ok(())
+    }
+}
+
+trait EventInfoExt {
+    fn transport_name(&self) -> String;
+}
+
+impl EventInfoExt for EventInfo {
+    fn transport_name(&self) -> String {
+        format!(
+            "crunch.{}.{}.{}",
+            self.domain, self.entity_type, self.event_name
+        )
+    }
+}