chore: updated folder structure

src/domain/events/mod.rs

@@ -0,0 +1,18 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use super::{ports::Port, projects::Project, users::User};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+#[allow(clippy::enum_variant_names)]
+pub enum Event {
+    ProjectCreated(Project),
+    UserCreated(User),
+    PortCreated(Port),
+}
+
+#[async_trait::async_trait]
+pub trait EventBridge: Send + Sync {
+    async fn dispatch(&self, event: Event) -> Result<()>;
+}

src/domain/mod.rs

@@ -1,3 +1,4 @@
-pub mod daemon;
-pub mod management;
 pub mod events;
+pub mod ports;
+pub mod projects;
+pub mod users;

src/domain/management/port.rs → src/domain/ports/create.rs

@@ -1,11 +1,17 @@
 use anyhow::{bail, Result};
+use kube::{
+    api::{ApiResource, DynamicObject, ObjectMeta},
+    ResourceExt,
+};
 use std::sync::Arc;
 use tracing::info;
-use uuid::Uuid;
 
-use crate::domain::events::{Event, EventBridge, PortCreated};
+use crate::domain::{
+    events::{Event, EventBridge},
+    projects::ProjectCache,
+};
 
-use super::project::ProjectCache;
+use super::{Port, PortCache, PortCluster};
 
 pub async fn create(
     project_cache: Arc<dyn ProjectCache>,
@@ -16,71 +22,52 @@ pub async fn create(
         bail!("Invalid project")
     }
 
-    let port_event = Event::PortCreated(port.clone().into());
+    let port_event = Event::PortCreated(port.clone());
 
     event.dispatch(port_event).await?;
     info!(project = port.project, "new port requested");
 
     Ok(())
 }
 
-pub async fn create_cache(port_cache: Arc<dyn PortCache>, port: PortCreated) -> Result<()> {
-    port_cache.create(&port.into()).await?;
+pub async fn create_cache(port_cache: Arc<dyn PortCache>, port: Port) -> Result<()> {
+    port_cache.create(&port).await?;
 
     Ok(())
 }
 
-#[derive(Debug, Clone)]
-pub struct Port {
-    pub id: String,
-    pub project: String,
-    pub kind: String,
-    pub data: String,
-}
-impl Port {
-    pub fn new(project: &str, kind: &str, data: &str) -> Self {
-        let id = Uuid::new_v4().to_string();
-
-        Self {
-            id,
-            project: project.into(),
-            kind: kind.into(),
-            data: data.into(),
-        }
-    }
-}
-impl From<Port> for PortCreated {
-    fn from(value: Port) -> Self {
-        PortCreated {
-            id: value.id,
-            project: value.project,
-            kind: value.kind,
-            data: value.data,
-        }
-    }
-}
-impl From<PortCreated> for Port {
-    fn from(value: PortCreated) -> Self {
-        Port {
-            id: value.id,
-            project: value.project,
-            kind: value.kind,
-            data: value.data,
-        }
-    }
-}
+pub async fn create_resource(cluster: Arc<dyn PortCluster>, port: Port) -> Result<()> {
+    let api = ApiResource {
+        kind: port.kind.clone(),
+        group: "demeter.run".into(),
+        version: "v1alpha1".into(),
+        plural: format!("{}s", port.kind.clone().to_lowercase()),
+        api_version: "demeter.run/v1alpha1".into(),
+    };
+
+    let mut obj = DynamicObject::new(&port.id, &api);
+    obj.metadata = ObjectMeta {
+        name: Some(port.id),
+        namespace: Some(port.project),
+        ..Default::default()
+    };
+    obj.data = serde_json::from_str(&port.data)?;
+
+    cluster.create(&obj).await?;
 
-#[async_trait::async_trait]
-pub trait PortCache: Send + Sync {
-    async fn create(&self, port: &Port) -> Result<()>;
+    //TODO: create event to update cache
+    info!(port = obj.name_any(), "new port created");
+
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
     use mockall::mock;
+    use uuid::Uuid;
 
     use super::*;
-    use crate::domain::management::project::Project;
+    use crate::domain::projects::Project;
 
     mock! {
         pub FakeProjectCache { }
@@ -110,6 +97,15 @@ mod tests {
         }
     }
 
+    mock! {
+        pub FakePortCluster { }
+
+        #[async_trait::async_trait]
+        impl PortCluster for FakePortCluster {
+            async fn create(&self, obj: &DynamicObject) -> Result<()>;
+        }
+    }
+
     impl Default for Port {
         fn default() -> Self {
             Self {
@@ -163,7 +159,20 @@ mod tests {
 
         let port = Port::default();
 
-        let result = create_cache(Arc::new(port_cache), port.into()).await;
+        let result = create_cache(Arc::new(port_cache), port).await;
+        if let Err(err) = result {
+            unreachable!("{err}")
+        }
+    }
+
+    #[tokio::test]
+    async fn it_should_create_resource() {
+        let mut port_cluster = MockFakePortCluster::new();
+        port_cluster.expect_create().return_once(|_| Ok(()));
+
+        let port = Port::default();
+
+        let result = create_resource(Arc::new(port_cluster), port).await;
         if let Err(err) = result {
             unreachable!("{err}")
         }