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(stripe): handle payment failures/successes in stripe webhook (#4599)

Will Hutchinsonfaf7ce18b4bd
diff --git a/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook.rs b/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook.rs
index fa54e6931c..d778f54e67 100644
--- a/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook.rs
+++ b/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook.rs
@@ -16,9 +16,17 @@ use macro_user_id::{cowlike::CowLike, lowercased::Lowercase};
use miniserde::json::Value as JsonValue;
use model::response::ErrorResponse;
use referral::domain::ports::ReferralService;
-use roles_and_permissions::domain::{model::ProductTier, port::UserRolesAndPermissionsService};
+use roles_and_permissions::domain::{
+ model::{ProductTier, SubscriptionStatus},
+ port::UserRolesAndPermissionsService,
+};
use serde::Serialize;
use stripe_webhook::{EventObject, EventType};
+use teams::domain::team_repo::TeamService;
+use tracing::Instrument;
+
+#[cfg(test)]
+mod test;
/// Extracts the previous status from the previous_attributes JSON value.
fn extract_previous_status(previous_attributes: &Option<JsonValue>) -> Option<String> {
@@ -31,8 +39,57 @@ fn extract_previous_status(previous_attributes: &Option<JsonValue>) -> Option<St
_ => None,
}
}
-use teams::domain::team_repo::TeamService;
-use tracing::Instrument;
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+enum PaymentEventOutcome {
+ RevokePremiumAccess,
+ RestorePremiumAccess,
+}
+
+impl PaymentEventOutcome {
+ fn from_event_type(event_type: &EventType) -> Option<Self> {
+ match event_type {
+ EventType::InvoicePaymentFailed => Some(Self::RevokePremiumAccess),
+ EventType::InvoicePaymentSucceeded | EventType::InvoicePaid => {
+ Some(Self::RestorePremiumAccess)
+ }
+ _ => None,
+ }
+ }
+
+ fn personal_subscription_status(self) -> SubscriptionStatus {
+ match self {
+ Self::RevokePremiumAccess => SubscriptionStatus::PastDue,
+ Self::RestorePremiumAccess => SubscriptionStatus::Active,
+ }
+ }
+
+ fn team_subscription_status(self) -> &'static str {
+ match self {
+ Self::RevokePremiumAccess => "past_due",
+ Self::RestorePremiumAccess => "active",
+ }
+ }
+
+ fn is_revoke(self) -> bool {
+ matches!(self, Self::RevokePremiumAccess)
+ }
+}
+
+fn is_active_subscription_status(status: &stripe::SubscriptionStatus) -> bool {
+ matches!(
+ *status,
+ stripe::SubscriptionStatus::Active | stripe::SubscriptionStatus::Trialing
+ )
+}
+
+fn is_active_subscription_except_current(
+ subscription_id: &str,
+ status: &stripe::SubscriptionStatus,
+ current_subscription_id: &str,
+) -> bool {
+ subscription_id != current_subscription_id && is_active_subscription_status(status)
+}
/// The main entrypoint for all stripe webhook events handling
#[tracing::instrument(skip(ctx, headers, body))]
@@ -108,8 +165,11 @@ pub async fn handler(
)
.await
}
+ EventType::InvoicePaymentFailed
+ | EventType::InvoicePaymentSucceeded
+ | EventType::InvoicePaid => handle_payment_event(&ctx, event.data.object, event_type).await,
_ => {
- tracing::error!(event_type=?event.type_, "unexpected event type");
+ tracing::error!(event_type=?event_type, "unexpected event type");
Ok(())
}
}
@@ -121,6 +181,157 @@ pub async fn handler(
Ok(StatusCode::OK.into_response())
}
+#[tracing::instrument(skip(ctx, event_object), err, ret)]
+async fn handle_payment_event(
+ ctx: &ApiContext,
+ event_object: EventObject,
+ event_type: EventType,
+) -> anyhow::Result<()> {
+ let invoice = match event_object {
+ EventObject::InvoicePaymentFailed(invoice) => invoice,
+ EventObject::InvoicePaymentSucceeded(invoice) => invoice,
+ EventObject::InvoicePaid(invoice) => invoice,
+ _ => {
+ anyhow::bail!("expected invoice payment event");
+ }
+ };
+
+ let outcome = PaymentEventOutcome::from_event_type(&event_type)
+ .context("expected invoice payment event type")?;
+
+ let Some(webhook_subscription_id) = invoice
+ .subscription
+ .as_ref()
+ .map(|subscription| subscription.id().as_str())
+ else {
+ tracing::info!(
+ event_type = ?event_type,
+ invoice_id = ?invoice.id.as_ref().map(|id| id.as_str()),
+ "acknowledging invoice payment event without subscription"
+ );
+ return Ok(());
+ };
+
+ let subscription_id: stripe::SubscriptionId = webhook_subscription_id
+ .parse()
+ .context("expected subscription id")?;
+ let subscription =
+ stripe::Subscription::retrieve(&ctx.stripe_client, &subscription_id, &[]).await?;
+
+ let customer_id = subscription.customer.id();
+ let customer = stripe::Customer::retrieve(&ctx.stripe_client, &customer_id, &[]).await?;
+
+ tracing::trace!(customer=?customer, "retrieved customer");
+
+ if customer.deleted {
+ return Ok(());
+ }
+
+ let email = customer.email.context("expected customer email")?;
+ let email = Email::parse_from_str(&email)
+ .context("expected customer email")?
+ .lowercase();
+
+ let subscription_id = subscription.id.as_str();
+ let subscription_status = outcome.team_subscription_status();
+ let stripe_subscription_status = subscription.status.as_str();
+
+ let subscription_currency = Some(subscription.currency.to_string());
+ let subscription_value: i64 = subscription
+ .items
+ .data
+ .iter()
+ .filter_map(|item| {
+ let price = item.price.as_ref()?;
+ let unit_amount = price.unit_amount?;
+ let quantity = item.quantity.unwrap_or(1) as i64;
+ Some(unit_amount * quantity)
+ })
+ .sum();
+ let subscription_value = if subscription_value > 0 {
+ Some(subscription_value)
+ } else {
+ None
+ };
+
+ let ga_client_id = subscription.metadata.get("ga_client_id").cloned();
+ let fbp = subscription.metadata.get("fbp").cloned();
+ let fbc = subscription.metadata.get("fbc").cloned();
+
+ tracing::info!(
+ email=%email.as_ref(),
+ event_type = ?event_type,
+ outcome = ?outcome,
+ subscription_id,
+ payment_derived_subscription_status = subscription_status,
+ stripe_subscription_status,
+ ga_client_id=?ga_client_id,
+ fbp=?fbp,
+ fbc=?fbc,
+ "processing stripe invoice payment event"
+ );
+
+ if let Some(team_id) = subscription.metadata.get("team_id") {
+ let team_id = macro_uuid::string_to_uuid(team_id)?;
+ return handle_team_subscription_event(
+ ctx,
+ subscription_id,
+ subscription_status,
+ &team_id,
+ &email,
+ SubscriptionTrackingData {
+ ga_client_id: ga_client_id.clone(),
+ fbp: fbp.clone(),
+ fbc: fbc.clone(),
+ email: email.as_ref().to_string(),
+ value_cents: subscription_value,
+ currency: subscription_currency,
+ status: subscription_status.to_string(),
+ is_new: false,
+ },
+ )
+ .await;
+ }
+
+ if outcome.is_revoke() {
+ let mut list_subscriptions = stripe::ListSubscriptions::new();
+ list_subscriptions.customer = Some(customer_id.clone());
+ list_subscriptions.limit = Some(10);
+
+ let all_subscriptions =
+ stripe::Subscription::list(&ctx.stripe_client, &list_subscriptions).await?;
+
+ let has_other_active_personal_subscription =
+ all_subscriptions.data.iter().any(|subscription| {
+ !subscription.metadata.contains_key("team_id")
+ && is_active_subscription_except_current(
+ subscription.id.as_str(),
+ &subscription.status,
+ subscription_id,
+ )
+ });
+
+ if has_other_active_personal_subscription {
+ tracing::info!(
+ customer_id = %customer_id,
+ subscription_id,
+ "invoice payment failed but user still has another active subscription - not revoking permissions"
+ );
+ return Ok(());
+ }
+ }
+
+ ctx.user_roles_and_permissions_service
+ .update_user_roles_and_permissions_for_subscription(
+ email,
+ outcome.personal_subscription_status(),
+ ProductTier::Opus,
+ )
+ .await?;
+
+ Ok(())
+}
+
#[tracing::instrument(skip(ctx, event_object, previous_attributes), err, ret)]
async fn handle_customer_subscription_event(
ctx: &ApiContext,
@@ -279,12 +490,7 @@ async fn handle_customer_subscription_event(
let active_subscriptions: Vec<_> = all_subscriptions
.data
.iter()
- .filter(|sub| {
- matches!(
- sub.status,
- stripe::SubscriptionStatus::Active | stripe::SubscriptionStatus::Trialing
- )
- })
+ .filter(|sub| is_active_subscription_status(&sub.status))
.collect();
// If this is a new active/trialing subscription and there are multiple active subscriptions,
diff --git a/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook/test.rs b/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook/test.rs
new file mode 100644
index 0000000000..37abd1e9a1
--- /dev/null
+++ b/rust/cloud-storage/authentication_service/src/api/webhooks/user/stripe_webhook/test.rs
@@ -0,0 +1,76 @@
+use roles_and_permissions::domain::model::SubscriptionStatus;
+use stripe_webhook::EventType;
+
+use super::{PaymentEventOutcome, is_active_subscription_except_current};
+
+#[test]
+fn invoice_payment_failed_maps_to_revoke_outcome() {
+ let outcome = PaymentEventOutcome::from_event_type(&EventType::InvoicePaymentFailed)
+ .expect("invoice payment failure should map to an outcome");
+
+ assert_eq!(outcome, PaymentEventOutcome::RevokePremiumAccess);
+ assert_eq!(
+ outcome.personal_subscription_status(),
+ SubscriptionStatus::PastDue
+ );
+ assert_eq!(outcome.team_subscription_status(), "past_due");
+ assert!(outcome.is_revoke());
+}
+
+#[test]
+fn invoice_payment_success_events_map_to_restore_outcome() {
+ let success_event_types = [EventType::InvoicePaymentSucceeded, EventType::InvoicePaid];
+
+ for event_type in success_event_types {
+ let outcome = PaymentEventOutcome::from_event_type(&event_type)
+ .expect("invoice payment success should map to an outcome");
+
+ assert_eq!(outcome, PaymentEventOutcome::RestorePremiumAccess);
+ assert_eq!(
+ outcome.personal_subscription_status(),
+ SubscriptionStatus::Active
+ );
+ assert_eq!(outcome.team_subscription_status(), "active");
+ assert!(!outcome.is_revoke());
+ }
+}
+
+#[test]
+fn non_invoice_payment_events_do_not_map_to_payment_outcomes() {
+ let non_payment_event_types = [
+ EventType::CustomerSubscriptionCreated,
+ EventType::CustomerSubscriptionUpdated,
+ EventType::CustomerSubscriptionDeleted,
+ EventType::CustomerSubscriptionPaused,
+ ];
+
+ for event_type in non_payment_event_types {
+ assert_eq!(PaymentEventOutcome::from_event_type(&event_type), None);
+ }
+}
+
+#[test]
+fn invoice_payment_active_subscription_check_excludes_current_subscription() {
+ let current_subscription_id = "sub_failed";
+
+ assert!(!is_active_subscription_except_current(
+ current_subscription_id,
+ &stripe::SubscriptionStatus::Active,
+ current_subscription_id,
+ ));
+ assert!(is_active_subscription_except_current(
+ "sub_active",
+ &stripe::SubscriptionStatus::Active,
+ current_subscription_id,
+ ));
+ assert!(is_active_subscription_except_current(
+ "sub_trialing",
+ &stripe::SubscriptionStatus::Trialing,
+ current_subscription_id,
+ ));
+ assert!(!is_active_subscription_except_current(
+ "sub_past_due",
+ &stripe::SubscriptionStatus::PastDue,
+ current_subscription_id,
+ ));
+}
diff --git a/rust/cloud-storage/roles_and_permissions/src/domain/service.rs b/rust/cloud-storage/roles_and_permissions/src/domain/service.rs
index ed3b3f38ce..7dd0313bf1 100644
--- a/rust/cloud-storage/roles_and_permissions/src/domain/service.rs
+++ b/rust/cloud-storage/roles_and_permissions/src/domain/service.rs
@@ -65,6 +65,8 @@ where
.await
}
SubscriptionStatus::Canceled
+ | SubscriptionStatus::IncompleteExpired
+ | SubscriptionStatus::PastDue
| SubscriptionStatus::Paused
| SubscriptionStatus::Unpaid => {
self.user_roles_and_permissions_repository
diff --git a/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rs b/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rs
index 033f2b3f99..c51ee0b8fe 100644
--- a/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rs
+++ b/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rs
@@ -27,7 +27,7 @@ impl UserRepository for MockUserRepository {
#[derive(Debug, Clone, Default)]
struct MockUserRolesAndPermissionsRepository {
add_roles_to_user_calls: Arc<Mutex<usize>>,
- remove_roles_from_user_calls: Arc<Mutex<usize>>,
+ removed_roles_from_user_calls: Arc<Mutex<Vec<Vec<RoleId>>>>,
}
impl MockUserRolesAndPermissionsRepository {
@@ -36,7 +36,11 @@ impl MockUserRolesAndPermissionsRepository {
}
pub fn get_remove_roles_from_user_calls(&self) -> usize {
- *self.remove_roles_from_user_calls.lock().unwrap()
+ self.removed_roles_from_user_calls.lock().unwrap().len()
+ }
+
+ pub fn get_removed_roles_from_user_calls(&self) -> Vec<Vec<RoleId>> {
+ self.removed_roles_from_user_calls.lock().unwrap().clone()
}
}
@@ -70,13 +74,55 @@ impl UserRolesAndPermissionsRepository for MockUserRolesAndPermissionsRepository
async fn remove_roles_from_user(
&self,
_user_id: &MacroUserIdStr<'_>,
- _role_ids: &[RoleId],
+ role_ids: &[RoleId],
) -> Result<(), UserRolesAndPermissionsError> {
- *self.remove_roles_from_user_calls.lock().unwrap() += 1;
+ self.removed_roles_from_user_calls
+ .lock()
+ .unwrap()
+ .push(role_ids.to_vec());
Ok(())
}
}
+async fn assert_payment_failure_status_removes_subscription_roles(
+ subscription_status: SubscriptionStatus,
+) -> anyhow::Result<()> {
+ let mock_user_repository = MockUserRepository::default();
+ let mock_user_roles_and_permissions_repository =
+ MockUserRolesAndPermissionsRepository::default();
+
+ let user_service = UserRolesAndPermissionsServiceImpl::new(
+ mock_user_roles_and_permissions_repository.clone(),
+ mock_user_repository,
+ );
+
+ user_service
+ .update_user_roles_and_permissions_for_subscription(
+ Email::parse_from_str("[email protected]")?.lowercase(),
+ subscription_status,
+ ProductTier::Opus,
+ )
+ .await?;
+
+ assert_eq!(
+ mock_user_roles_and_permissions_repository.get_removed_roles_from_user_calls(),
+ vec![vec![RoleId::ProfessionalSubscriber, RoleId::SubOpus]]
+ );
+
+ Ok(())
+}
+
+#[tokio::test]
+async fn test_payment_failure_statuses_past_due_removes_roles() -> anyhow::Result<()> {
+ assert_payment_failure_status_removes_subscription_roles(SubscriptionStatus::PastDue).await
+}
+
+#[tokio::test]
+async fn test_payment_failure_statuses_incomplete_expired_removes_roles() -> anyhow::Result<()> {
+ assert_payment_failure_status_removes_subscription_roles(SubscriptionStatus::IncompleteExpired)
+ .await
+}
+
#[tokio::test]
async fn test_user_respository_get_user_id_by_email() -> anyhow::Result<()> {
let mock_user_repository = MockUserRepository::default();
diff --git a/rust/cloud-storage/teams/src/domain/team_service/test.rs b/rust/cloud-storage/teams/src/domain/team_service/test.rs
index 9aeafdc506..031a99a6b5 100644
--- a/rust/cloud-storage/teams/src/domain/team_service/test.rs
+++ b/rust/cloud-storage/teams/src/domain/team_service/test.rs
@@ -60,6 +60,7 @@ struct MockTeamRepository {
backfilled_subscription_id: Arc<Mutex<Option<stripe::SubscriptionId>>>,
stripe_customer_id: Option<stripe::CustomerId>,
team_payment_status: bool,
+ team_members: Vec<TeamMember<'static>>,
accepted_invite: Option<AcceptedTeamInvite<'static>>,
removed_member: Option<TeamMember<'static>>,
rollback_accept_calls: Arc<Mutex<usize>>,
@@ -91,6 +92,7 @@ impl MockTeamRepository {
backfilled_subscription_id: Arc::new(Mutex::new(None)),
stripe_customer_id: None,
team_payment_status: true,
+ team_members: Vec::new(),
accepted_invite: None,
removed_member: None,
rollback_accept_calls: Arc::new(Mutex::new(0)),
@@ -119,6 +121,11 @@ impl MockTeamRepository {
self.team_for_get_by_id = Some(team);
self
}
+
+ fn with_team_members(mut self, members: Vec<TeamMember<'static>>) -> Self {
+ self.team_members = members;
+ self
+ }
}
impl TeamRepository for MockTeamRepository {
@@ -351,7 +358,8 @@ impl TeamRepository for MockTeamRepository {
&self,
_: &uuid::Uuid,
) -> impl Future<Output = Result<Vec<TeamMember<'_>>, TeamError>> + Send {
- async { unimplemented!() }
+ let members = self.team_members.clone();
+ async move { Ok(members) }
}
fn bulk_is_member_of_other_team(
@@ -809,6 +817,16 @@ fn make_invite(email: &str, invite_id: uuid::Uuid, team_id: uuid::Uuid) -> TeamI
}
}
+fn make_team_member(team_id: uuid::Uuid, user_id: &str, role: TeamRole) -> TeamMember<'static> {
+ TeamMember {
+ team_id,
+ user_id: MacroUserIdStr::parse_from_str(user_id)
+ .unwrap()
+ .into_owned(),
+ role,
+ }
+}
+
fn make_accepted_invite(
team_id: uuid::Uuid,
invite_id: uuid::Uuid,
@@ -877,6 +895,117 @@ fn build_service_with_analytics(
// -- Tests --
+#[tokio::test]
+async fn team_payment_revoke_removes_exact_premium_roles_from_members() {
+ let team_id = uuid::Uuid::from_u128(5000);
+ let members = vec![
+ make_team_member(team_id, "macro|[email protected]", TeamRole::Member),
+ make_team_member(team_id, "macro|[email protected]", TeamRole::Admin),
+ ];
+ let expected_roles = vec![RoleId::TeamSubscriber, RoleId::SubOpus];
+ let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
+ let team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls)
+ .with_team_members(members);
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let remove_role_calls = roles_service.remove_calls.clone();
+ let service = TeamServiceImpl::new(
+ team_repo,
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ roles_service,
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ service
+ .revoke_permissions_for_team_members(&team_id)
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *remove_role_calls.lock().unwrap(),
+ vec![
+ (
+ "macro|[email protected]".to_string(),
+ expected_roles.clone(),
+ ),
+ ("macro|[email protected]".to_string(), expected_roles),
+ ]
+ );
+}
+
+#[tokio::test]
+async fn team_payment_restore_adds_exact_premium_roles_to_members() {
+ let team_id = uuid::Uuid::from_u128(5001);
+ let members = vec![
+ make_team_member(team_id, "macro|[email protected]", TeamRole::Member),
+ make_team_member(team_id, "macro|[email protected]", TeamRole::Admin),
+ ];
+ let expected_roles = vec![RoleId::TeamSubscriber, RoleId::SubOpus];
+ let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
+ let team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls)
+ .with_team_members(members);
+ let roles_service = MockUserRolesAndPermissionsService::default();
+ let upsert_role_calls = roles_service.upsert_calls.clone();
+ let service = TeamServiceImpl::new(
+ team_repo,
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ roles_service,
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ service
+ .restore_permissions_for_team_members(&team_id)
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *upsert_role_calls.lock().unwrap(),
+ vec![
+ (
+ "macro|[email protected]".to_string(),
+ expected_roles.clone(),
+ ),
+ ("macro|[email protected]".to_string(), expected_roles),
+ ]
+ );
+}
+
+#[tokio::test]
+async fn team_payment_patch_payment_status_delegates_to_repository() {
+ let team_id = uuid::Uuid::from_u128(5002);
+ let mark_sent_calls: Arc<Mutex<Vec<Vec<uuid::Uuid>>>> = Arc::new(Mutex::new(Vec::new()));
+ let team_repo = MockTeamRepository::new(Vec::new(), "Test Team", mark_sent_calls);
+ let payment_update_calls = team_repo.payment_update_calls.clone();
+ let service = TeamServiceImpl::new(
+ team_repo,
+ MockCustomerRepository::default(),
+ MockTeamChannelsRepository::default(),
+ MockUserRolesAndPermissionsService::default(),
+ Arc::new(MockNotificationIngress::new(HashSet::new())),
+ NoOpCrmEnqueuer,
+ NoOpTeamCrmSettingsRepository,
+ );
+
+ service
+ .patch_team_payment_status(&team_id, false)
+ .await
+ .unwrap();
+ service
+ .patch_team_payment_status(&team_id, true)
+ .await
+ .unwrap();
+
+ assert_eq!(
+ *payment_update_calls.lock().unwrap(),
+ vec![(team_id, false), (team_id, true)]
+ );
+}
+
#[tokio::test]
async fn test_create_team_moves_github_installation_to_created_team() {
let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();