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(invites): email every invitee in a multi-person team invite (#8436)

Chaitanya Agarwal43a9e25a79f4
diff --git a/crates/invite_email/src/lib.rs b/crates/invite_email/src/lib.rs
index b2b8b9ad99..cefcefd25e 100644
--- a/crates/invite_email/src/lib.rs
+++ b/crates/invite_email/src/lib.rs
@@ -328,10 +328,12 @@ impl NotificationExtEmail for InviteToTeamMetadata {
}
}
+ /// One bucket per invite (one invite per recipient per team), so inviting
+ /// several teammates at once emails each of them. Resends reuse the invite.
fn rate_limit_key(&self) -> RateLimitKey {
RateLimitKey::builder(&Self::TYPE_NAME)
.append(&self.team_id)
- .append(&self.invited_by.as_ref())
+ .append(&self.team_invite_id)
.finish()
}
}
diff --git a/crates/invite_email/src/test.rs b/crates/invite_email/src/test.rs
index 28358169f6..f511bc369e 100644
--- a/crates/invite_email/src/test.rs
+++ b/crates/invite_email/src/test.rs
@@ -109,6 +109,30 @@ fn colleague_joined_rate_limit_key_is_per_recipient() {
);
}
+#[test]
+fn team_invite_rate_limit_key_is_per_invite() {
+ let to_bob = InviteToTeamMetadata {
+ team_name: "Acme".to_string(),
+ team_id: Uuid::from_u128(1),
+ team_invite_id: Uuid::from_u128(10),
+ invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
+ role: None,
+ sender_profile_picture_url: None,
+ };
+ let to_carol = InviteToTeamMetadata {
+ team_invite_id: Uuid::from_u128(11),
+ ..to_bob.clone()
+ };
+ assert_eq!(
+ to_bob.rate_limit_key().as_bytes(),
+ to_bob.clone().rate_limit_key().as_bytes()
+ );
+ assert_ne!(
+ to_bob.rate_limit_key().as_bytes(),
+ to_carol.rate_limit_key().as_bytes()
+ );
+}
+
#[test]
fn colleague_joined_serde_round_trip_keeps_the_wire_shape() {
let wire = serde_json::json!({
diff --git a/crates/teams/src/domain/model.rs b/crates/teams/src/domain/model.rs
index 72ee691fce..4b41bcee80 100644
--- a/crates/teams/src/domain/model.rs
+++ b/crates/teams/src/domain/model.rs
@@ -653,8 +653,8 @@ pub enum CreateTeamError {
/// Errors for inviting users to team
#[derive(Debug, thiserror::Error)]
pub enum InviteUsersToTeamError {
- /// Too many emails were provided
- #[error("Too many emails were provided")]
+ /// The team has hit its daily limit on new invites
+ #[error("the team has sent too many invites today")]
TooManyEmails,
/// The team only allows admins to invite and the caller is not an admin
#[error("only team admins may invite users to this team")]
diff --git a/crates/teams/src/domain/team_service.rs b/crates/teams/src/domain/team_service.rs
index 195b68c477..c4ed567dd0 100644
--- a/crates/teams/src/domain/team_service.rs
+++ b/crates/teams/src/domain/team_service.rs
@@ -57,6 +57,9 @@ use crate::domain::{
team_repo::{TeamMembersService, TeamRepository, TeamService},
};
+/// Most new invites a non-enterprise team may create in a rolling day.
+const MAX_TEAM_INVITES_PER_DAY: usize = 50;
+
/// The roles a member of a paying or enterprise team holds: the team
/// subscriber role plus the tier role of their seat's plan.
fn team_member_roles_to_add(plan: SeatPlan) -> Vec<RoleId> {
@@ -1309,6 +1312,22 @@ where
.get_new_invites(&team_id, invites.clone())
.await?;
+ // Every new invite sends an email, so a team cannot be used to mail
+ // strangers in bulk. Enterprise teams onboard many people at once.
+ if !enterprise && !new_invites.is_empty() {
+ let day_ago = chrono::Utc::now() - chrono::Duration::days(1);
+ let invited_today = self
+ .team_repository
+ .get_team_invites(&team_id)
+ .await?
+ .iter()
+ .filter(|invite| invite.created_at > day_ago)
+ .count();
+ if invited_today + new_invites.len() > MAX_TEAM_INVITES_PER_DAY {
+ return Err(InviteUsersToTeamError::TooManyEmails);
+ }
+ }
+
let new_invite_emails: HashSet<String> = new_invites
.iter()
.map(|email| email.as_ref().to_owned())
diff --git a/crates/teams/src/domain/team_service/test.rs b/crates/teams/src/domain/team_service/test.rs
index 54e7818854..8afea1b74d 100644
--- a/crates/teams/src/domain/team_service/test.rs
+++ b/crates/teams/src/domain/team_service/test.rs
@@ -115,6 +115,7 @@ struct MockTeamRepository {
fail_invite_users_to_team: bool,
invite_users_to_team_calls: Arc<Mutex<usize>>,
new_invite_emails: Option<Vec<String>>,
+ pending_team_invites: Vec<TeamInviteDetails>,
invite_by_id: Option<TeamInvite<'static>>,
delete_invite_calls: Arc<Mutex<Vec<(uuid::Uuid, uuid::Uuid)>>>,
fail_delete_invite: bool,
@@ -194,6 +195,7 @@ impl MockTeamRepository {
fail_invite_users_to_team: false,
invite_users_to_team_calls: Arc::new(Mutex::new(0)),
new_invite_emails: None,
+ pending_team_invites: Vec::new(),
invite_by_id: None,
delete_invite_calls: Arc::new(Mutex::new(Vec::new())),
fail_delete_invite: false,
@@ -677,7 +679,8 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &uuid::Uuid,
) -> impl Future<Output = Result<Vec<TeamInviteDetails>, TeamError>> + Send {
- async { unimplemented!() }
+ let invites = self.pending_team_invites.clone();
+ async move { Ok(invites) }
}
fn get_team_name(
@@ -3252,6 +3255,62 @@ async fn invite_users_to_team_blocked_for_member_when_non_admin_invites_disabled
assert!(mark_sent_calls.lock().unwrap().is_empty());
}
+#[tokio::test]
+async fn invite_users_to_team_caps_new_invites_per_day() {
+ let team_id = uuid::Uuid::from_u128(6140);
+ let invite_id = uuid::Uuid::from_u128(6141);
+ let invited_by = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mark_sent_calls = Arc::new(Mutex::new(Vec::new()));
+ let mut team_repo = MockTeamRepository::new(
+ vec![make_invite("[email protected]", invite_id, team_id)],
+ "Busy Team",
+ mark_sent_calls.clone(),
+ );
+ let recent = |n: u128, created_at| TeamInviteDetails {
+ id: uuid::Uuid::from_u128(7000 + n),
+ email: format!("invitee{n}@example.com"),
+ team_id,
+ team_role: TeamRole::Member,
+ invited_by: "macro|[email protected]".to_string(),
+ created_at,
+ last_sent_at: created_at,
+ };
+ let now = chrono::Utc::now();
+ // A day-old invite no longer counts toward today's limit.
+ team_repo.pending_team_invites = (0..MAX_TEAM_INVITES_PER_DAY as u128)
+ .map(|n| recent(n, now))
+ .chain([recent(999, now - chrono::Duration::days(2))])
+ .collect();
+ let invitation_persistence_calls = team_repo.invite_users_to_team_calls.clone();
+
+ let service = TeamServiceImpl::new(
+ team_repo,
+ MockCustomerRepository::default(),
+ RecordingChannelService::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ let invite_emails = vec![
+ Email::parse_from_str("[email protected]")
+ .unwrap()
+ .lowercase(),
+ ];
+ let error = service
+ .invite_users_to_team(
+ test_team_receipt::<MemberTeamRole>(team_id, &invited_by),
+ non_empty::NonEmpty::new(invite_emails.as_slice()).unwrap(),
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, InviteUsersToTeamError::TooManyEmails));
+ assert_eq!(*invitation_persistence_calls.lock().unwrap(), 0);
+ assert!(mark_sent_calls.lock().unwrap().is_empty());
+}
+
#[tokio::test]
async fn invite_users_to_team_allowed_for_admin_when_non_admin_invites_disabled() {
let team_id = uuid::Uuid::from_u128(6110);
diff --git a/crates/teams/src/inbound/axum_router.rs b/crates/teams/src/inbound/axum_router.rs
index 12183132e1..71f6015b14 100644
--- a/crates/teams/src/inbound/axum_router.rs
+++ b/crates/teams/src/inbound/axum_router.rs
@@ -262,7 +262,7 @@ impl IntoResponse for InviteUsersToTeamError {
InviteUsersToTeamError::TooManyEmails => (
StatusCode::BAD_REQUEST,
Json(ErrorResponse {
- message: "too many emails".into(),
+ message: "too many invites today; try again tomorrow".into(),
}),
),
InviteUsersToTeamError::NonAdminInvitesDisabled => (