Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix(auth): clean up teams and use the fleet-wide internal key when deleting an account (#7401)

Will Hutchinson9590ce9577a8
diff --git a/crates/teams/README.md b/crates/teams/README.md
index 9b5815d7bb..060780db52 100644
--- a/crates/teams/README.md
+++ b/crates/teams/README.md
@@ -36,6 +36,12 @@ the members present before deletion; it does not produce an individual removal
event for every member. For self-service removal, `removed_by` equals
`member_id`.
+Account deletion detaches the user from their team through
+`TeamService::remove_user_from_all_teams` before the profile is removed. A team
+the user owns produces `team.deleted` with the deleted owner as
+`actor_user_id`; a team the user belongs to produces `team.member_removed` with
+`removed_by` equal to `member_id`.
+
The automatic domain toggle performed during creation is represented only by
`auto_join_domain` on the created event. The explicit settings operation
produces the toggle event. A role-only PATCH produces role-change events but no
diff --git a/crates/teams/src/domain/model.rs b/crates/teams/src/domain/model.rs
index e5520e5819..54f7c0148a 100644
--- a/crates/teams/src/domain/model.rs
+++ b/crates/teams/src/domain/model.rs
@@ -787,6 +787,20 @@ pub enum DeleteTeamError {
RemoveRolesFromUserError(#[from] UserRolesAndPermissionsError),
}
+/// Errors for detaching a user from every team ahead of account deletion
+#[derive(Debug, thiserror::Error)]
+pub enum RemoveUserFromAllTeamsError {
+ /// Underlying team error
+ #[error("Underlying team error")]
+ TeamError(#[from] TeamError),
+ /// A team the user owns could not be deleted
+ #[error("Unable to delete a team the user owns")]
+ DeleteTeam(#[from] DeleteTeamError),
+ /// The user could not be removed from a team they belong to
+ #[error("Unable to remove the user from a team")]
+ RemoveUserFromTeam(#[from] RemoveUserFromTeamError),
+}
+
/// Errors for joining a team
#[derive(Debug, thiserror::Error)]
pub enum JoinTeamError {
diff --git a/crates/teams/src/domain/team_repo.rs b/crates/teams/src/domain/team_repo.rs
index 8ab99b290a..7a54cc2396 100644
--- a/crates/teams/src/domain/team_repo.rs
+++ b/crates/teams/src/domain/team_repo.rs
@@ -9,11 +9,11 @@ use macro_user_id::{email::Email, lowercased::Lowercase, user_id::MacroUserIdStr
use crate::domain::model::{
AcceptedTeamInvite, CreateTeamError, DeleteTeamError, InviteUsersToTeamError, JoinTeamError,
- PatchTeamCrmSettingsResponse, PatchTeamRequest, RemoveTeamInviteError, RemoveUserFromTeamError,
- RestorePermissionsForTeamMembersError, RevokePermissionsForTeamMembersError, SeatPlan,
- SetTeamMemberPlanError, Team, TeamError, TeamInvite, TeamInviteDetails, TeamMember,
- TeamMembers, TeamPlan, TeamRole, TeamWithMembers, ToggleAutoJoinDomainError,
- TryJoinTeamByDomainError,
+ PatchTeamCrmSettingsResponse, PatchTeamRequest, RemoveTeamInviteError,
+ RemoveUserFromAllTeamsError, RemoveUserFromTeamError, RestorePermissionsForTeamMembersError,
+ RevokePermissionsForTeamMembersError, SeatPlan, SetTeamMemberPlanError, Team, TeamError,
+ TeamInvite, TeamInviteDetails, TeamMember, TeamMembers, TeamPlan, TeamRole, TeamWithMembers,
+ ToggleAutoJoinDomainError, TryJoinTeamByDomainError,
};
/// The TeamRepository defines a set of actions to perform on teams data
@@ -400,6 +400,20 @@ pub trait TeamService: Clone + Send + Sync + 'static {
entity_access_receipt: EntityAccessReceipt<OwnerTeamRole>,
) -> impl Future<Output = Result<(), DeleteTeamError>> + Send;
+ /// Detaches the user from every team ahead of account deletion.
+ ///
+ /// A team the user owns is deleted the way [`TeamService::delete_team`]
+ /// does it: the subscription is cancelled, the team and its memberships
+ /// are removed, `team.deleted` is published, and members on no other
+ /// team lose the team subscriber role. A team the user merely belongs to
+ /// is left the way [`TeamService::remove_user_from_team`] does it, with
+ /// the user recorded as the actor.
+ /// NOTE: this is not exposed via axum and is meant for account deletion only.
+ fn remove_user_from_all_teams(
+ &self,
+ user_id: &MacroUserIdStr<'_>,
+ ) -> impl Future<Output = Result<(), RemoveUserFromAllTeamsError>> + Send;
+
/// Accepts a team invite for a user
fn join_team(
&self,
diff --git a/crates/teams/src/domain/team_service.rs b/crates/teams/src/domain/team_service.rs
index 1641601e0b..0668b1e581 100644
--- a/crates/teams/src/domain/team_service.rs
+++ b/crates/teams/src/domain/team_service.rs
@@ -44,11 +44,11 @@ use crate::domain::{
model::{
CreateTeamError, CustomerError, DeleteTeamError, InviteUsersToTeamError, JoinTeamError,
PatchTeamCrmSettingsResponse, PatchTeamRequest, RemoveTeamInviteError,
- RemoveUserFromTeamError, RestorePermissionsForTeamMembersError,
- RevokePermissionsForTeamMembersError, SeatPlan, SetTeamMemberPlanError, Team, TeamError,
- TeamInvite, TeamInviteDetails, TeamMember, TeamMembers, TeamRole, TeamWithMembers,
- ToggleAutoJoinDomainError, TryJoinTeamByDomainError, is_generic_email_domain,
- team_slug_from_name,
+ RemoveUserFromAllTeamsError, RemoveUserFromTeamError,
+ RestorePermissionsForTeamMembersError, RevokePermissionsForTeamMembersError, SeatPlan,
+ SetTeamMemberPlanError, Team, TeamError, TeamInvite, TeamInviteDetails, TeamMember,
+ TeamMembers, TeamRole, TeamWithMembers, ToggleAutoJoinDomainError,
+ TryJoinTeamByDomainError, is_generic_email_domain, team_slug_from_name,
},
open_seat_release::{NoOpOpenSeatRelease, OpenSeatRelease},
team_analytics::{NoOpTeamAnalytics, TeamAnalytics, TeamAnalyticsEvent},
@@ -413,6 +413,264 @@ where
.ok();
}
+ /// Deletes `team_id` on behalf of `actor_user_id`: cancels the team
+ /// subscription, removes the team and its memberships, publishes
+ /// `team.deleted`, and strips the team subscriber role from members who
+ /// are on no other team.
+ async fn delete_team_as(
+ &self,
+ team_id: uuid::Uuid,
+ actor_user_id: MacroUserIdStr<'static>,
+ ) -> Result<(), DeleteTeamError> {
+ let members = self.team_repository.get_all_team_members(&team_id).await?;
+ let member_user_ids = members
+ .iter()
+ .map(|member| member.user_id.clone().into_owned())
+ .collect();
+
+ let subscription_id = self
+ .team_repository
+ .get_team_subscription_id(&team_id)
+ .await?;
+ if let Some(subscription_id) = subscription_id {
+ // Cancel subscription
+ self.customer_repository
+ .cancel_subscription(&subscription_id)
+ .await
+ .map_err(DeleteTeamError::CustomerError)?;
+ }
+
+ self.team_repository
+ .delete_team(&team_id)
+ .await
+ .map_err(DeleteTeamError::TeamError)?;
+ self.publish_team_event(&TeamMacroEvent::deleted(TeamDeletedMetadata {
+ team_id,
+ actor_user_id,
+ member_user_ids,
+ }));
+
+ // Remove roles for team members
+ let roles = vec![RoleId::TeamSubscriber];
+ let roles = non_empty::NonEmpty::new(roles.as_slice()).unwrap();
+
+ // TODO: speed this up
+ for member in members {
+ if !self
+ .team_repository
+ .is_user_member_of_team(&member.user_id)
+ .await?
+ {
+ self.user_roles_and_permissions_service
+ .dangerous_remove_roles_from_user(&member.user_id, &roles)
+ .await
+ .map_err(DeleteTeamError::RemoveRolesFromUserError)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Removes `user_id` from `team_id` on behalf of `removed_by_id`, rolling
+ /// back every completed side effect when a later one fails.
+ async fn remove_member(
+ &self,
+ team_id: uuid::Uuid,
+ user_id: &MacroUserIdStr<'_>,
+ removed_by_id: MacroUserIdStr<'static>,
+ ) -> Result<(), RemoveUserFromTeamError> {
+ let enterprise = self
+ .team_repository
+ .get_team_enterprise_status(&team_id)
+ .await?;
+
+ let roles_to_remove = team_member_roles_to_remove();
+ let current_roles = self
+ .user_roles_and_permissions_service
+ .get_user_roles(user_id)
+ .await
+ .map_err(RemoveUserFromTeamError::RemoveRolesFromUserError)?;
+ let roles_to_restore: Vec<RoleId> = roles_to_remove
+ .iter()
+ .filter(|role| current_roles.contains(*role))
+ .cloned()
+ .collect();
+
+ let removed_member = match self
+ .team_repository
+ .remove_user_from_team(&team_id, user_id)
+ .await
+ {
+ Ok(removed_member) => removed_member,
+ Err(RemoveUserFromTeamError::UserNotInTeam) => {
+ if let Err(error) = self.open_seat_release.release(team_id, user_id).await {
+ return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));
+ }
+ return Err(RemoveUserFromTeamError::UserNotInTeam);
+ }
+ Err(error) => return Err(error),
+ };
+
+ let subscription_id = if enterprise {
+ None
+ } else {
+ // Free teams have no linked subscription - nothing to decrement.
+ match self
+ .team_repository
+ .get_team_subscription_id(&team_id)
+ .await
+ {
+ Ok(subscription_id) => subscription_id,
+ Err(e) => {
+ self.team_repository
+ .rollback_remove_user_from_team(&removed_member)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback removed team member after getting team subscription failed"
+ );
+ })
+ .ok();
+ return Err(RemoveUserFromTeamError::TeamError(e));
+ }
+ }
+ };
+
+ if let Some(subscription_id) = subscription_id.as_ref()
+ && let Err(e) = self
+ .customer_repository
+ .decrement_seat_count(subscription_id, removed_member.plan, 1)
+ .await
+ {
+ self.team_repository
+ .rollback_remove_user_from_team(&removed_member)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback removed team member after decrementing seat count failed"
+ );
+ })
+ .ok();
+ return Err(RemoveUserFromTeamError::CustomerError(e));
+ }
+
+ let left_channel_ids = match self
+ .channel_service
+ .leave_by_team_id(&team_id, user_id)
+ .await
+ {
+ Ok(channel_ids) => channel_ids,
+ Err(error) => {
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .increment_seat_count(subscription_id, removed_member.plan, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after removing team member from channels failed"
+ );
+ })
+ .ok();
+ }
+ self.team_repository
+ .rollback_remove_user_from_team(&removed_member)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback removed team member after removing team member from channels failed"
+ );
+ })
+ .ok();
+ return Err(RemoveUserFromTeamError::TeamError(
+ channel_error_to_team_error(error),
+ ));
+ }
+ };
+
+ let roles = non_empty::NonEmpty::new(roles_to_remove.as_slice()).unwrap();
+
+ if let Err(e) = self
+ .user_roles_and_permissions_service
+ .dangerous_remove_roles_from_user(user_id, &roles)
+ .await
+ {
+ self.restore_after_channels_left(
+ &removed_member,
+ subscription_id.as_ref(),
+ user_id,
+ &left_channel_ids,
+ "removing team member roles",
+ )
+ .await;
+ return Err(RemoveUserFromTeamError::RemoveRolesFromUserError(e));
+ }
+
+ if let Err(error) = self.open_seat_release.release(team_id, user_id).await {
+ if let Ok(restore) = non_empty::NonEmpty::new(roles_to_restore.as_slice()) {
+ self.user_roles_and_permissions_service
+ .dangerous_upsert_roles_for_user(user_id, restore)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error = ?rollback_err,
+ "unable to restore member roles after releasing the open seat failed"
+ );
+ })
+ .ok();
+ }
+ self.restore_after_channels_left(
+ &removed_member,
+ subscription_id.as_ref(),
+ user_id,
+ &left_channel_ids,
+ "releasing the open seat",
+ )
+ .await;
+ return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));
+ }
+
+ // Best-effort: ask the email service to tear down CRM rows
+ // sourced from this user's email link. Log and swallow failures
+ // - the removal is already committed and the email-service
+ // handler is idempotent, so a missed enqueue can be retried
+ // without leaving the system in an inconsistent state. Team
+ // deletion is handled separately via the
+ // `crm_companies.team_id` FK cascade and does NOT route through
+ // this enqueuer.
+ if let Err(e) = self
+ .crm_enqueuer
+ .enqueue_depopulate_crm_for_user(&team_id, user_id)
+ .await
+ {
+ tracing::error!(
+ error = ?e,
+ team_id = %team_id,
+ macro_id = %user_id,
+ "Failed to enqueue DepopulateCrmForUser after remove_user_from_team; CRM rows owned by the removed user's link will be left in place until manual cleanup"
+ );
+ }
+
+ self.track_team_analytics_event(TeamAnalyticsEvent::TeamLeft {
+ team_id,
+ member_id: removed_member.user_id.clone().into_owned(),
+ removed_by_id: removed_by_id.clone(),
+ role: removed_member.role,
+ })
+ .await;
+ self.publish_team_event(&TeamMacroEvent::member_removed(TeamMemberRemovedMetadata {
+ team_id,
+ member_id: removed_member.user_id.into_owned(),
+ removed_by: removed_by_id,
+ role: removed_member.role,
+ }));
+
+ Ok(())
+ }
+
#[allow(
dead_code,
reason = "team mutations publish events in follow-up changes"
@@ -955,196 +1213,7 @@ where
.clone()
.into_owned();
- let enterprise = self
- .team_repository
- .get_team_enterprise_status(&team_id)
- .await?;
-
- let roles_to_remove = team_member_roles_to_remove();
- let current_roles = self
- .user_roles_and_permissions_service
- .get_user_roles(user_id)
- .await
- .map_err(RemoveUserFromTeamError::RemoveRolesFromUserError)?;
- let roles_to_restore: Vec<RoleId> = roles_to_remove
- .iter()
- .filter(|role| current_roles.contains(*role))
- .cloned()
- .collect();
-
- let removed_member = match self
- .team_repository
- .remove_user_from_team(&team_id, user_id)
- .await
- {
- Ok(removed_member) => removed_member,
- Err(RemoveUserFromTeamError::UserNotInTeam) => {
- if let Err(error) = self.open_seat_release.release(team_id, user_id).await {
- return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));
- }
- return Err(RemoveUserFromTeamError::UserNotInTeam);
- }
- Err(error) => return Err(error),
- };
-
- let subscription_id = if enterprise {
- None
- } else {
- // Free teams have no linked subscription - nothing to decrement.
- match self
- .team_repository
- .get_team_subscription_id(&team_id)
- .await
- {
- Ok(subscription_id) => subscription_id,
- Err(e) => {
- self.team_repository
- .rollback_remove_user_from_team(&removed_member)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback removed team member after getting team subscription failed"
- );
- })
- .ok();
- return Err(RemoveUserFromTeamError::TeamError(e));
- }
- }
- };
-
- if let Some(subscription_id) = subscription_id.as_ref()
- && let Err(e) = self
- .customer_repository
- .decrement_seat_count(subscription_id, removed_member.plan, 1)
- .await
- {
- self.team_repository
- .rollback_remove_user_from_team(&removed_member)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback removed team member after decrementing seat count failed"
- );
- })
- .ok();
- return Err(RemoveUserFromTeamError::CustomerError(e));
- }
-
- let left_channel_ids = match self
- .channel_service
- .leave_by_team_id(&team_id, user_id)
- .await
- {
- Ok(channel_ids) => channel_ids,
- Err(error) => {
- if let Some(subscription_id) = subscription_id.as_ref() {
- self.customer_repository
- .increment_seat_count(subscription_id, removed_member.plan, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after removing team member from channels failed"
- );
- })
- .ok();
- }
- self.team_repository
- .rollback_remove_user_from_team(&removed_member)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback removed team member after removing team member from channels failed"
- );
- })
- .ok();
- return Err(RemoveUserFromTeamError::TeamError(
- channel_error_to_team_error(error),
- ));
- }
- };
-
- let roles = non_empty::NonEmpty::new(roles_to_remove.as_slice()).unwrap();
-
- if let Err(e) = self
- .user_roles_and_permissions_service
- .dangerous_remove_roles_from_user(user_id, &roles)
- .await
- {
- self.restore_after_channels_left(
- &removed_member,
- subscription_id.as_ref(),
- user_id,
- &left_channel_ids,
- "removing team member roles",
- )
- .await;
- return Err(RemoveUserFromTeamError::RemoveRolesFromUserError(e));
- }
-
- if let Err(error) = self.open_seat_release.release(team_id, user_id).await {
- if let Ok(restore) = non_empty::NonEmpty::new(roles_to_restore.as_slice()) {
- self.user_roles_and_permissions_service
- .dangerous_upsert_roles_for_user(user_id, restore)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error = ?rollback_err,
- "unable to restore member roles after releasing the open seat failed"
- );
- })
- .ok();
- }
- self.restore_after_channels_left(
- &removed_member,
- subscription_id.as_ref(),
- user_id,
- &left_channel_ids,
- "releasing the open seat",
- )
- .await;
- return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));
- }
-
- // Best-effort: ask the email service to tear down CRM rows
- // sourced from this user's email link. Log and swallow failures
- // - the removal is already committed and the email-service
- // handler is idempotent, so a missed enqueue can be retried
- // without leaving the system in an inconsistent state. Team
- // deletion is handled separately via the
- // `crm_companies.team_id` FK cascade and does NOT route through
- // this enqueuer.
- if let Err(e) = self
- .crm_enqueuer
- .enqueue_depopulate_crm_for_user(&team_id, user_id)
- .await
- {
- tracing::error!(
- error = ?e,
- team_id = %team_id,
- macro_id = %user_id,
- "Failed to enqueue DepopulateCrmForUser after remove_user_from_team; CRM rows owned by the removed user's link will be left in place until manual cleanup"
- );
- }
-
- self.track_team_analytics_event(TeamAnalyticsEvent::TeamLeft {
- team_id,
- member_id: removed_member.user_id.clone().into_owned(),
- removed_by_id: removed_by_id.clone(),
- role: removed_member.role,
- })
- .await;
- self.publish_team_event(&TeamMacroEvent::member_removed(TeamMemberRemovedMetadata {
- team_id,
- member_id: removed_member.user_id.into_owned(),
- removed_by: removed_by_id,
- role: removed_member.role,
- }));
-
- Ok(())
+ self.remove_member(team_id, user_id, removed_by_id).await
}
#[tracing::instrument(skip(self), err)]
@@ -1223,52 +1292,25 @@ where
.clone()
.into_owned();
- let members = self.team_repository.get_all_team_members(&team_id).await?;
- let member_user_ids = members
- .iter()
- .map(|member| member.user_id.clone().into_owned())
- .collect();
-
- let subscription_id = self
- .team_repository
- .get_team_subscription_id(&team_id)
- .await?;
- if let Some(subscription_id) = subscription_id {
- // Cancel subscription
- self.customer_repository
- .cancel_subscription(&subscription_id)
- .await
- .map_err(DeleteTeamError::CustomerError)?;
- }
-
- self.team_repository
- .delete_team(&team_id)
- .await
- .map_err(DeleteTeamError::TeamError)?;
- self.publish_team_event(&TeamMacroEvent::deleted(TeamDeletedMetadata {
- team_id,
- actor_user_id,
- member_user_ids,
- }));
-
- // Remove roles for team members
- let roles = vec![RoleId::TeamSubscriber];
- let roles = non_empty::NonEmpty::new(roles.as_slice()).unwrap();
+ self.delete_team_as(team_id, actor_user_id).await
+ }
- // TODO: speed this up
- for member in members {
- if !self
- .team_repository
- .is_user_member_of_team(&member.user_id)
- .await?
- {
- self.user_roles_and_permissions_service
- .dangerous_remove_roles_from_user(&member.user_id, &roles)
- .await
- .map_err(DeleteTeamError::RemoveRolesFromUserError)?;
+ #[tracing::instrument(skip(self), err)]
+ async fn remove_user_from_all_teams(
+ &self,
+ user_id: &MacroUserIdStr<'_>,
+ ) -> Result<(), RemoveUserFromAllTeamsError> {
+ let teams = self.team_repository.get_user_teams(user_id).await?;
+ for team in teams {
+ let team_id = *team.id();
+ if team.owner_id() == user_id.as_ref() {
+ self.delete_team_as(team_id, user_id.clone().into_owned())
+ .await?;
+ } else {
+ self.remove_member(team_id, user_id, user_id.clone().into_owned())
+ .await?;
}
}
-
Ok(())
}
diff --git a/crates/teams/src/domain/team_service/test.rs b/crates/teams/src/domain/team_service/test.rs
index 4570335269..5ec8ad4367 100644
--- a/crates/teams/src/domain/team_service/test.rs
+++ b/crates/teams/src/domain/team_service/test.rs
@@ -56,9 +56,10 @@ use crate::domain::{
customer_repo::CustomerRepository,
model::{
AcceptedTeamInvite, CustomerError, PatchTeamRequest, PatchTeamUserRole,
- RemoveTeamInviteError, RemoveUserFromTeamError, SeatPlan, SetTeamMemberPlanError, Team,
- TeamError, TeamInvite, TeamInviteDetails, TeamInviteSnapshot, TeamMember, TeamPlan,
- TeamRole, TeamWithMembers, ToggleAutoJoinDomainError, TryJoinTeamByDomainError,
+ RemoveTeamInviteError, RemoveUserFromAllTeamsError, RemoveUserFromTeamError, SeatPlan,
+ SetTeamMemberPlanError, Team, TeamError, TeamInvite, TeamInviteDetails, TeamInviteSnapshot,
+ TeamMember, TeamPlan, TeamRole, TeamWithMembers, ToggleAutoJoinDomainError,
+ TryJoinTeamByDomainError,
},
team_repo::TeamRepository,
};
@@ -130,6 +131,7 @@ struct MockTeamRepository {
fail_get_all_team_members: bool,
team_ids: Vec<uuid::Uuid>,
reject_owner: bool,
+ user_teams: Vec<Team>,
}
impl MockTeamRepository {
@@ -207,6 +209,7 @@ impl MockTeamRepository {
fail_get_all_team_members: false,
team_ids: Vec::new(),
reject_owner: false,
+ user_teams: Vec::new(),
}
}
@@ -610,7 +613,8 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &MacroUserIdStr<'_>,
) -> impl Future<Output = Result<Vec<Team>, TeamError>> + Send {
- async { unimplemented!() }
+ let teams = self.user_teams.clone();
+ async move { Ok(teams) }
}
fn get_user_team_invites(
@@ -3990,6 +3994,107 @@ async fn test_delete_team_repository_failures_do_not_publish_event() {
}
}
+fn account_deletion_team(team_id: uuid::Uuid, owner: &MacroUserIdStr<'_>) -> Team {
+ Team::new(
+ team_id,
+ "Team".to_string(),
+ "team".to_string(),
+ owner.clone().into_owned(),
+ false,
+ false,
+ )
+}
+
+#[tokio::test]
+async fn remove_user_from_all_teams_deletes_the_team_the_user_owns() {
+ let team_id = uuid::Uuid::from_u128(809);
+ let owner = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut repo = MockTeamRepository::new(Vec::new(), "Team", Arc::new(Mutex::new(Vec::new())));
+ repo.user_teams = vec![account_deletion_team(team_id, &owner)];
+ repo.team_members = vec![
+ make_team_member(team_id, owner.as_ref(), TeamRole::Owner),
+ make_team_member(team_id, member.as_ref(), TeamRole::Member),
+ ];
+ let delete_team_calls = repo.delete_team_calls.clone();
+ let remove_user_calls = repo.remove_user_calls.clone();
+ let broker = RecordingEventBroker::default();
+ let service = build_service_with_repo_and_broker(repo, broker.clone());
+
+ service.remove_user_from_all_teams(&owner).await.unwrap();
+
+ assert_eq!(*delete_team_calls.lock().unwrap(), vec![team_id]);
+ assert_eq!(*remove_user_calls.lock().unwrap(), 0);
+ let events = broker.events();
+ assert_eq!(events.len(), 1);
+ assert_eq!(events[0].envelope["event_type"], "team.deleted");
+ let metadata = &events[0].envelope["metadata"];
+ assert_eq!(metadata["actor_user_id"], owner.as_ref());
+ assert_eq!(
+ metadata["member_user_ids"],
+ serde_json::json!([owner.as_ref(), member.as_ref()])
+ );
+}
+
+#[tokio::test]
+async fn remove_user_from_all_teams_leaves_the_team_the_user_belongs_to() {
+ let team_id = uuid::Uuid::from_u128(810);
+ let owner = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut repo = MockTeamRepository::new(Vec::new(), "Team", Arc::new(Mutex::new(Vec::new())));
+ repo.user_teams = vec![account_deletion_team(team_id, &owner)];
+ repo.removed_member = Some(make_team_member(team_id, member.as_ref(), TeamRole::Member));
+ let delete_team_calls = repo.delete_team_calls.clone();
+ let remove_user_calls = repo.remove_user_calls.clone();
+ let broker = RecordingEventBroker::default();
+ let service = build_service_with_repo_and_broker(repo, broker.clone());
+
+ service.remove_user_from_all_teams(&member).await.unwrap();
+
+ assert!(delete_team_calls.lock().unwrap().is_empty());
+ assert_eq!(*remove_user_calls.lock().unwrap(), 1);
+ let events = broker.events();
+ assert_eq!(events.len(), 1);
+ assert_eq!(events[0].envelope["event_type"], "team.member_removed");
+ let metadata = &events[0].envelope["metadata"];
+ assert_eq!(metadata["member_id"], member.as_ref());
+ assert_eq!(metadata["removed_by"], member.as_ref());
+}
+
+#[tokio::test]
+async fn remove_user_from_all_teams_without_a_team_changes_nothing() {
+ let user = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let repo = MockTeamRepository::new(Vec::new(), "Team", Arc::new(Mutex::new(Vec::new())));
+ let delete_team_calls = repo.delete_team_calls.clone();
+ let remove_user_calls = repo.remove_user_calls.clone();
+ let broker = RecordingEventBroker::default();
+ let service = build_service_with_repo_and_broker(repo, broker.clone());
+
+ service.remove_user_from_all_teams(&user).await.unwrap();
+
+ assert!(delete_team_calls.lock().unwrap().is_empty());
+ assert_eq!(*remove_user_calls.lock().unwrap(), 0);
+ assert!(broker.events().is_empty());
+}
+
+#[tokio::test]
+async fn remove_user_from_all_teams_surfaces_owned_team_deletion_failures() {
+ let team_id = uuid::Uuid::from_u128(811);
+ let owner = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut repo = MockTeamRepository::new(Vec::new(), "Team", Arc::new(Mutex::new(Vec::new())));
+ repo.user_teams = vec![account_deletion_team(team_id, &owner)];
+ repo.team_members = vec![make_team_member(team_id, owner.as_ref(), TeamRole::Owner)];
+ repo.fail_delete_team = true;
+ let broker = RecordingEventBroker::default();
+ let service = build_service_with_repo_and_broker(repo, broker.clone());
+
+ assert!(matches!(
+ service.remove_user_from_all_teams(&owner).await,
+ Err(RemoveUserFromAllTeamsError::DeleteTeam(_))
+ ));
+ assert!(broker.events().is_empty());
+}
+
#[tokio::test]
async fn test_invite_users_to_team_backfills_legacy_team_subscription() {
let team_id = uuid::Uuid::from_u128(42);
diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rs
index 00155c1e06..2774ed2a7c 100644
--- a/crates/teams/src/inbound/axum_router/test.rs
+++ b/crates/teams/src/inbound/axum_router/test.rs
@@ -425,6 +425,13 @@ impl TeamService for FakeTeamService {
panic!("unexpected toggle_allow_non_admin_invites call")
}
+ async fn remove_user_from_all_teams(
+ &self,
+ _user_id: &MacroUserIdStr<'_>,
+ ) -> Result<(), crate::domain::model::RemoveUserFromAllTeamsError> {
+ panic!("unexpected remove_user_from_all_teams call")
+ }
+
async fn try_join_team_by_domain(
&self,
_user_id: &MacroUserIdStr<'_>,
diff --git a/services/authentication_service/src/api/context.rs b/services/authentication_service/src/api/context.rs
index fd926bda83..5e7a04a836 100644
--- a/services/authentication_service/src/api/context.rs
+++ b/services/authentication_service/src/api/context.rs
@@ -142,7 +142,8 @@ pub(crate) struct ApiContext {
pub stripe_client: Arc<stripe::Client>,
pub document_storage_service_client:
Arc<document_storage_service_client::DocumentStorageServiceClient>,
- pub user_deletion: Arc<authentication_service::outbound::user_deletion::UserDeletionAdapter>,
+ pub user_deletion:
+ Arc<authentication_service::outbound::user_deletion::UserDeletionAdapter<TeamsServiceType>>,
pub email_service_client: Arc<email::outbound::EmailServiceHttpClient>,
pub ses_client: Arc<ses_client::Ses>,
pub notification_ingress_service: Arc<NotificationIngressType>,
diff --git a/services/authentication_service/src/main.rs b/services/authentication_service/src/main.rs
index 466c420b09..feb22234a2 100644
--- a/services/authentication_service/src/main.rs
+++ b/services/authentication_service/src/main.rs
@@ -391,7 +391,7 @@ async fn main() -> anyhow::Result<()> {
PgAccessRepository::new(db.clone()),
));
let connection_gateway_client = Arc::new(ConnectionGatewayClient::new(
- internal_api_key.to_string(),
+ config.service_internal_auth_key.to_string(),
ConnectionGatewayUrl::new()?.to_string(),
));
// Authentication creates channels and posts support welcome messages in-process, so its
@@ -525,12 +525,16 @@ async fn main() -> anyhow::Result<()> {
.with_contacts_enqueuer(contacts_enqueuer)
.with_event_broker(macro_event_broker)
.with_open_seat_release((*ai_billing_service).clone());
+ let teams_service = Arc::new(teams_service_impl);
let document_storage_service_client = Arc::new(document_storage_service_client);
+ // The harness and scheduled-action services validate the fleet-wide
+ // internal key, not this service's own inbound key.
let user_deletion = Arc::new(
authentication_service::outbound::user_deletion::UserDeletionAdapter::new(
db.clone(),
document_storage_service_client.clone(),
- internal_api_key.to_string(),
+ teams_service.clone(),
+ config.service_internal_auth_key.to_string(),
macro_service_urls::AgentHarnessServiceUrl::new()?.to_string(),
macro_service_urls::ScheduledActionServiceUrl::new()?.to_string(),
)
@@ -570,7 +574,7 @@ async fn main() -> anyhow::Result<()> {
internal_api_key,
stripe_webhook_secret,
user_roles_and_permissions_service: Arc::new(user_roles_and_permissions_service),
- teams_service: Arc::new(teams_service_impl),
+ teams_service,
channel_service: Arc::new(channel_service),
channel_messages,
favorites_service: Arc::new(favorites_service),
diff --git a/services/authentication_service/src/outbound/user_deletion.rs b/services/authentication_service/src/outbound/user_deletion.rs
index c93bd3cdd8..648725acd5 100644
--- a/services/authentication_service/src/outbound/user_deletion.rs
+++ b/services/authentication_service/src/outbound/user_deletion.rs
@@ -10,26 +10,34 @@ use rootcause::{
prelude::{IntoRootcause, ResultExt},
};
use sqlx::PgPool;
+use teams::domain::team_repo::TeamService;
use uuid::Uuid;
use crate::service::user::delete_user::UserDeletionGateway;
-/// HTTP and database adapter composed at authentication-service startup.
-pub struct UserDeletionAdapter {
+/// HTTP, in-process team service, and database adapter composed at
+/// authentication-service startup.
+pub struct UserDeletionAdapter<T: TeamService> {
db: PgPool,
documents: Arc<DocumentStorageServiceClient>,
+ teams: Arc<T>,
client: reqwest::Client,
internal_key: String,
harness_url: String,
scheduled_action_url: String,
}
-impl UserDeletionAdapter {
+impl<T: TeamService> UserDeletionAdapter<T> {
/// Construct a bounded HTTP client. Redirects must not turn a failed
/// internal DELETE into an unrelated successful response.
+ ///
+ /// `internal_key` is the fleet-wide internal service key that the agent
+ /// harness and scheduled-action services validate. This service's own
+ /// inbound key is a different secret and is rejected by them.
pub fn new(
db: PgPool,
documents: Arc<DocumentStorageServiceClient>,
+ teams: Arc<T>,
internal_key: String,
harness_url: String,
scheduled_action_url: String,
@@ -37,6 +45,7 @@ impl UserDeletionAdapter {
Ok(Self {
db,
documents,
+ teams,
client: reqwest::Client::builder()
.timeout(Duration::from_secs(300))
.redirect(reqwest::redirect::Policy::none())
@@ -73,7 +82,7 @@ impl UserDeletionAdapter {
}
}
-impl UserDeletionGateway for UserDeletionAdapter {
+impl<T: TeamService> UserDeletionGateway for UserDeletionAdapter<T> {
async fn delete_scheduled_actions(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
self.delete_owned(&self.scheduled_action_url, "scheduled-actions", user)
.await
@@ -84,6 +93,15 @@ impl UserDeletionGateway for UserDeletionAdapter {
.await
}
+ async fn leave_teams(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
+ self.teams
+ .remove_user_from_all_teams(user)
+ .await
+ .map_err(|error| Report::new(error).into_dynamic())
+ .context("failed to remove user from teams")?;
+ Ok(())
+ }
+
async fn delete_items(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
self.documents
.delete_all_user_items(user.as_ref())
diff --git a/services/authentication_service/src/service/user/delete_user.rs b/services/authentication_service/src/service/user/delete_user.rs
index 499e9ca069..3dc0452e27 100644
--- a/services/authentication_service/src/service/user/delete_user.rs
+++ b/services/authentication_service/src/service/user/delete_user.rs
@@ -19,6 +19,13 @@ pub trait UserDeletionGateway: Send + Sync {
&self,
user: &MacroUserIdStr<'static>,
) -> impl Future<Output = Result<(), Report>> + Send;
+ /// Delete the teams the user owns and leave the rest through the teams
+ /// service, so subscriptions, member roles, and team events are handled
+ /// instead of the membership silently cascading away with the profile.
+ fn leave_teams(
+ &self,
+ user: &MacroUserIdStr<'static>,
+ ) -> impl Future<Output = Result<(), Report>> + Send;
/// Delete documents, chats, and projects through their owning service.
fn delete_items(
&self,
@@ -44,6 +51,7 @@ pub async fn delete_user_data(
for user in users {
gateway.delete_scheduled_actions(user).await?;
gateway.delete_agent_sessions(user).await?;
+ gateway.leave_teams(user).await?;
gateway.delete_items(user).await?;
gateway.delete_profile(user, account).await?;
}
diff --git a/services/authentication_service/src/service/user/delete_user/test.rs b/services/authentication_service/src/service/user/delete_user/test.rs
index de09f40942..6daef09b51 100644
--- a/services/authentication_service/src/service/user/delete_user/test.rs
+++ b/services/authentication_service/src/service/user/delete_user/test.rs
@@ -25,6 +25,9 @@ impl UserDeletionGateway for FakeGateway {
async fn delete_agent_sessions(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
self.call("sessions", user.as_ref())
}
+ async fn leave_teams(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
+ self.call("teams", user.as_ref())
+ }
async fn delete_items(&self, user: &MacroUserIdStr<'static>) -> Result<(), Report> {
self.call("items", user.as_ref())
}
@@ -46,7 +49,7 @@ fn users() -> Vec<MacroUserIdStr<'static>> {
fn expected_calls() -> Vec<String> {
let mut expected = Vec::new();
for user in users() {
- for step in ["actions", "sessions", "items", "profile"] {
+ for step in ["actions", "sessions", "teams", "items", "profile"] {
expected.push(format!("{step}:{user}"));
}
}