feat: database tenant update functions

jacobtread · jacobtread · commit 672dd8a8d64f · 2026-02-05T12:32:33.000+13:00
diff --git a/packages/docbox-database/src/models/tenant.rs b/packages/docbox-database/src/models/tenant.rs
@@ -1,10 +1,12 @@
 use crate::{DbExecutor, DbResult};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sqlx::prelude::FromRow;
 use uuid::Uuid;
 
 pub type TenantId = Uuid;
 
+use crate::utils::update_if_some;
+
 #[derive(Debug, Clone, FromRow, Serialize, PartialEq, Eq)]
 pub struct Tenant {
     /// Unique ID for the tenant
@@ -30,6 +32,8 @@ pub struct Tenant {
     pub event_queue_url: Option<String>,
 }
 
+/// Structure for fields required when creating a
+/// tenant within the database
 pub struct CreateTenant {
     pub id: TenantId,
     pub name: String,
@@ -42,6 +46,21 @@ pub struct CreateTenant {
     pub env: String,
 }
 
+/// Bulk update for tenant fields
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct UpdateTenant {
+    pub id: Option<TenantId>,
+    pub name: Option<String>,
+    pub db_name: Option<String>,
+    pub db_secret_name: Option<Option<String>>,
+    pub db_iam_user_name: Option<Option<String>>,
+    pub s3_name: Option<String>,
+    pub os_index_name: Option<String>,
+    pub env: Option<String>,
+    pub event_queue_url: Option<Option<String>>,
+}
+
 impl Tenant {
     /// Create a new tenant
     pub async fn create(db: impl DbExecutor<'_>, create: CreateTenant) -> DbResult<Tenant> {
@@ -87,35 +106,67 @@ impl Tenant {
     }
 
     /// Update the "db_iam_user_name" property of the tenant
-    pub async fn set_db_iam_user_name(
+    pub async fn update(
         &mut self,
         db: impl DbExecutor<'_>,
-        iam_user_name: Option<String>,
-    ) -> DbResult<Option<Tenant>> {
-        sqlx::query_as(
-            r#"UPDATE "docbox_tenants" SET "db_iam_user_name" = $3 WHERE "id" = $1 AND "env" = $2"#,
+        UpdateTenant {
+            id,
+            name,
+            db_name,
+            db_secret_name,
+            db_iam_user_name,
+            s3_name,
+            os_index_name,
+            env,
+            event_queue_url,
+        }: UpdateTenant,
+    ) -> DbResult<()> {
+        sqlx::query(
+            r#"
+            UPDATE "docbox_tenants"
+            SET
+                "id" = COALESCE($3, "id"),
+                "name" = COALESCE($4, "name"),
+                "db_name" = COALESCE($5, "db_name"),
+                "db_secret_name" = COALESCE($6, "db_secret_name"),
+                "db_iam_user_name" = COALESCE($7, "db_iam_user_name"),
+                "s3_name" = COALESCE($8, "s3_name"),
+                "os_index_name" = COALESCE($9, "os_index_name"),
+                "env" = COALESCE($10, "env"),
+                "event_queue_url" = COALESCE($11, "event_queue_url")
+            WHERE "id" = $1 AND "env" = $2
+            "#,
         )
+        //
         .bind(self.id)
         .bind(self.env.clone())
-        .bind(iam_user_name)
+        //
+        .bind(id)
+        .bind(name.clone())
+        .bind(db_name.clone())
+        .bind(db_secret_name.clone())
+        .bind(db_iam_user_name.clone())
+        .bind(s3_name.clone())
+        .bind(os_index_name.clone())
+        .bind(env.clone())
+        .bind(event_queue_url.clone())
         .fetch_optional(db)
-        .await
-    }
+        .await?;
 
-    /// Update the "db_secret_name" property of the tenant
-    pub async fn set_db_secret_name(
-        &mut self,
-        db: impl DbExecutor<'_>,
-        db_secret_name: Option<String>,
-    ) -> DbResult<Option<Tenant>> {
-        sqlx::query_as(
-            r#"UPDATE "docbox_tenants" SET "db_secret_name" = $3 WHERE "id" = $1 AND "env" = $2"#,
-        )
-        .bind(self.id)
-        .bind(self.env.clone())
-        .bind(db_secret_name)
-        .fetch_optional(db)
-        .await
+        update_if_some!(
+            self,
+            id,
+            name,
+            db_name,
+            db_secret_name,
+            db_iam_user_name,
+            s3_name,
+            os_index_name,
+            env,
+            event_queue_url,
+        );
+
+        Ok(())
     }
 
     /// Find a tenant by `id` within a specific `env`
diff --git a/packages/docbox-database/src/utils.rs b/packages/docbox-database/src/utils.rs
@@ -76,3 +76,15 @@ impl DatabaseErrorExt for DbErr {
             .is_some_and(|error| error.is_restrict())
     }
 }
+
+macro_rules! update_if_some {
+    ($self:expr, $($field:ident),+ $(,)?) => {
+        $(
+            if let Some(value) = $field {
+                $self.$field = value;
+            }
+        )+
+    };
+}
+
+pub(crate) use update_if_some;
diff --git a/packages/docbox-database/tests/tenant.rs b/packages/docbox-database/tests/tenant.rs
@@ -1,5 +1,5 @@
 use docbox_database::{
-    models::tenant::{CreateTenant, Tenant},
+    models::tenant::{CreateTenant, Tenant, UpdateTenant},
     utils::DatabaseErrorExt,
 };
 use uuid::Uuid;
@@ -418,3 +418,122 @@ async fn test_delete_tenant() {
         .unwrap();
     assert!(result.is_some());
 }
+
+/// Tests that a tenant can be created
+#[tokio::test]
+async fn test_update_tenant() {
+    let (db, _db_container) = test_root_db().await;
+
+    // Create a secondary tenant to ensure updates aren't applied to it
+    let secondary_tenant_id = Uuid::new_v4();
+    let secondary_tenant = Tenant::create(
+        &db,
+        CreateTenant {
+            id: secondary_tenant_id,
+            name: "dont-match-test".to_string(),
+            db_name: "dont-match-test".to_string(),
+            db_secret_name: Some("dont-match-test".to_string()),
+            db_iam_user_name: None,
+            s3_name: "dont-match-test".to_string(),
+            os_index_name: "dont-match-test".to_string(),
+            event_queue_url: None,
+            env: "Development".to_string(),
+        },
+    )
+    .await
+    .unwrap();
+
+    let tenant_id = Uuid::new_v4();
+
+    let mut tenant = Tenant::create(
+        &db,
+        CreateTenant {
+            id: tenant_id,
+            name: "test".to_string(),
+            db_name: "test".to_string(),
+            db_secret_name: Some("test".to_string()),
+            db_iam_user_name: None,
+            s3_name: "test".to_string(),
+            os_index_name: "test".to_string(),
+            event_queue_url: None,
+            env: "Development".to_string(),
+        },
+    )
+    .await
+    .unwrap();
+
+    let original_tenant = tenant.clone();
+    let new_tenant_id = Uuid::new_v4();
+
+    // Update the tenant ID
+    tenant
+        .update(
+            &db,
+            UpdateTenant {
+                id: Some(new_tenant_id),
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(tenant.id, new_tenant_id);
+    assert_ne!(tenant, original_tenant);
+
+    // Should be able to query the updated tenant and get back the same one we have after the update
+    let found_tenant = Tenant::find_by_id(&db, tenant.id, &tenant.env)
+        .await
+        .unwrap()
+        .expect("expected to find tenant");
+    assert_eq!(found_tenant, tenant);
+
+    // Update other tenant fields
+    tenant
+        .update(
+            &db,
+            UpdateTenant {
+                id: Some(new_tenant_id),
+                name: Some("test-name-2".to_string()),
+                db_name: Some("test-db-name-2".to_string()),
+                db_secret_name: Some(Some("test-secret-name".to_string())),
+                db_iam_user_name: Some(Some("test-iam-user-name-2".to_string())),
+                s3_name: Some("test-s3-name-2".to_string()),
+                os_index_name: Some("test-search-2".to_string()),
+                event_queue_url: Some(Some("test-event-queue-2".to_string())),
+                env: Some("Production".to_string()),
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(tenant.id, new_tenant_id);
+    assert_eq!(tenant.name, "test-name-2");
+    assert_eq!(tenant.db_name, "test-db-name-2");
+    assert_eq!(tenant.db_secret_name, Some("test-secret-name".to_string()));
+    assert_eq!(
+        tenant.db_iam_user_name,
+        Some("test-iam-user-name-2".to_string())
+    );
+    assert_eq!(tenant.s3_name, "test-s3-name-2");
+    assert_eq!(tenant.os_index_name, "test-search-2");
+    assert_eq!(
+        tenant.event_queue_url,
+        Some("test-event-queue-2".to_string())
+    );
+    assert_eq!(tenant.env, "Production");
+
+    // Should be able to query the updated tenant and get back the same one we have after the update
+    let found_tenant = Tenant::find_by_id(&db, tenant.id, &tenant.env)
+        .await
+        .unwrap()
+        .expect("expected to find tenant");
+    assert_eq!(found_tenant, tenant);
+
+    // Secondary tenant should not have been changed
+    let found_secondary_tenant =
+        Tenant::find_by_id(&db, secondary_tenant.id, &secondary_tenant.env)
+            .await
+            .unwrap()
+            .expect("expected to find tenant");
+    assert_eq!(found_secondary_tenant, secondary_tenant);
+}
diff --git a/packages/docbox-management/src/tenant/migrate_tenant_secret_to_iam.rs b/packages/docbox-management/src/tenant/migrate_tenant_secret_to_iam.rs
@@ -1,7 +1,9 @@
 use crate::database::{DatabaseProvider, close_pool_on_drop};
 use docbox_core::{
     database::{
-        DbErr, DbSecrets, ROOT_DATABASE_NAME, create::make_role_iam_only, models::tenant::Tenant,
+        DbErr, DbSecrets, ROOT_DATABASE_NAME,
+        create::make_role_iam_only,
+        models::tenant::{Tenant, UpdateTenant},
     },
     secrets::{SecretManager, SecretManagerError},
 };
@@ -54,12 +56,14 @@ pub async fn migrate_tenant_secret_to_iam(
         .map_err(MigrateIAMError::MakeRoleIAM)?;
 
     tenant
-        .set_db_iam_user_name(&root_db, Some(secret.username.clone()))
-        .await
-        .map_err(MigrateIAMError::UpdateTenant)?;
-
-    tenant
-        .set_db_secret_name(&root_db, None)
+        .update(
+            &root_db,
+            UpdateTenant {
+                db_iam_user_name: Some(Some(secret.username.clone())),
+                db_secret_name: Some(None),
+                ..Default::default()
+            },
+        )
         .await
         .map_err(MigrateIAMError::UpdateTenant)?;
 
