warren creation / edit / deletion

backend/src/lib/outbound/metrics_debug_logger.rs

@@ -10,6 +10,27 @@ impl MetricsDebugLogger {
 }
 
 impl WarrenMetrics for MetricsDebugLogger {
+    async fn record_warren_creation_success(&self) {
+        tracing::debug!("[Metrics] Warren creation succeeded");
+    }
+    async fn record_warren_creation_failure(&self) {
+        tracing::debug!("[Metrics] Warren creation failed");
+    }
+
+    async fn record_warren_edit_success(&self) {
+        tracing::debug!("[Metrics] Warren edit succeeded");
+    }
+    async fn record_warren_edit_failure(&self) {
+        tracing::debug!("[Metrics] Warren edit failed");
+    }
+
+    async fn record_warren_deletion_success(&self) {
+        tracing::debug!("[Metrics] Warren deletion succeeded");
+    }
+    async fn record_warren_deletion_failure(&self) {
+        tracing::debug!("[Metrics] Warren deletion failed");
+    }
+
     async fn record_warren_list_success(&self) {
         tracing::debug!("[Metrics] Warren list succeeded");
     }
@@ -129,6 +150,27 @@ impl FileSystemMetrics for MetricsDebugLogger {
 }
 
 impl AuthMetrics for MetricsDebugLogger {
+    async fn record_auth_warren_creation_success(&self) {
+        tracing::debug!("[Metrics] Warren creation by admin succeeded");
+    }
+    async fn record_auth_warren_creation_failure(&self) {
+        tracing::debug!("[Metrics] Warren creation by admin failed");
+    }
+
+    async fn record_auth_warren_edit_success(&self) -> () {
+        tracing::debug!("[Metrics] Warren edit by admin succeeded");
+    }
+    async fn record_auth_warren_edit_failure(&self) -> () {
+        tracing::debug!("[Metrics] Warren edit by admin failed");
+    }
+
+    async fn record_auth_warren_deletion_success(&self) -> () {
+        tracing::debug!("[Metrics] Warren deletion by admin succeeded");
+    }
+    async fn record_auth_warren_deletion_failure(&self) -> () {
+        tracing::debug!("[Metrics] Warren deletion by admin failed");
+    }
+
     async fn record_user_registration_success(&self) {
         tracing::debug!("[Metrics] User registration succeeded");
     }

backend/src/lib/outbound/notifier_debug_logger.rs

@@ -24,6 +24,16 @@ impl NotifierDebugLogger {
 }
 
 impl WarrenNotifier for NotifierDebugLogger {
+    async fn warren_created(&self, warren: &Warren) {
+        tracing::debug!("[Notifier] Created warren: {}", warren.name());
+    }
+    async fn warren_edited(&self, warren: &Warren) {
+        tracing::debug!("[Notifier] Edited warren: {}", warren.name());
+    }
+    async fn warren_deleted(&self, warren: &Warren) {
+        tracing::debug!("[Notifier] Deleted warren: {}", warren.name());
+    }
+
     async fn warrens_fetched(&self, warrens: &Vec<Warren>) {
         tracing::debug!("[Notifier] Fetched {} warren(s)", warrens.len());
     }
@@ -121,6 +131,28 @@ impl FileSystemNotifier for NotifierDebugLogger {
 }
 
 impl AuthNotifier for NotifierDebugLogger {
+    async fn auth_warren_created(&self, creator: &User, warren: &Warren) {
+        tracing::debug!(
+            "[Notifier] Admin {} created warren: {}",
+            creator.id(),
+            warren.name()
+        );
+    }
+    async fn auth_warren_edited(&self, editor: &User, warren: &Warren) {
+        tracing::debug!(
+            "[Notifier] Admin {} edited warren: {}",
+            editor.id(),
+            warren.name()
+        );
+    }
+    async fn auth_warren_deleted(&self, deleter: &User, warren: &Warren) {
+        tracing::debug!(
+            "[Notifier] Admin {} deleted warren: {}",
+            deleter.id(),
+            warren.name()
+        );
+    }
+
     async fn user_registered(&self, user: &User) {
         tracing::debug!("[Notifier] Registered user {}", user.name());
     }

backend/src/lib/outbound/postgres/warrens.rs

@@ -1,11 +1,16 @@
 use anyhow::{Context as _, anyhow};
-use sqlx::PgConnection;
+use sqlx::{Acquire as _, PgConnection};
 use uuid::Uuid;
 
 use crate::domain::warren::{
-    models::warren::{
-        FetchWarrenError, FetchWarrenRequest, FetchWarrensError, FetchWarrensRequest,
-        ListWarrensError, ListWarrensRequest, Warren,
+    models::{
+        file::AbsoluteFilePath,
+        warren::{
+            CreateWarrenError, CreateWarrenRequest, DeleteWarrenError, DeleteWarrenRequest,
+            EditWarrenError, EditWarrenRequest, FetchWarrenError, FetchWarrenRequest,
+            FetchWarrensError, FetchWarrensRequest, ListWarrensError, ListWarrensRequest, Warren,
+            WarrenName,
+        },
     },
     ports::WarrenRepository,
 };
@@ -13,6 +18,62 @@ use crate::domain::warren::{
 use super::{Postgres, is_not_found_error};
 
 impl WarrenRepository for Postgres {
+    async fn create_warren(
+        &self,
+        request: CreateWarrenRequest,
+    ) -> Result<Warren, CreateWarrenError> {
+        let mut connection = self
+            .pool
+            .acquire()
+            .await
+            .context("Failed to get a PostgreSQL connection")?;
+
+        let warren = self
+            .create_warren(&mut connection, request.name(), request.path())
+            .await
+            .context("Failed to create new warren")?;
+
+        Ok(warren)
+    }
+
+    async fn edit_warren(&self, request: EditWarrenRequest) -> Result<Warren, EditWarrenError> {
+        let mut connection = self
+            .pool
+            .acquire()
+            .await
+            .context("Failed to get a PostgreSQL connection")?;
+
+        let warren = self
+            .edit_warren(
+                &mut connection,
+                request.id(),
+                request.name(),
+                request.path(),
+            )
+            .await
+            .context("Failed to edit existing warren")?;
+
+        Ok(warren)
+    }
+
+    async fn delete_warren(
+        &self,
+        request: DeleteWarrenRequest,
+    ) -> Result<Warren, DeleteWarrenError> {
+        let mut connection = self
+            .pool
+            .acquire()
+            .await
+            .context("Failed to get a PostgreSQL connection")?;
+
+        let warren = self
+            .delete_warren(&mut connection, request.id())
+            .await
+            .context("Failed to delete existing warren")?;
+
+        Ok(warren)
+    }
+
     async fn fetch_warrens(
         &self,
         request: FetchWarrensRequest,
@@ -74,6 +135,96 @@ impl WarrenRepository for Postgres {
 }
 
 impl Postgres {
+    async fn create_warren(
+        &self,
+        connection: &mut PgConnection,
+        name: &WarrenName,
+        path: &AbsoluteFilePath,
+    ) -> Result<Warren, sqlx::Error> {
+        let mut tx = connection.begin().await?;
+
+        let warren: Warren = sqlx::query_as(
+            "
+            INSERT INTO warrens (
+                name,
+                path
+            ) VALUES (
+                $1,
+                $2
+            )
+            RETURNING
+                *
+            ",
+        )
+        .bind(name)
+        .bind(path)
+        .fetch_one(&mut *tx)
+        .await?;
+
+        tx.commit().await?;
+
+        Ok(warren)
+    }
+
+    async fn edit_warren(
+        &self,
+        connection: &mut PgConnection,
+        id: &Uuid,
+        name: &WarrenName,
+        path: &AbsoluteFilePath,
+    ) -> Result<Warren, sqlx::Error> {
+        let mut tx = connection.begin().await?;
+
+        let warren: Warren = sqlx::query_as(
+            "
+            UPDATE
+                warrens
+            SET
+                name = $2,
+                path = $3
+            WHERE
+                id = $1
+            RETURNING
+                *
+            ",
+        )
+        .bind(id)
+        .bind(name)
+        .bind(path)
+        .fetch_one(&mut *tx)
+        .await?;
+
+        tx.commit().await?;
+
+        Ok(warren)
+    }
+
+    async fn delete_warren(
+        &self,
+        connection: &mut PgConnection,
+        id: &Uuid,
+    ) -> Result<Warren, sqlx::Error> {
+        let mut tx = connection.begin().await?;
+
+        let warren: Warren = sqlx::query_as(
+            "
+            DELETE FROM
+                warrens
+            WHERE
+                id = $1
+            RETURNING
+                *
+            ",
+        )
+        .bind(id)
+        .fetch_one(&mut *tx)
+        .await?;
+
+        tx.commit().await?;
+
+        Ok(warren)
+    }
+
     async fn get_warren(
         &self,
         connection: &mut PgConnection,