Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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.rsindex 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.rsnew file mode 100644index 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.rsindex 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_repositorydiff --git a/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rs b/rust/cloud-storage/roles_and_permissions/src/domain/service/test.rsindex 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 MockUserRolesAndPermissionsRepositoryasync 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.rsindex 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();