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.

feat(teams): support enterprise contract teams (#4884)

Will Hutchinson1c8232fbe9b3
diff --git a/.sqlx/query-14df98e291c38661eb60224a93d61fda30583f9fafae4fde8b1ba73974e4d914.json b/.sqlx/query-14df98e291c38661eb60224a93d61fda30583f9fafae4fde8b1ba73974e4d914.json
new file mode 100644
index 0000000000..8fc53362c3
--- /dev/null
+++ b/.sqlx/query-14df98e291c38661eb60224a93d61fda30583f9fafae4fde8b1ba73974e4d914.json
@@ -0,0 +1,22 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT enterprise\n FROM team\n WHERE id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "enterprise",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid"
+ ]
+ },
+ "nullable": [
+ false
+ ]
+ },
+ "hash": "14df98e291c38661eb60224a93d61fda30583f9fafae4fde8b1ba73974e4d914"
+}
diff --git a/.sqlx/query-b3908e74b7e17fe7a0910abf70f933a832d32ef6df78eb3e327b4fe282dd67ed.json b/.sqlx/query-58e9a0467f6c0795abbf9ebba05ee30f28de0dee4cc6d1c7a84b0c55ca05d27c.json
similarity index 79%
rename from .sqlx/query-b3908e74b7e17fe7a0910abf70f933a832d32ef6df78eb3e327b4fe282dd67ed.json
rename to .sqlx/query-58e9a0467f6c0795abbf9ebba05ee30f28de0dee4cc6d1c7a84b0c55ca05d27c.json
index 8be43078c0..6aecbc1243 100644
--- a/.sqlx/query-b3908e74b7e17fe7a0910abf70f933a832d32ef6df78eb3e327b4fe282dd67ed.json
+++ b/.sqlx/query-58e9a0467f6c0795abbf9ebba05ee30f28de0dee4cc6d1c7a84b0c55ca05d27c.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n INSERT INTO team (id, name, owner_id, seat_count, subscription_id, paying)\n VALUES ($1, $2, $3, 1, $4, TRUE)\n RETURNING id, name, slug, owner_id\n ",
+ "query": "\n INSERT INTO team (id, name, owner_id, seat_count, subscription_id, paying)\n VALUES ($1, $2, $3, 1, $4, TRUE)\n RETURNING id, name, slug, owner_id, enterprise\n ",
"describe": {
"columns": [
{
@@ -22,6 +22,11 @@
"ordinal": 3,
"name": "owner_id",
"type_info": "Text"
+ },
+ {
+ "ordinal": 4,
+ "name": "enterprise",
+ "type_info": "Bool"
}
],
"parameters": {
@@ -36,8 +41,9 @@
false,
false,
false,
+ false,
false
]
},
- "hash": "b3908e74b7e17fe7a0910abf70f933a832d32ef6df78eb3e327b4fe282dd67ed"
+ "hash": "58e9a0467f6c0795abbf9ebba05ee30f28de0dee4cc6d1c7a84b0c55ca05d27c"
}
diff --git a/.sqlx/query-f9a6fffccca132ccefa2654e7e08d87320c51e5103e589615b475f18c3f07f68.json b/.sqlx/query-8412cb4e4925bf7d8ff2ebf5ece3a13570a0df3f222d81e7ff90a1e27c564697.json
similarity index 66%
rename from .sqlx/query-f9a6fffccca132ccefa2654e7e08d87320c51e5103e589615b475f18c3f07f68.json
rename to .sqlx/query-8412cb4e4925bf7d8ff2ebf5ece3a13570a0df3f222d81e7ff90a1e27c564697.json
index cee1ed3162..7e1647365b 100644
--- a/.sqlx/query-f9a6fffccca132ccefa2654e7e08d87320c51e5103e589615b475f18c3f07f68.json
+++ b/.sqlx/query-8412cb4e4925bf7d8ff2ebf5ece3a13570a0df3f222d81e7ff90a1e27c564697.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain,\n COALESCE(tcs.crm_enabled, FALSE) AS \"crm_enabled!\"\n FROM team t\n LEFT JOIN team_crm_settings tcs ON tcs.team_id = t.id\n WHERE t.id = $1\n ",
+ "query": "\n SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain, t.enterprise,\n COALESCE(tcs.crm_enabled, FALSE) AS \"crm_enabled!\"\n FROM team t\n LEFT JOIN team_crm_settings tcs ON tcs.team_id = t.id\n WHERE t.id = $1\n ",
"describe": {
"columns": [
{
@@ -30,6 +30,11 @@
},
{
"ordinal": 5,
+ "name": "enterprise",
+ "type_info": "Bool"
+ },
+ {
+ "ordinal": 6,
"name": "crm_enabled!",
"type_info": "Bool"
}
@@ -45,8 +50,9 @@
false,
false,
true,
+ false,
null
]
},
- "hash": "f9a6fffccca132ccefa2654e7e08d87320c51e5103e589615b475f18c3f07f68"
+ "hash": "8412cb4e4925bf7d8ff2ebf5ece3a13570a0df3f222d81e7ff90a1e27c564697"
}
diff --git a/.sqlx/query-bbf73370ac43c4f2378584e005b10a8d854b7c0203978dfb28c2fa7a70996bdd.json b/.sqlx/query-9c06e7ff3bf17ac4951964b0b9b4c191b8a66e46b15c1b19f93416650f8ea1ea.json
similarity index 64%
rename from .sqlx/query-bbf73370ac43c4f2378584e005b10a8d854b7c0203978dfb28c2fa7a70996bdd.json
rename to .sqlx/query-9c06e7ff3bf17ac4951964b0b9b4c191b8a66e46b15c1b19f93416650f8ea1ea.json
index 224d49cbd0..35be07381c 100644
--- a/.sqlx/query-bbf73370ac43c4f2378584e005b10a8d854b7c0203978dfb28c2fa7a70996bdd.json
+++ b/.sqlx/query-9c06e7ff3bf17ac4951964b0b9b4c191b8a66e46b15c1b19f93416650f8ea1ea.json
@@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
- "query": "\n SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain,\n COALESCE(tcs.crm_enabled, FALSE) AS \"crm_enabled!\"\n FROM team t\n JOIN team_user tu ON t.id = tu.team_id\n LEFT JOIN team_crm_settings tcs ON tcs.team_id = t.id\n WHERE tu.user_id = $1\n ",
+ "query": "\n SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain, t.enterprise,\n COALESCE(tcs.crm_enabled, FALSE) AS \"crm_enabled!\"\n FROM team t\n JOIN team_user tu ON t.id = tu.team_id\n LEFT JOIN team_crm_settings tcs ON tcs.team_id = t.id\n WHERE tu.user_id = $1\n ",
"describe": {
"columns": [
{
@@ -30,6 +30,11 @@
},
{
"ordinal": 5,
+ "name": "enterprise",
+ "type_info": "Bool"
+ },
+ {
+ "ordinal": 6,
"name": "crm_enabled!",
"type_info": "Bool"
}
@@ -45,8 +50,9 @@
false,
false,
true,
+ false,
null
]
},
- "hash": "bbf73370ac43c4f2378584e005b10a8d854b7c0203978dfb28c2fa7a70996bdd"
+ "hash": "9c06e7ff3bf17ac4951964b0b9b4c191b8a66e46b15c1b19f93416650f8ea1ea"
}
diff --git a/apps/web/src/lib/queries/team/teams.ts b/apps/web/src/lib/queries/team/teams.ts
index 663199bece..7477946d9e 100644
--- a/apps/web/src/lib/queries/team/teams.ts
+++ b/apps/web/src/lib/queries/team/teams.ts
@@ -320,6 +320,7 @@ export function useCreateTeamWithInvitesMutation(
owner_id: userInfo.userId,
crm_enabled: false,
auto_join_domain: null,
+ enterprise: false,
};
queryClient.setQueryData<Team[]>(
diff --git a/apps/web/src/lib/service-clients/service-auth/generated/schemas/team.ts b/apps/web/src/lib/service-clients/service-auth/generated/schemas/team.ts
index 3d4d1899b0..a771316922 100644
--- a/apps/web/src/lib/service-clients/service-auth/generated/schemas/team.ts
+++ b/apps/web/src/lib/service-clients/service-auth/generated/schemas/team.ts
@@ -16,6 +16,10 @@ with, when automatic domain joining is enabled (None otherwise). */
/** Whether the CRM is enabled for this team (from `team_crm_settings`;
`false` when no row exists). */
crm_enabled: boolean;
+ /** Whether this team is on an enterprise license. Enterprise teams are
+billed out-of-band; membership changes skip all Stripe subscription
+bookkeeping (no seat counts, no subscription backfill, no paying check). */
+ enterprise: boolean;
id: string;
name: string;
owner_id: string;
diff --git a/apps/web/src/lib/service-clients/service-auth/openapi.json b/apps/web/src/lib/service-clients/service-auth/openapi.json
index b6891816a2..6c798ba3f5 100644
--- a/apps/web/src/lib/service-clients/service-auth/openapi.json
+++ b/apps/web/src/lib/service-clients/service-auth/openapi.json
@@ -4281,7 +4281,14 @@
"Team": {
"type": "object",
"description": "The Team struct",
- "required": ["id", "name", "slug", "owner_id", "crm_enabled"],
+ "required": [
+ "id",
+ "name",
+ "slug",
+ "owner_id",
+ "crm_enabled",
+ "enterprise"
+ ],
"properties": {
"auto_join_domain": {
"type": ["string", "null"],
@@ -4291,6 +4298,10 @@
"type": "boolean",
"description": "Whether the CRM is enabled for this team (from `team_crm_settings`;\n`false` when no row exists)."
},
+ "enterprise": {
+ "type": "boolean",
+ "description": "Whether this team is on an enterprise license. Enterprise teams are\nbilled out-of-band; membership changes skip all Stripe subscription\nbookkeeping (no seat counts, no subscription backfill, no paying check)."
+ },
"id": {
"type": "string",
"format": "uuid"
diff --git a/crates/macro_db_client/migrations/20260715190633_add_team_enterprise.sql b/crates/macro_db_client/migrations/20260715190633_add_team_enterprise.sql
new file mode 100644
index 0000000000..43383dbc7a
--- /dev/null
+++ b/crates/macro_db_client/migrations/20260715190633_add_team_enterprise.sql
@@ -0,0 +1,4 @@
+-- Enterprise teams are billed out-of-band; membership changes skip all
+-- Stripe subscription bookkeeping for them.
+ALTER TABLE team
+ ADD COLUMN enterprise BOOLEAN NOT NULL DEFAULT FALSE;
diff --git a/crates/teams/src/domain/model.rs b/crates/teams/src/domain/model.rs
index 7e22aeca56..6d2c8f9c76 100644
--- a/crates/teams/src/domain/model.rs
+++ b/crates/teams/src/domain/model.rs
@@ -330,6 +330,10 @@ pub struct Team {
/// The email domain new users are automatically joined to this team
/// with, when automatic domain joining is enabled (None otherwise).
pub(crate) auto_join_domain: Option<String>,
+ /// Whether this team is on an enterprise license. Enterprise teams are
+ /// billed out-of-band; membership changes skip all Stripe subscription
+ /// bookkeeping (no seat counts, no subscription backfill, no paying check).
+ pub(crate) enterprise: bool,
}
impl Team {
@@ -341,6 +345,7 @@ impl Team {
slug: String,
owner_id: MacroUserIdStr<'static>,
crm_enabled: bool,
+ enterprise: bool,
) -> Self {
Self {
id,
@@ -349,6 +354,7 @@ impl Team {
owner_id,
crm_enabled,
auto_join_domain: None,
+ enterprise,
}
}
}
@@ -383,6 +389,11 @@ impl Team {
pub fn auto_join_domain(&self) -> Option<&str> {
self.auto_join_domain.as_deref()
}
+
+ /// Whether this team is on an enterprise license
+ pub fn enterprise(&self) -> bool {
+ self.enterprise
+ }
}
/// Request to create a new team
diff --git a/crates/teams/src/domain/model/test.rs b/crates/teams/src/domain/model/test.rs
index abf3440ba2..a3a76c34c7 100644
--- a/crates/teams/src/domain/model/test.rs
+++ b/crates/teams/src/domain/model/test.rs
@@ -14,6 +14,36 @@ fn assert_preserves_customer_storage_error(error: impl std::fmt::Display) {
);
}
+fn team_with_enterprise_status(enterprise: bool) -> Team {
+ Team::new(
+ uuid::Uuid::nil(),
+ "Test Team".to_string(),
+ "TEST_TEAM".to_string(),
+ MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
+ false,
+ enterprise,
+ )
+}
+
+#[test]
+fn team_enterprise_accessor_preserves_constructor_value() {
+ for enterprise in [false, true] {
+ assert_eq!(
+ team_with_enterprise_status(enterprise).enterprise(),
+ enterprise
+ );
+ }
+}
+
+#[test]
+fn serialized_team_preserves_enterprise_value() {
+ for enterprise in [false, true] {
+ let serialized = serde_json::to_value(team_with_enterprise_status(enterprise)).unwrap();
+
+ assert_eq!(serialized["enterprise"], enterprise);
+ }
+}
+
#[test]
fn invite_users_to_team_error_preserves_customer_storage_error() {
let error = InviteUsersToTeamError::from(customer_storage_error());
diff --git a/crates/teams/src/domain/team_repo.rs b/crates/teams/src/domain/team_repo.rs
index 37cd29c1ff..c710799725 100644
--- a/crates/teams/src/domain/team_repo.rs
+++ b/crates/teams/src/domain/team_repo.rs
@@ -58,6 +58,12 @@ pub trait TeamRepository: Clone + Send + Sync + 'static {
team_id: &uuid::Uuid,
) -> impl Future<Output = Result<bool, TeamError>> + Send;
+ /// Returns whether the team uses enterprise billing.
+ fn get_team_enterprise_status(
+ &self,
+ team_id: &uuid::Uuid,
+ ) -> impl Future<Output = Result<bool, TeamError>> + Send;
+
/// Creates a new team
fn create_team(
&self,
diff --git a/crates/teams/src/domain/team_service.rs b/crates/teams/src/domain/team_service.rs
index e649e926cd..4ed4ef584d 100644
--- a/crates/teams/src/domain/team_service.rs
+++ b/crates/teams/src/domain/team_service.rs
@@ -476,10 +476,16 @@ where
let team_id =
macro_uuid::string_to_uuid(&entity_access_receipt.entity().entity_id).unwrap();
- if !self
+ let enterprise = self
.team_repository
- .get_team_payment_status(&team_id)
- .await?
+ .get_team_enterprise_status(&team_id)
+ .await?;
+
+ if !enterprise
+ && !self
+ .team_repository
+ .get_team_payment_status(&team_id)
+ .await?
{
// If the team has a subscription id and they are set to not paying continue to error
if self
@@ -600,32 +606,43 @@ where
.clone()
.into_owned();
+ let enterprise = self
+ .team_repository
+ .get_team_enterprise_status(&team_id)
+ .await?;
+
let removed_member = self
.team_repository
.remove_user_from_team(&team_id, user_id)
.await?;
- let subscription_id = match self.get_team_subscription(&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(e.into_remove_user_from_team_error());
- }
+ let subscription_id = if enterprise {
+ None
+ } else {
+ let subscription_id = match self.get_team_subscription(&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(e.into_remove_user_from_team_error());
+ }
+ };
+ Some(subscription_id)
};
- if let Err(e) = self
- .customer_repository
- .decrement_seat_count(&subscription_id, 1)
- .await
+ if let Some(subscription_id) = subscription_id.as_ref()
+ && let Err(e) = self
+ .customer_repository
+ .decrement_seat_count(subscription_id, 1)
+ .await
{
self.team_repository
.rollback_remove_user_from_team(&removed_member)
@@ -645,16 +662,18 @@ where
.remove_team_member_from_channels(&team_id, user_id)
.await
{
- self.customer_repository
- .increment_seat_count(&subscription_id, 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();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .increment_seat_count(subscription_id, 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
@@ -686,16 +705,18 @@ where
);
})
.ok();
- self.customer_repository
- .increment_seat_count(&subscription_id, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after removing team member roles failed"
- );
- })
- .ok();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .increment_seat_count(subscription_id, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after removing team member roles failed"
+ );
+ })
+ .ok();
+ }
self.team_repository
.rollback_remove_user_from_team(&removed_member)
.await
@@ -841,84 +862,143 @@ where
.map_err(JoinTeamError::TeamError)?;
let team_member = accepted_invite.member.clone();
-
- if !self
+ let enterprise = match self
.team_repository
- .get_team_payment_status(&team_member.team_id)
- .await?
+ .get_team_enterprise_status(&team_member.team_id)
+ .await
{
- // If the team has a subscription id and they are set to not paying continue to error
- if self
- .team_repository
- .get_team_subscription_id(&accepted_invite.member.team_id)
- .await?
- .is_some()
- {
+ Ok(enterprise) => enterprise,
+ Err(error) => {
self.team_repository
.rollback_accept_team_invite(&accepted_invite)
.await
.inspect_err(|rollback_err| {
tracing::error!(
error=?rollback_err,
- "unable to rollback accepted team invite after getting team subscription failed"
+ "unable to rollback accepted team invite after getting enterprise status failed"
);
})
.ok();
- return Err(JoinTeamError::TeamError(TeamError::TeamNotPaying));
+ return Err(JoinTeamError::TeamError(error));
}
+ };
- if let Err(e) = self
- .backfill_legacy_team_subscription(&accepted_invite.member.team_id)
+ let subscription_id = if enterprise {
+ None
+ } else {
+ let team_payment_status = match self
+ .team_repository
+ .get_team_payment_status(&team_member.team_id)
.await
{
- self.team_repository
- .rollback_accept_team_invite(&accepted_invite)
+ Ok(team_payment_status) => team_payment_status,
+ Err(error) => {
+ self.team_repository
+ .rollback_accept_team_invite(&accepted_invite)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback accepted team invite after getting team payment status failed"
+ );
+ })
+ .ok();
+ return Err(JoinTeamError::TeamError(error));
+ }
+ };
+
+ if !team_payment_status {
+ // If the team has a subscription id and they are set to not paying continue to error
+ let team_subscription_id = match self
+ .team_repository
+ .get_team_subscription_id(&accepted_invite.member.team_id)
.await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback accepted team invite after backfilling team subscription failed"
- );
- })
- .ok();
- return Err(e.into_join_team_error());
+ {
+ Ok(team_subscription_id) => team_subscription_id,
+ Err(error) => {
+ self.team_repository
+ .rollback_accept_team_invite(&accepted_invite)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback accepted team invite after getting team subscription failed"
+ );
+ })
+ .ok();
+ return Err(JoinTeamError::TeamError(error));
+ }
+ };
+
+ if team_subscription_id.is_some() {
+ self.team_repository
+ .rollback_accept_team_invite(&accepted_invite)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback accepted team invite after getting team subscription failed"
+ );
+ })
+ .ok();
+ return Err(JoinTeamError::TeamError(TeamError::TeamNotPaying));
+ }
+
+ if let Err(e) = self
+ .backfill_legacy_team_subscription(&accepted_invite.member.team_id)
+ .await
+ {
+ self.team_repository
+ .rollback_accept_team_invite(&accepted_invite)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback accepted team invite after backfilling team subscription failed"
+ );
+ })
+ .ok();
+ return Err(e.into_join_team_error());
+ }
}
- }
- let subscription_id = match self.get_team_subscription(&team_member.team_id).await {
- Ok(subscription_id) => subscription_id,
- Err(e) => {
+ let subscription_id = match self.get_team_subscription(&team_member.team_id).await {
+ Ok(subscription_id) => subscription_id,
+ Err(e) => {
+ self.team_repository
+ .rollback_accept_team_invite(&accepted_invite)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback accepted team invite after getting team subscription failed"
+ );
+ })
+ .ok();
+ return Err(e.into_join_team_error());
+ }
+ };
+
+ if let Err(e) = self
+ .customer_repository
+ .increment_seat_count(&subscription_id, 1)
+ .await
+ {
self.team_repository
.rollback_accept_team_invite(&accepted_invite)
.await
.inspect_err(|rollback_err| {
tracing::error!(
error=?rollback_err,
- "unable to rollback accepted team invite after getting team subscription failed"
+ "unable to rollback accepted team invite after incrementing seat count failed"
);
})
.ok();
- return Err(e.into_join_team_error());
+ return Err(JoinTeamError::CustomerError(e));
}
- };
- if let Err(e) = self
- .customer_repository
- .increment_seat_count(&subscription_id, 1)
- .await
- {
- self.team_repository
- .rollback_accept_team_invite(&accepted_invite)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback accepted team invite after incrementing seat count failed"
- );
- })
- .ok();
- return Err(JoinTeamError::CustomerError(e));
- }
+ Some(subscription_id)
+ };
// subscribe the user to professional features from the TeamSubscriber role and the role associated with their tier
let roles_to_add = vec![RoleId::TeamSubscriber, RoleId::SubOpus];
@@ -929,16 +1009,18 @@ where
.dangerous_upsert_roles_for_user(user_id, roles)
.await
{
- self.customer_repository
- .decrement_seat_count(&subscription_id, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after adding team member roles failed"
- );
- })
- .ok();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .decrement_seat_count(subscription_id, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after adding team member roles failed"
+ );
+ })
+ .ok();
+ }
self.team_repository
.rollback_accept_team_invite(&accepted_invite)
.await
@@ -968,16 +1050,18 @@ where
);
})
.ok();
- self.customer_repository
- .decrement_seat_count(&subscription_id, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after adding team member to channels failed"
- );
- })
- .ok();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .decrement_seat_count(subscription_id, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after adding team member to channels failed"
+ );
+ })
+ .ok();
+ }
self.team_repository
.rollback_accept_team_invite(&accepted_invite)
.await
@@ -1282,6 +1366,11 @@ where
return Ok(None);
};
+ let enterprise = self
+ .team_repository
+ .get_team_enterprise_status(&team_id)
+ .await?;
+
// Mirror the seat-cap check from invite_users_to_team — an
// auto-join must not push the team past its plan's seat cap.
if let Some(team_plan) = self.team_repository.get_team_plan(&team_id).await? {
@@ -1304,48 +1393,80 @@ where
return Ok(None);
};
- if !self
- .team_repository
- .get_team_payment_status(&team_id)
- .await?
- {
- // If the team has a subscription id and they are set to not paying continue to error
- if self
- .team_repository
- .get_team_subscription_id(&team_id)
- .await?
- .is_some()
- {
- self.rollback_add_user_to_team(&team_id, user_id, "the payment status check")
- .await;
- return Err(JoinTeamError::TeamError(TeamError::TeamNotPaying).into());
- }
+ let subscription_id = if enterprise {
+ None
+ } else {
+ let team_payment_status =
+ match self.team_repository.get_team_payment_status(&team_id).await {
+ Ok(team_payment_status) => team_payment_status,
+ Err(error) => {
+ self.rollback_add_user_to_team(
+ &team_id,
+ user_id,
+ "getting team payment status",
+ )
+ .await;
+ return Err(error.into());
+ }
+ };
- if let Err(e) = self.backfill_legacy_team_subscription(&team_id).await {
- self.rollback_add_user_to_team(&team_id, user_id, "backfilling team subscription")
+ if !team_payment_status {
+ // If the team has a subscription id and they are set to not paying continue to error
+ let team_subscription_id = match self
+ .team_repository
+ .get_team_subscription_id(&team_id)
+ .await
+ {
+ Ok(team_subscription_id) => team_subscription_id,
+ Err(error) => {
+ self.rollback_add_user_to_team(
+ &team_id,
+ user_id,
+ "getting team subscription id",
+ )
+ .await;
+ return Err(error.into());
+ }
+ };
+
+ if team_subscription_id.is_some() {
+ self.rollback_add_user_to_team(&team_id, user_id, "the payment status check")
+ .await;
+ return Err(JoinTeamError::TeamError(TeamError::TeamNotPaying).into());
+ }
+
+ if let Err(e) = self.backfill_legacy_team_subscription(&team_id).await {
+ self.rollback_add_user_to_team(
+ &team_id,
+ user_id,
+ "backfilling team subscription",
+ )
.await;
- return Err(e.into_join_team_error().into());
+ return Err(e.into_join_team_error().into());
+ }
}
- }
- let subscription_id = match self.get_team_subscription(&team_id).await {
- Ok(subscription_id) => subscription_id,
- Err(e) => {
- self.rollback_add_user_to_team(&team_id, user_id, "getting team subscription")
+ let subscription_id = match self.get_team_subscription(&team_id).await {
+ Ok(subscription_id) => subscription_id,
+ Err(e) => {
+ self.rollback_add_user_to_team(&team_id, user_id, "getting team subscription")
+ .await;
+ return Err(e.into_join_team_error().into());
+ }
+ };
+
+ if let Err(e) = self
+ .customer_repository
+ .increment_seat_count(&subscription_id, 1)
+ .await
+ {
+ self.rollback_add_user_to_team(&team_id, user_id, "incrementing seat count")
.await;
- return Err(e.into_join_team_error().into());
+ return Err(JoinTeamError::CustomerError(e).into());
}
- };
- if let Err(e) = self
- .customer_repository
- .increment_seat_count(&subscription_id, 1)
- .await
- {
- self.rollback_add_user_to_team(&team_id, user_id, "incrementing seat count")
- .await;
- return Err(JoinTeamError::CustomerError(e).into());
- }
+ Some(subscription_id)
+ };
// subscribe the user to professional features from the TeamSubscriber role and the role associated with their tier
let roles_to_add = vec![RoleId::TeamSubscriber, RoleId::SubOpus];
@@ -1356,16 +1477,18 @@ where
.dangerous_upsert_roles_for_user(user_id, roles)
.await
{
- self.customer_repository
- .decrement_seat_count(&subscription_id, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after adding team member roles failed"
- );
- })
- .ok();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .decrement_seat_count(subscription_id, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after adding team member roles failed"
+ );
+ })
+ .ok();
+ }
self.rollback_add_user_to_team(&team_id, user_id, "adding team member roles")
.await;
return Err(JoinTeamError::AddRolesToUserError(e).into());
@@ -1387,16 +1510,18 @@ where
);
})
.ok();
- self.customer_repository
- .decrement_seat_count(&subscription_id, 1)
- .await
- .inspect_err(|rollback_err| {
- tracing::error!(
- error=?rollback_err,
- "unable to rollback customer seat count after adding team member to channels failed"
- );
- })
- .ok();
+ if let Some(subscription_id) = subscription_id.as_ref() {
+ self.customer_repository
+ .decrement_seat_count(subscription_id, 1)
+ .await
+ .inspect_err(|rollback_err| {
+ tracing::error!(
+ error=?rollback_err,
+ "unable to rollback customer seat count after adding team member to channels failed"
+ );
+ })
+ .ok();
+ }
self.rollback_add_user_to_team(&team_id, user_id, "adding team member to channels")
.await;
return Err(JoinTeamError::TeamError(e).into());
diff --git a/crates/teams/src/domain/team_service/test.rs b/crates/teams/src/domain/team_service/test.rs
index bcf8780c78..b23a192866 100644
--- a/crates/teams/src/domain/team_service/test.rs
+++ b/crates/teams/src/domain/team_service/test.rs
@@ -58,9 +58,17 @@ struct MockTeamRepository {
mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>>,
team_for_get_by_id: Option<Team>,
team_subscription_id: Option<stripe::SubscriptionId>,
+ team_subscription_id_lookup_calls: Arc<Mutex<usize>>,
+ fail_team_subscription_id_lookup: bool,
backfilled_subscription_id: Arc<Mutex<Option<stripe::SubscriptionId>>>,
stripe_customer_id: Option<stripe::CustomerId>,
+ stripe_customer_id_lookup_calls: Arc<Mutex<usize>>,
team_payment_status: bool,
+ team_payment_status_lookup_calls: Arc<Mutex<usize>>,
+ fail_team_payment_status_lookup: bool,
+ enterprise: bool,
+ enterprise_status_lookup_calls: Arc<Mutex<usize>>,
+ fail_enterprise_status_lookup: bool,
team_members: Vec<TeamMember<'static>>,
accepted_invite: Option<AcceptedTeamInvite<'static>>,
removed_member: Option<TeamMember<'static>>,
@@ -76,10 +84,13 @@ struct MockTeamRepository {
payment_update_calls: Arc<Mutex<Vec<(uuid::Uuid, bool)>>>,
fail_github_installation_move: bool,
fail_invite_users_to_team: bool,
+ invite_users_to_team_calls: Arc<Mutex<usize>>,
+ get_team_by_id_calls: Arc<Mutex<usize>>,
team_id_for_domain: Option<uuid::Uuid>,
team_plan: Option<TeamPlan>,
seat_count: i32,
add_user_to_team_result: Option<TeamMember<'static>>,
+ add_user_to_team_calls: Arc<Mutex<usize>>,
remove_user_calls: Arc<Mutex<usize>>,
}
@@ -95,9 +106,17 @@ impl MockTeamRepository {
mark_sent_calls,
team_for_get_by_id: None,
team_subscription_id: None,
+ team_subscription_id_lookup_calls: Arc::new(Mutex::new(0)),
+ fail_team_subscription_id_lookup: false,
backfilled_subscription_id: Arc::new(Mutex::new(None)),
stripe_customer_id: None,
+ stripe_customer_id_lookup_calls: Arc::new(Mutex::new(0)),
team_payment_status: true,
+ team_payment_status_lookup_calls: Arc::new(Mutex::new(0)),
+ fail_team_payment_status_lookup: false,
+ enterprise: false,
+ enterprise_status_lookup_calls: Arc::new(Mutex::new(0)),
+ fail_enterprise_status_lookup: false,
team_members: Vec::new(),
accepted_invite: None,
removed_member: None,
@@ -115,16 +134,20 @@ impl MockTeamRepository {
.unwrap()
.into_owned(),
false,
+ false,
),
github_installation_move_calls: Arc::new(Mutex::new(Vec::new())),
subscription_update_calls: Arc::new(Mutex::new(Vec::new())),
payment_update_calls: Arc::new(Mutex::new(Vec::new())),
fail_github_installation_move: false,
fail_invite_users_to_team: false,
+ invite_users_to_team_calls: Arc::new(Mutex::new(0)),
+ get_team_by_id_calls: Arc::new(Mutex::new(0)),
team_id_for_domain: None,
team_plan: None,
seat_count: 0,
add_user_to_team_result: None,
+ add_user_to_team_calls: Arc::new(Mutex::new(0)),
remove_user_calls: Arc::new(Mutex::new(0)),
}
}
@@ -134,6 +157,11 @@ impl MockTeamRepository {
self
}
+ fn with_enterprise(mut self, enterprise: bool) -> Self {
+ self.enterprise = enterprise;
+ self
+ }
+
fn with_team_members(mut self, members: Vec<TeamMember<'static>>) -> Self {
self.team_members = members;
self
@@ -145,6 +173,7 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &MacroUserIdStr<'_>,
) -> impl Future<Output = Result<Option<stripe::CustomerId>, TeamError>> + Send {
+ *self.stripe_customer_id_lookup_calls.lock().unwrap() += 1;
let customer_id = self.stripe_customer_id.clone();
async move { Ok(customer_id) }
}
@@ -153,21 +182,59 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &uuid::Uuid,
) -> impl Future<Output = Result<Option<stripe::SubscriptionId>, TeamError>> + Send {
+ *self.team_subscription_id_lookup_calls.lock().unwrap() += 1;
let subscription_id = self
.backfilled_subscription_id
.lock()
.unwrap()
.clone()
.or_else(|| self.team_subscription_id.clone());
- async move { Ok(subscription_id) }
+ let fail = self.fail_team_subscription_id_lookup;
+ async move {
+ if fail {
+ Err(TeamError::StorageLayerError(anyhow::anyhow!(
+ "team subscription id lookup failed"
+ )))
+ } else {
+ Ok(subscription_id)
+ }
+ }
}
fn get_team_payment_status(
&self,
_: &uuid::Uuid,
) -> impl Future<Output = Result<bool, TeamError>> + Send {
+ *self.team_payment_status_lookup_calls.lock().unwrap() += 1;
let team_payment_status = self.team_payment_status;
- async move { Ok(team_payment_status) }
+ let fail = self.fail_team_payment_status_lookup;
+ async move {
+ if fail {
+ Err(TeamError::StorageLayerError(anyhow::anyhow!(
+ "team payment status lookup failed"
+ )))
+ } else {
+ Ok(team_payment_status)
+ }
+ }
+ }
+
+ fn get_team_enterprise_status(
+ &self,
+ _: &uuid::Uuid,
+ ) -> impl Future<Output = Result<bool, TeamError>> + Send {
+ *self.enterprise_status_lookup_calls.lock().unwrap() += 1;
+ let enterprise = self.enterprise;
+ let fail = self.fail_enterprise_status_lookup;
+ async move {
+ if fail {
+ Err(TeamError::StorageLayerError(anyhow::anyhow!(
+ "enterprise status lookup failed"
+ )))
+ } else {
+ Ok(enterprise)
+ }
+ }
}
fn has_user_trialed(
@@ -214,6 +281,7 @@ impl TeamRepository for MockTeamRepository {
_: &MacroUserIdStr<'_>,
_: non_empty::NonEmpty<&[Email<Lowercase<'_>>]>,
) -> impl Future<Output = Result<Vec<TeamInvite<'_>>, InviteUsersToTeamError>> + Send {
+ *self.invite_users_to_team_calls.lock().unwrap() += 1;
let invites = self.invites_to_return.clone();
let fail = self.fail_invite_users_to_team;
async move {
@@ -387,6 +455,7 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &uuid::Uuid,
) -> impl Future<Output = Result<TeamWithMembers, TeamError>> + Send {
+ *self.get_team_by_id_calls.lock().unwrap() += 1;
let team = self.team_for_get_by_id.clone();
async move {
let team = team.ok_or(TeamError::TeamDoesNotExist)?;
@@ -513,6 +582,7 @@ impl TeamRepository for MockTeamRepository {
_: &uuid::Uuid,
_: &MacroUserIdStr<'_>,
) -> impl Future<Output = Result<Option<TeamMember<'static>>, TeamError>> + Send {
+ *self.add_user_to_team_calls.lock().unwrap() += 1;
let member = self.add_user_to_team_result.clone();
async move { Ok(member) }
}
@@ -526,6 +596,7 @@ struct MockCustomerRepository {
increment_calls: Arc<Mutex<Vec<(String, u64)>>>,
decrement_calls: Arc<Mutex<Vec<(String, u64)>>>,
convert_calls: Arc<Mutex<Vec<(String, uuid::Uuid, String)>>>,
+ subscription_lookup_calls: Arc<Mutex<usize>>,
fail_increment: bool,
fail_decrement: bool,
no_active_subscription: bool,
@@ -538,6 +609,7 @@ impl Default for MockCustomerRepository {
increment_calls: Arc::new(Mutex::new(Vec::new())),
decrement_calls: Arc::new(Mutex::new(Vec::new())),
convert_calls: Arc::new(Mutex::new(Vec::new())),
+ subscription_lookup_calls: Arc::new(Mutex::new(0)),
fail_increment: false,
fail_decrement: false,
no_active_subscription: false,
@@ -564,6 +636,7 @@ impl CustomerRepository for MockCustomerRepository {
&self,
_: &stripe::CustomerId,
) -> impl Future<Output = Result<stripe::SubscriptionId, CustomerError>> + Send {
+ *self.subscription_lookup_calls.lock().unwrap() += 1;
let no_active_subscription = self.no_active_subscription;
let subscription_id = self.subscription_id.clone();
async move {
@@ -894,6 +967,143 @@ fn make_accepted_invite(
}
}
+fn make_enterprise_join_team_repository(
+ team_id: uuid::Uuid,
+ invite_id: uuid::Uuid,
+ user_id: &MacroUserIdStr<'_>,
+) -> MockTeamRepository {
+ let mark_sent_calls = Arc::new(Mutex::new(Vec::new()));
+ let mut team_repository =
+ MockTeamRepository::new(Vec::new(), "Enterprise Team", mark_sent_calls)
+ .with_enterprise(true);
+ team_repository.team_payment_status = false;
+ team_repository.team_subscription_id = Some("sub_enterprise_sentinel".parse().unwrap());
+ team_repository.accepted_invite = Some(make_accepted_invite(team_id, invite_id, user_id));
+ team_repository
+}
+
+fn make_enterprise_domain_join_team_repository(
+ team_id: uuid::Uuid,
+ user_id: &MacroUserIdStr<'_>,
+) -> MockTeamRepository {
+ let mark_sent_calls = Arc::new(Mutex::new(Vec::new()));
+ let member = TeamMember {
+ team_id,
+ user_id: user_id.clone().into_owned(),
+ role: TeamRole::Member,
+ };
+ let mut team_repository =
+ MockTeamRepository::new(Vec::new(), "Enterprise Team", mark_sent_calls)
+ .with_enterprise(true);
+ team_repository.team_id_for_domain = Some(team_id);
+ team_repository.team_payment_status = false;
+ team_repository.team_subscription_id = Some("sub_enterprise_sentinel".parse().unwrap());
+ team_repository.stripe_customer_id = Some("cus_enterprise_sentinel".parse().unwrap());
+ team_repository.add_user_to_team_result = Some(member.clone());
+ team_repository.removed_member = Some(member);
+ team_repository
+}
+
+fn make_enterprise_remove_user_repository(
+ team_id: uuid::Uuid,
+ user_id: &MacroUserIdStr<'_>,
+ role: TeamRole,
+) -> MockTeamRepository {
+ let mark_sent_calls = Arc::new(Mutex::new(Vec::new()));
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team = Team::new(
+ team_id,
+ "Enterprise Team".to_string(),
+ "ENTERPRISE_TEAM".to_string(),
+ owner_id.into_owned(),
+ false,
+ true,
+ );
+ let mut team_repository =
+ MockTeamRepository::new(Vec::new(), "Enterprise Team", mark_sent_calls)
+ .with_enterprise(true)
+ .with_team(team);
+ team_repository.team_payment_status = false;
+ team_repository.stripe_customer_id = Some("cus_enterprise_sentinel".parse().unwrap());
+ team_repository.removed_member = Some(TeamMember {
+ team_id,
+ user_id: user_id.clone().into_owned(),
+ role,
+ });
+ team_repository
+}
+
+fn assert_no_enterprise_join_team_billing_calls(
+ team_repository: &MockTeamRepository,
+ customer_repository: &MockCustomerRepository,
+) {
+ assert_eq!(
+ *team_repository
+ .team_payment_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 0
+ );
+ assert_eq!(
+ *team_repository
+ .team_subscription_id_lookup_calls
+ .lock()
+ .unwrap(),
+ 0
+ );
+ assert_eq!(
+ *team_repository
+ .stripe_customer_id_lookup_calls
+ .lock()
+ .unwrap(),
+ 0
+ );
+ assert!(
+ team_repository
+ .subscription_update_calls
+ .lock()
+ .unwrap()
+ .is_empty()
+ );
+ assert!(
+ team_repository
+ .payment_update_calls
+ .lock()
+ .unwrap()
+ .is_empty()
+ );
+ assert_eq!(
+ *customer_repository
+ .subscription_lookup_calls
+ .lock()
+ .unwrap(),
+ 0
+ );
+ assert!(customer_repository.convert_calls.lock().unwrap().is_empty());
+ assert!(
+ customer_repository
+ .increment_calls
+ .lock()
+ .unwrap()
+ .is_empty()
+ );
+ assert!(
+ customer_repository
+ .decrement_calls
+ .lock()
+ .unwrap()
+ .is_empty()
+ );
+}
+
+fn assert_no_enterprise_remove_user_billing_calls(
+ team_repository: &MockTeamRepository,
+ customer_repository: &MockCustomerRepository,
+) {
+ assert_no_enterprise_join_team_billing_calls(team_repository, customer_repository);
+ assert_eq!(*team_repository.get_team_by_id_calls.lock().unwrap(), 0);
+}
+
fn build_service(
invites: Vec<TeamInvite<'static>>,
fail_indices: HashSet<usize>,
@@ -1054,6 +1264,7 @@ async fn test_create_team_moves_github_installation_to_created_team() {
"NEW_TEAM".to_string(),
user_id.clone().into_owned(),
false,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
let mut team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
@@ -1091,6 +1302,7 @@ async fn test_create_team_propagates_github_installation_move_failure() {
"NEW_TEAM".to_string(),
user_id.clone().into_owned(),
false,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
let mut team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
@@ -1131,6 +1343,7 @@ async fn team_analytics_create_team_emits_created_event_with_team_id() {
"ANALYTICS_TEAM".to_string(),
user_id.clone().into_owned(),
false,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
let mut team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
@@ -1176,6 +1389,7 @@ async fn team_analytics_failure_is_swallowed_by_create_team() {
"ANALYTICS_TEAM".to_string(),
user_id.clone().into_owned(),
false,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
let mut team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
@@ -1207,6 +1421,7 @@ async fn team_analytics_create_team_does_not_emit_when_side_effect_fails() {
"ANALYTICS_TEAM".to_string(),
user_id.clone().into_owned(),
false,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
let mut team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
@@ -1277,6 +1492,203 @@ async fn test_is_user_premium_without_active_subscription() {
assert!(service.is_user_premium(&user_id).await.unwrap().is_none());
}
+#[tokio::test]
+async fn invite_users_to_team_enterprise_bypasses_billing_and_preserves_side_effects() {
+ let team_id = uuid::Uuid::from_u128(6000);
+ let invite_id = uuid::Uuid::from_u128(6001);
+ 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)],
+ "Enterprise Team",
+ mark_sent_calls.clone(),
+ )
+ .with_enterprise(true);
+ team_repo.team_payment_status = false;
+ team_repo.team_subscription_id = Some("sub_enterprise_sentinel".parse().unwrap());
+ team_repo.stripe_customer_id = Some("cus_enterprise_sentinel".parse().unwrap());
+ team_repo.team_plan = Some(TeamPlan::Idea);
+ team_repo.seat_count = TeamPlan::Idea.seat_cap() - 1;
+
+ let enterprise_status_lookup_calls = team_repo.enterprise_status_lookup_calls.clone();
+ let payment_status_lookup_calls = team_repo.team_payment_status_lookup_calls.clone();
+ let subscription_id_lookup_calls = team_repo.team_subscription_id_lookup_calls.clone();
+ let stripe_customer_id_lookup_calls = team_repo.stripe_customer_id_lookup_calls.clone();
+ let get_team_by_id_calls = team_repo.get_team_by_id_calls.clone();
+ let invitation_persistence_calls = team_repo.invite_users_to_team_calls.clone();
+ let subscription_update_calls = team_repo.subscription_update_calls.clone();
+ let payment_update_calls = team_repo.payment_update_calls.clone();
+
+ let customer_repo = MockCustomerRepository::default();
+ let customer_subscription_lookup_calls = customer_repo.subscription_lookup_calls.clone();
+ let convert_calls = customer_repo.convert_calls.clone();
+ let increment_calls = customer_repo.increment_calls.clone();
+ let decrement_calls = customer_repo.decrement_calls.clone();
+ let notification_ingress = Arc::new(MockNotificationIngress::new(HashSet::new()));
+ let analytics_events = Arc::new(Mutex::new(Vec::new()));
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repo,
+ customer_repo,
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ notification_ingress.clone(),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(analytics_events.clone()),
+ );
+
+ let invite_emails = vec![
+ Email::parse_from_str("[email protected]")
+ .unwrap()
+ .lowercase(),
+ ];
+ let invites = non_empty::NonEmpty::new(invite_emails.as_slice()).unwrap();
+ let receipt = test_team_receipt::<AdminTeamRole>(team_id, &invited_by);
+
+ let result = service
+ .invite_users_to_team(receipt, invites)
+ .await
+ .unwrap();
+
+ assert_eq!(result.len(), 1);
+ assert_eq!(result[0].team_invite_id, invite_id);
+ assert_eq!(*enterprise_status_lookup_calls.lock().unwrap(), 1);
+ assert_eq!(*payment_status_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*subscription_id_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*stripe_customer_id_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*get_team_by_id_calls.lock().unwrap(), 0);
+ assert_eq!(*customer_subscription_lookup_calls.lock().unwrap(), 0);
+ assert!(convert_calls.lock().unwrap().is_empty());
+ assert!(subscription_update_calls.lock().unwrap().is_empty());
+ assert!(payment_update_calls.lock().unwrap().is_empty());
+ assert!(increment_calls.lock().unwrap().is_empty());
+ assert!(decrement_calls.lock().unwrap().is_empty());
+
+ assert_eq!(*invitation_persistence_calls.lock().unwrap(), 1);
+ assert_eq!(notification_ingress.call_count.load(Ordering::SeqCst), 1);
+ assert_eq!(*mark_sent_calls.lock().unwrap(), vec![vec![invite_id]]);
+
+ let events = analytics_events.lock().unwrap();
+ assert_eq!(events.len(), 1);
+ match &events[0] {
+ TeamAnalyticsEvent::TeamInvited {
+ team_id: event_team_id,
+ team_invite_id,
+ inviter_id,
+ team_name,
+ } => {
+ assert_eq!(*event_team_id, team_id);
+ assert_eq!(*team_invite_id, invite_id);
+ assert_eq!(inviter_id.as_ref(), invited_by.as_ref());
+ assert_eq!(team_name.as_deref(), Some("Enterprise Team"));
+ }
+ event => panic!("unexpected event: {event:?}"),
+ }
+}
+
+#[tokio::test]
+async fn invite_users_to_team_enterprise_enforces_team_plan_seat_cap() {
+ let team_id = uuid::Uuid::from_u128(6010);
+ let invite_id = uuid::Uuid::from_u128(6011);
+ 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)],
+ "Enterprise Team",
+ mark_sent_calls.clone(),
+ )
+ .with_enterprise(true);
+ team_repo.team_payment_status = false;
+ team_repo.team_subscription_id = Some("sub_enterprise_sentinel".parse().unwrap());
+ team_repo.team_plan = Some(TeamPlan::Idea);
+ team_repo.seat_count = TeamPlan::Idea.seat_cap();
+
+ let payment_status_lookup_calls = team_repo.team_payment_status_lookup_calls.clone();
+ let subscription_id_lookup_calls = team_repo.team_subscription_id_lookup_calls.clone();
+ let invitation_persistence_calls = team_repo.invite_users_to_team_calls.clone();
+ let notification_ingress = Arc::new(MockNotificationIngress::new(HashSet::new()));
+ let analytics_events = Arc::new(Mutex::new(Vec::new()));
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repo,
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ notification_ingress.clone(),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(analytics_events.clone()),
+ );
+
+ let invite_emails = vec![
+ Email::parse_from_str("[email protected]")
+ .unwrap()
+ .lowercase(),
+ ];
+ let invites = non_empty::NonEmpty::new(invite_emails.as_slice()).unwrap();
+ let receipt = test_team_receipt::<AdminTeamRole>(team_id, &invited_by);
+
+ let error = service
+ .invite_users_to_team(receipt, invites)
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, InviteUsersToTeamError::NotEnoughOpenSeats));
+ assert_eq!(*payment_status_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*subscription_id_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*invitation_persistence_calls.lock().unwrap(), 0);
+ assert_eq!(notification_ingress.call_count.load(Ordering::SeqCst), 0);
+ assert!(mark_sent_calls.lock().unwrap().is_empty());
+ assert!(analytics_events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn invite_users_to_team_enterprise_status_lookup_failure_precedes_persistence() {
+ let team_id = uuid::Uuid::from_u128(6020);
+ let invite_id = uuid::Uuid::from_u128(6021);
+ 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)],
+ "Enterprise Team",
+ mark_sent_calls,
+ );
+ team_repo.fail_enterprise_status_lookup = true;
+
+ let enterprise_status_lookup_calls = team_repo.enterprise_status_lookup_calls.clone();
+ let payment_status_lookup_calls = team_repo.team_payment_status_lookup_calls.clone();
+ let invitation_persistence_calls = team_repo.invite_users_to_team_calls.clone();
+ let service = TeamServiceImpl::new(
+ team_repo,
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ let invite_emails = vec![
+ Email::parse_from_str("[email protected]")
+ .unwrap()
+ .lowercase(),
+ ];
+ let invites = non_empty::NonEmpty::new(invite_emails.as_slice()).unwrap();
+ let receipt = test_team_receipt::<AdminTeamRole>(team_id, &invited_by);
+
+ let error = service
+ .invite_users_to_team(receipt, invites)
+ .await
+ .unwrap_err();
+
+ assert!(matches!(
+ error,
+ InviteUsersToTeamError::TeamError(TeamError::StorageLayerError(_))
+ ));
+ assert_eq!(*enterprise_status_lookup_calls.lock().unwrap(), 1);
+ assert_eq!(*payment_status_lookup_calls.lock().unwrap(), 0);
+ assert_eq!(*invitation_persistence_calls.lock().unwrap(), 0);
+}
+
/// When one notification fails, only the successful invite IDs are passed to
/// mark_invites_sent.
#[tokio::test]
@@ -1519,6 +1931,7 @@ async fn test_get_team_reports_crm_enabled() {
"TEST_TEAM".to_string(),
owner_id.clone(),
true,
+ false,
);
let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
@@ -1540,10 +1953,11 @@ async fn test_get_team_reports_crm_enabled() {
assert!(team.team.crm_enabled());
}
-/// CrmEnqueuer that records which users had a populate enqueued.
+/// CrmEnqueuer that records which users had a populate or depopulate enqueued.
#[derive(Clone, Default)]
struct RecordingCrmEnqueuer {
populated: Arc<Mutex<Vec<String>>>,
+ depopulated: Arc<Mutex<Vec<(uuid::Uuid, String)>>>,
}
impl CrmEnqueuer for RecordingCrmEnqueuer {
@@ -1562,9 +1976,13 @@ impl CrmEnqueuer for RecordingCrmEnqueuer {
async fn enqueue_depopulate_crm_for_user(
&self,
- _: &uuid::Uuid,
- _: &MacroUserIdStr<'_>,
+ team_id: &uuid::Uuid,
+ macro_id: &MacroUserIdStr<'_>,
) -> Result<(), Self::Err> {
+ self.depopulated
+ .lock()
+ .unwrap()
+ .push((*team_id, macro_id.as_ref().to_string()));
Ok(())
}
}
@@ -1690,6 +2108,7 @@ async fn test_patch_team_rejects_owner_role_assignment() {
"TEST_TEAM".to_string(),
owner_id,
false,
+ false,
);
let (service, role_calls, name_calls) = build_service_with_team(team);
@@ -1728,6 +2147,7 @@ async fn test_patch_team_rejects_owner_downgrade() {
"TEST_TEAM".to_string(),
owner_id.clone(),
false,
+ false,
);
let (service, role_calls, name_calls) = build_service_with_team(team);
@@ -1767,6 +2187,7 @@ async fn test_patch_team_applies_role_updates_and_name() {
"OLD_NAME".to_string(),
owner_id.clone(),
false,
+ false,
);
let (service, role_calls, name_calls) = build_service_with_team(team);
@@ -1825,6 +2246,7 @@ async fn test_patch_team_empty_role_updates() {
"OLD_NAME".to_string(),
owner_id.clone(),
false,
+ false,
);
let (service, role_calls, name_calls) = build_service_with_team(team);
@@ -1863,6 +2285,7 @@ async fn test_invite_users_to_team_backfills_legacy_team_subscription() {
"legacy-team".to_string(),
owner_id.clone().into_owned(),
false,
+ false,
));
team_repo.team_payment_status = false;
team_repo.team_subscription_id = None;
@@ -1916,58 +2339,308 @@ async fn test_invite_users_to_team_backfills_legacy_team_subscription() {
}
#[tokio::test]
-async fn test_join_team_backfills_legacy_team_subscription() {
- let team_id = uuid::Uuid::from_u128(43);
- let invite_id = uuid::Uuid::from_u128(430);
- let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+async fn join_team_enterprise_bypasses_billing_and_preserves_membership_side_effects() {
+ let team_id = uuid::Uuid::from_u128(45);
+ let invite_id = uuid::Uuid::from_u128(450);
let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
- let subscription_id: stripe::SubscriptionId = "sub_backfill_join".parse().unwrap();
-
- let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
- let mut team_repo = MockTeamRepository::new(Vec::new(), "Legacy Team", mark_sent_calls)
- .with_team(Team::new(
- team_id,
- "Legacy Team".to_string(),
- "legacy-team".to_string(),
- owner_id.clone().into_owned(),
- false,
- ));
- team_repo.team_payment_status = false;
- team_repo.team_subscription_id = None;
- team_repo.stripe_customer_id = Some("cus_backfill_join".parse().unwrap());
- team_repo.accepted_invite = Some(make_accepted_invite(team_id, invite_id, &user_id));
- let subscription_update_calls = team_repo.subscription_update_calls.clone();
- let payment_update_calls = team_repo.payment_update_calls.clone();
-
- let customer_repo = MockCustomerRepository {
- subscription_id: subscription_id.clone(),
- ..Default::default()
- };
- let convert_calls = customer_repo.convert_calls.clone();
- let increment_calls = customer_repo.increment_calls.clone();
+ let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
- let service = TeamServiceImpl::new(
- team_repo,
- customer_repo,
- MockTeamChannelsRepository::default(),
- MockUserRolesAndPermissionsService::default(),
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
Arc::new(MockNotificationIngress::new(HashSet::new())),
- NoOpCrmEnqueuer,
+ crm_enqueuer.clone(),
NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
);
- service.join_team(&invite_id, &user_id).await.unwrap();
+ let member = service.join_team(&invite_id, &user_id).await.unwrap();
- assert!(convert_calls.lock().unwrap().contains(&(
- subscription_id.to_string(),
- team_id,
- owner_id.as_ref().to_string()
- )));
+ assert_eq!(member.team_id, team_id);
+ assert_eq!(member.user_id, user_id);
assert_eq!(
- *subscription_update_calls.lock().unwrap(),
- vec![(team_id, subscription_id.to_string())]
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
);
- assert_eq!(*payment_update_calls.lock().unwrap(), vec![(team_id, true)]);
+ assert_eq!(*team_repository.rollback_accept_calls.lock().unwrap(), 0);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(
+ *roles_service.upsert_calls.lock().unwrap(),
+ vec![(
+ user_id.as_ref().to_string(),
+ vec![RoleId::TeamSubscriber, RoleId::SubOpus]
+ )]
+ );
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert_eq!(
+ *channels_repository.add_calls.lock().unwrap(),
+ vec![(team_id, user_id.as_ref().to_string())]
+ );
+ assert!(channels_repository.remove_calls.lock().unwrap().is_empty());
+ assert_eq!(
+ *crm_enqueuer.populated.lock().unwrap(),
+ vec![user_id.as_ref().to_string()]
+ );
+ assert_eq!(
+ *events.lock().unwrap(),
+ vec![TeamAnalyticsEvent::TeamJoined {
+ team_id,
+ team_invite_id: invite_id,
+ member_id: user_id.clone().into_owned(),
+ role: TeamRole::Member,
+ }]
+ );
+}
+
+#[tokio::test]
+async fn join_team_enterprise_rolls_back_accepted_invite_when_role_assignment_fails() {
+ let team_id = uuid::Uuid::from_u128(46);
+ let invite_id = uuid::Uuid::from_u128(460);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService {
+ fail_upsert: true,
+ ..Default::default()
+ };
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.join_team(&invite_id, &user_id).await.unwrap_err();
+
+ assert!(matches!(error, JoinTeamError::AddRolesToUserError(_)));
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.rollback_accept_calls.lock().unwrap(), 1);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn join_team_enterprise_rolls_back_roles_and_invite_when_channel_add_fails() {
+ let team_id = uuid::Uuid::from_u128(47);
+ let invite_id = uuid::Uuid::from_u128(470);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository {
+ fail_add: true,
+ ..Default::default()
+ };
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.join_team(&invite_id, &user_id).await.unwrap_err();
+
+ assert!(matches!(error, JoinTeamError::TeamError(_)));
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.rollback_accept_calls.lock().unwrap(), 1);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);
+ assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);
+ assert_eq!(
+ *channels_repository.add_calls.lock().unwrap(),
+ vec![(team_id, user_id.as_ref().to_string())]
+ );
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn join_team_enterprise_rolls_back_accepted_invite_when_status_read_fails() {
+ let team_id = uuid::Uuid::from_u128(48);
+ let invite_id = uuid::Uuid::from_u128(480);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);
+ team_repository.fail_enterprise_status_lookup = true;
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.join_team(&invite_id, &user_id).await.unwrap_err();
+
+ assert!(matches!(error, JoinTeamError::TeamError(_)));
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.rollback_accept_calls.lock().unwrap(), 1);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert!(roles_service.upsert_calls.lock().unwrap().is_empty());
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn join_team_rolls_back_accepted_invite_when_billing_lookup_fails() {
+ let team_id = uuid::Uuid::from_u128(49);
+ let invite_id = uuid::Uuid::from_u128(490);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+
+ for (fail_payment_status, fail_subscription_id, expected_subscription_lookups) in
+ [(true, false, 0), (false, true, 1)]
+ {
+ let mut team_repository =
+ make_enterprise_join_team_repository(team_id, invite_id, &user_id);
+ team_repository.enterprise = false;
+ team_repository.fail_team_payment_status_lookup = fail_payment_status;
+ team_repository.fail_team_subscription_id_lookup = fail_subscription_id;
+
+ let service = TeamServiceImpl::new(
+ team_repository.clone(),
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ let error = service.join_team(&invite_id, &user_id).await.unwrap_err();
+
+ assert!(matches!(
+ error,
+ JoinTeamError::TeamError(TeamError::StorageLayerError(_))
+ ));
+ assert_eq!(*team_repository.rollback_accept_calls.lock().unwrap(), 1);
+ assert_eq!(
+ *team_repository
+ .team_payment_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(
+ *team_repository
+ .team_subscription_id_lookup_calls
+ .lock()
+ .unwrap(),
+ expected_subscription_lookups
+ );
+ }
+}
+
+#[tokio::test]
+async fn test_join_team_backfills_legacy_team_subscription() {
+ let team_id = uuid::Uuid::from_u128(43);
+ let invite_id = uuid::Uuid::from_u128(430);
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let subscription_id: stripe::SubscriptionId = "sub_backfill_join".parse().unwrap();
+
+ let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
+ let mut team_repo = MockTeamRepository::new(Vec::new(), "Legacy Team", mark_sent_calls)
+ .with_team(Team::new(
+ team_id,
+ "Legacy Team".to_string(),
+ "legacy-team".to_string(),
+ owner_id.clone().into_owned(),
+ false,
+ false,
+ ));
+ team_repo.team_payment_status = false;
+ team_repo.team_subscription_id = None;
+ team_repo.stripe_customer_id = Some("cus_backfill_join".parse().unwrap());
+ team_repo.accepted_invite = Some(make_accepted_invite(team_id, invite_id, &user_id));
+ let subscription_update_calls = team_repo.subscription_update_calls.clone();
+ let payment_update_calls = team_repo.payment_update_calls.clone();
+
+ let customer_repo = MockCustomerRepository {
+ subscription_id: subscription_id.clone(),
+ ..Default::default()
+ };
+ let convert_calls = customer_repo.convert_calls.clone();
+ let increment_calls = customer_repo.increment_calls.clone();
+
+ let service = TeamServiceImpl::new(
+ team_repo,
+ customer_repo,
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ service.join_team(&invite_id, &user_id).await.unwrap();
+
+ assert!(convert_calls.lock().unwrap().contains(&(
+ subscription_id.to_string(),
+ team_id,
+ owner_id.as_ref().to_string()
+ )));
+ assert_eq!(
+ *subscription_update_calls.lock().unwrap(),
+ vec![(team_id, subscription_id.to_string())]
+ );
+ assert_eq!(*payment_update_calls.lock().unwrap(), vec![(team_id, true)]);
assert_eq!(
*increment_calls.lock().unwrap(),
vec![(subscription_id.to_string(), 1)]
@@ -1989,6 +2662,7 @@ async fn test_join_team_rolls_back_accept_when_backfill_fails() {
"legacy-team".to_string(),
owner_id.into_owned(),
false,
+ false,
));
team_repo.team_payment_status = false;
team_repo.team_subscription_id = None;
@@ -2738,3 +3412,513 @@ async fn test_try_join_team_by_domain_rolls_back_membership_when_roles_fail() {
);
assert_eq!(*remove_user_calls.lock().unwrap(), 1);
}
+
+#[tokio::test]
+async fn try_join_team_by_domain_rolls_back_membership_when_billing_lookup_fails() {
+ let team_id = uuid::Uuid::from_u128(86);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+
+ for (fail_payment_status, fail_subscription_id, expected_subscription_lookups) in
+ [(true, false, 0), (false, true, 1)]
+ {
+ let mut team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ team_repository.enterprise = false;
+ team_repository.fail_team_payment_status_lookup = fail_payment_status;
+ team_repository.fail_team_subscription_id_lookup = fail_subscription_id;
+
+ let service = TeamServiceImpl::new(
+ team_repository.clone(),
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ let error = service.try_join_team_by_domain(&user_id).await.unwrap_err();
+
+ assert!(matches!(
+ error,
+ TryJoinTeamByDomainError::TeamError(TeamError::StorageLayerError(_))
+ ));
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_eq!(
+ *team_repository
+ .team_payment_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(
+ *team_repository
+ .team_subscription_id_lookup_calls
+ .lock()
+ .unwrap(),
+ expected_subscription_lookups
+ );
+ }
+}
+
+#[tokio::test]
+async fn try_join_team_by_domain_enterprise_bypasses_billing_and_preserves_side_effects() {
+ let team_id = uuid::Uuid::from_u128(81);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let member = service
+ .try_join_team_by_domain(&user_id)
+ .await
+ .unwrap()
+ .expect("enterprise user should have been auto-joined");
+
+ assert_eq!(member.team_id, team_id);
+ assert_eq!(member.user_id, user_id);
+ assert_eq!(member.role, TeamRole::Member);
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(
+ *roles_service.upsert_calls.lock().unwrap(),
+ vec![(
+ user_id.as_ref().to_string(),
+ vec![RoleId::TeamSubscriber, RoleId::SubOpus]
+ )]
+ );
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert_eq!(
+ *channels_repository.add_calls.lock().unwrap(),
+ vec![(team_id, user_id.as_ref().to_string())]
+ );
+ assert!(channels_repository.remove_calls.lock().unwrap().is_empty());
+ assert_eq!(
+ *crm_enqueuer.populated.lock().unwrap(),
+ vec![user_id.as_ref().to_string()]
+ );
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn try_join_team_by_domain_enterprise_still_enforces_local_seat_cap() {
+ let team_id = uuid::Uuid::from_u128(82);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ team_repository.team_plan = Some(TeamPlan::Idea);
+ team_repository.seat_count = TeamPlan::Idea.seat_cap();
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let member = service.try_join_team_by_domain(&user_id).await.unwrap();
+
+ assert!(member.is_none());
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 0);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert!(roles_service.upsert_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn try_join_team_by_domain_enterprise_rolls_back_membership_when_roles_fail() {
+ let team_id = uuid::Uuid::from_u128(83);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService {
+ fail_upsert: true,
+ ..Default::default()
+ };
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.try_join_team_by_domain(&user_id).await.unwrap_err();
+
+ assert!(matches!(
+ error,
+ TryJoinTeamByDomainError::JoinTeamError(JoinTeamError::AddRolesToUserError(_))
+ ));
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn try_join_team_by_domain_enterprise_rolls_back_roles_when_channels_fail() {
+ let team_id = uuid::Uuid::from_u128(84);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository {
+ fail_add: true,
+ ..Default::default()
+ };
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.try_join_team_by_domain(&user_id).await.unwrap_err();
+
+ assert!(matches!(
+ error,
+ TryJoinTeamByDomainError::JoinTeamError(JoinTeamError::TeamError(_))
+ ));
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);
+ assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);
+ assert_eq!(
+ *channels_repository.add_calls.lock().unwrap(),
+ vec![(team_id, user_id.as_ref().to_string())]
+ );
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn remove_user_from_team_enterprise_bypasses_billing_and_preserves_side_effects() {
+ let team_id = uuid::Uuid::from_u128(91);
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository =
+ make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Admin);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ service
+ .remove_user_from_team(
+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),
+ &member_id,
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 0);
+ assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(
+ *channels_repository.remove_calls.lock().unwrap(),
+ vec![(team_id, member_id.as_ref().to_string())]
+ );
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert_eq!(
+ *roles_service.remove_calls.lock().unwrap(),
+ vec![(
+ member_id.as_ref().to_string(),
+ vec![RoleId::TeamSubscriber, RoleId::SubOpus]
+ )]
+ );
+ assert_eq!(
+ *crm_enqueuer.depopulated.lock().unwrap(),
+ vec![(team_id, member_id.as_ref().to_string())]
+ );
+ assert_eq!(
+ *events.lock().unwrap(),
+ vec![TeamAnalyticsEvent::TeamLeft {
+ team_id,
+ member_id: member_id.clone().into_owned(),
+ removed_by_id: owner_id.into_owned(),
+ role: TeamRole::Admin,
+ }]
+ );
+}
+
+#[tokio::test]
+async fn remove_user_from_team_enterprise_rolls_back_membership_when_channel_removal_fails() {
+ let team_id = uuid::Uuid::from_u128(92);
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository =
+ make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository {
+ fail_remove: true,
+ ..Default::default()
+ };
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service
+ .remove_user_from_team(
+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),
+ &member_id,
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(error, RemoveUserFromTeamError::TeamError(_)));
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 1);
+ assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(
+ *channels_repository.remove_calls.lock().unwrap(),
+ vec![(team_id, member_id.as_ref().to_string())]
+ );
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn remove_user_from_team_enterprise_rolls_back_membership_and_channels_when_role_removal_fails()
+ {
+ let team_id = uuid::Uuid::from_u128(93);
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let team_repository =
+ make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService {
+ fail_remove: true,
+ ..Default::default()
+ };
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service
+ .remove_user_from_team(
+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),
+ &member_id,
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(
+ error,
+ RemoveUserFromTeamError::RemoveRolesFromUserError(_)
+ ));
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 1);
+ assert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 1);
+ assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);
+ assert_eq!(
+ *channels_repository.remove_calls.lock().unwrap(),
+ vec![(team_id, member_id.as_ref().to_string())]
+ );
+ assert_eq!(
+ *channels_repository.add_calls.lock().unwrap(),
+ vec![(team_id, member_id.as_ref().to_string())]
+ );
+ assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);
+ assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn remove_user_from_team_enterprise_status_read_precedes_membership_removal() {
+ let team_id = uuid::Uuid::from_u128(94);
+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut team_repository =
+ make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);
+ team_repository.fail_enterprise_status_lookup = true;
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service
+ .remove_user_from_team(
+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),
+ &member_id,
+ )
+ .await
+ .unwrap_err();
+
+ assert!(matches!(
+ error,
+ RemoveUserFromTeamError::TeamError(TeamError::StorageLayerError(_))
+ ));
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);
+ assert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 0);
+ assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);
+ assert!(channels_repository.remove_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn try_join_team_by_domain_enterprise_status_read_precedes_membership_mutation() {
+ let team_id = uuid::Uuid::from_u128(85);
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();
+ let mut team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);
+ team_repository.fail_enterprise_status_lookup = true;
+ let customer_repository = MockCustomerRepository::default();
+ let channels_repository = MockTeamChannelsRepository::default();
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let crm_enqueuer = RecordingCrmEnqueuer::default();
+ let events = Arc::new(Mutex::new(Vec::new()));
+
+ let service = TeamServiceImpl::new_with_analytics(
+ team_repository.clone(),
+ customer_repository.clone(),
+ channels_repository.clone(),
+ roles_service.clone(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ crm_enqueuer.clone(),
+ NoOpTeamCrmSettingsRepository,
+ MockTeamAnalytics::new(events.clone()),
+ );
+
+ let error = service.try_join_team_by_domain(&user_id).await.unwrap_err();
+
+ assert!(matches!(
+ error,
+ TryJoinTeamByDomainError::TeamError(TeamError::StorageLayerError(_))
+ ));
+ assert_eq!(
+ *team_repository
+ .enterprise_status_lookup_calls
+ .lock()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(*team_repository.add_user_to_team_calls.lock().unwrap(), 0);
+ assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);
+ assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);
+ assert!(roles_service.upsert_calls.lock().unwrap().is_empty());
+ assert!(channels_repository.add_calls.lock().unwrap().is_empty());
+ assert!(crm_enqueuer.populated.lock().unwrap().is_empty());
+ assert!(events.lock().unwrap().is_empty());
+}
diff --git a/crates/teams/src/outbound/team_repo.rs b/crates/teams/src/outbound/team_repo.rs
index 5adb9b1132..98cd2fcb41 100644
--- a/crates/teams/src/outbound/team_repo.rs
+++ b/crates/teams/src/outbound/team_repo.rs
@@ -148,7 +148,7 @@ impl TeamRepositoryImpl {
r#"
INSERT INTO team (id, name, owner_id, seat_count, subscription_id, paying)
VALUES ($1, $2, $3, 1, $4, TRUE)
- RETURNING id, name, slug, owner_id
+ RETURNING id, name, slug, owner_id, enterprise
"#,
id,
team_name,
@@ -167,6 +167,7 @@ impl TeamRepositoryImpl {
crm_enabled: false,
// New teams start without an auto-join domain.
auto_join_domain: None,
+ enterprise: row.enterprise,
})
})
.fetch_one(&mut *transaction)
@@ -354,6 +355,22 @@ impl TeamRepository for TeamRepositoryImpl {
Ok(paying)
}
+ #[tracing::instrument(skip(self), err)]
+ async fn get_team_enterprise_status(&self, team_id: &uuid::Uuid) -> Result<bool, TeamError> {
+ let enterprise = sqlx::query_scalar!(
+ r#"
+ SELECT enterprise
+ FROM team
+ WHERE id = $1
+ "#,
+ team_id,
+ )
+ .fetch_one(&self.pool)
+ .await?;
+
+ Ok(enterprise)
+ }
+
#[tracing::instrument(skip(self), err)]
async fn create_team(
&self,
@@ -1062,7 +1079,7 @@ impl TeamRepository for TeamRepositoryImpl {
async fn get_team_by_id(&self, team_id: &uuid::Uuid) -> Result<TeamWithMembers, TeamError> {
let team = sqlx::query!(
r#"
- SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain,
+ SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain, t.enterprise,
COALESCE(tcs.crm_enabled, FALSE) AS "crm_enabled!"
FROM team t
LEFT JOIN team_crm_settings tcs ON tcs.team_id = t.id
@@ -1080,6 +1097,7 @@ impl TeamRepository for TeamRepositoryImpl {
.into_owned(),
crm_enabled: row.crm_enabled,
auto_join_domain: row.auto_join_domain,
+ enterprise: row.enterprise,
})
})
.fetch_one(&self.pool)
@@ -1117,7 +1135,7 @@ impl TeamRepository for TeamRepositoryImpl {
async fn get_user_teams(&self, user_id: &MacroUserIdStr<'_>) -> Result<Vec<Team>, TeamError> {
let teams = sqlx::query!(
r#"
- SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain,
+ SELECT t.id, t.name, t.slug, t.owner_id, t.auto_join_domain, t.enterprise,
COALESCE(tcs.crm_enabled, FALSE) AS "crm_enabled!"
FROM team t
JOIN team_user tu ON t.id = tu.team_id
@@ -1136,6 +1154,7 @@ impl TeamRepository for TeamRepositoryImpl {
.into_owned(),
crm_enabled: row.crm_enabled,
auto_join_domain: row.auto_join_domain,
+ enterprise: row.enterprise,
})
})
.fetch_all(&self.pool)
diff --git a/crates/teams/src/outbound/team_repo/test.rs b/crates/teams/src/outbound/team_repo/test.rs
index 573c884d29..92c2084537 100644
--- a/crates/teams/src/outbound/team_repo/test.rs
+++ b/crates/teams/src/outbound/team_repo/test.rs
@@ -132,6 +132,35 @@ async fn test_get_team_payment_status(pool: Pool<Postgres>) -> anyhow::Result<()
Ok(())
}
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("teams"))
+)]
+async fn test_get_team_enterprise_status(pool: Pool<Postgres>) -> anyhow::Result<()> {
+ let team_repo = TeamRepositoryImpl::new(pool.clone());
+ let team_id = macro_uuid::string_to_uuid("11111111-1111-1111-1111-111111111111")?;
+
+ let enterprise = team_repo.get_team_enterprise_status(&team_id).await?;
+ assert!(!enterprise);
+
+ sqlx::query!("UPDATE team SET enterprise = TRUE WHERE id = $1", &team_id)
+ .execute(&pool)
+ .await?;
+
+ let enterprise = team_repo.get_team_enterprise_status(&team_id).await?;
+ assert!(enterprise);
+
+ let missing_team_id = macro_uuid::string_to_uuid("63333333-3333-3333-3333-333333333333")?;
+ let error = team_repo
+ .get_team_enterprise_status(&missing_team_id)
+ .await
+ .expect_err("a missing team should return an error");
+
+ assert!(matches!(error, TeamError::TeamDoesNotExist));
+
+ Ok(())
+}
+
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("teams"))
@@ -148,6 +177,7 @@ async fn test_create_team(pool: Pool<Postgres>) -> anyhow::Result<()> {
assert_eq!(result.name, "team1");
assert_eq!(result.slug, "MACRO");
assert_eq!(result.owner_id.0.as_ref(), "macro|[email protected]");
+ assert!(!result.enterprise());
// Create team with too large a name
let err = team_repo
@@ -1291,14 +1321,47 @@ async fn test_patch_team_plan(pool: Pool<Postgres>) -> anyhow::Result<()> {
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../fixtures", scripts("teams"))
)]
-async fn test_get_team_by_id_includes_slug(pool: Pool<Postgres>) -> anyhow::Result<()> {
- let team_repo = TeamRepositoryImpl::new(pool);
+async fn test_get_team_by_id_hydrates_enterprise_status(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let team_repo = TeamRepositoryImpl::new(pool.clone());
let team_id = macro_uuid::string_to_uuid("11111111-1111-1111-1111-111111111111")?;
+ sqlx::query!("UPDATE team SET enterprise = TRUE WHERE id = $1", &team_id)
+ .execute(&pool)
+ .await?;
+
let team = team_repo.get_team_by_id(&team_id).await?.team;
assert_eq!(team.name(), "team1");
assert_eq!(team.slug(), "MACRO");
+ assert!(team.enterprise());
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("teams"))
+)]
+async fn test_get_user_teams_hydrates_enterprise_status(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ let team_repo = TeamRepositoryImpl::new(pool.clone());
+ let team_id = macro_uuid::string_to_uuid("11111111-1111-1111-1111-111111111111")?;
+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]")?;
+
+ sqlx::query!("UPDATE team SET enterprise = TRUE WHERE id = $1", &team_id)
+ .execute(&pool)
+ .await?;
+
+ let teams = team_repo.get_user_teams(&user_id).await?;
+ let team = teams
+ .iter()
+ .find(|team| team.id() == &team_id)
+ .expect("updated team should be returned for the user");
+
+ assert!(team.enterprise());
Ok(())
}