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
test(teams): add failing seat release regression (#6933)
Will Hutchinsondbb660ff5f8e
diff --git a/.sqlx/query-904248cdade2f9b74f4612195cfee182ca877615bc144fd491c251b70003eb37.json b/.sqlx/query-2b085d52dfc73a35dd75163a923febcc32c778880e83d4eb497c6a78067aa0d8.jsonsimilarity index 73%rename from .sqlx/query-904248cdade2f9b74f4612195cfee182ca877615bc144fd491c251b70003eb37.jsonrename to .sqlx/query-2b085d52dfc73a35dd75163a923febcc32c778880e83d4eb497c6a78067aa0d8.jsonindex d4754b4f4c..03e524a0fe 100644--- a/.sqlx/query-904248cdade2f9b74f4612195cfee182ca877615bc144fd491c251b70003eb37.json+++ b/.sqlx/query-2b085d52dfc73a35dd75163a923febcc32c778880e83d4eb497c6a78067aa0d8.json@@ -1,6 +1,6 @@{"db_name": "PostgreSQL",- "query": "\n SELECT overage_enabled, overage_limit_cents, overage_suspended_at,\n period_start, period_end\n FROM ai_billing_account\n WHERE user_id = $1\n ",+ "query": "\n SELECT overage_enabled, overage_limit_cents, overage_suspended_at,\n period_start, period_end, seat_generation\n FROM ai_billing_account\n WHERE user_id = $1\n ","describe": {"columns": [{@@ -27,6 +27,11 @@"ordinal": 4,"name": "period_end","type_info": "Timestamptz"+ },+ {+ "ordinal": 5,+ "name": "seat_generation",+ "type_info": "Int8"}],"parameters": {@@ -39,8 +44,9 @@false,true,true,- true+ true,+ false]},- "hash": "904248cdade2f9b74f4612195cfee182ca877615bc144fd491c251b70003eb37"+ "hash": "2b085d52dfc73a35dd75163a923febcc32c778880e83d4eb497c6a78067aa0d8"}diff --git a/.sqlx/query-62ba149ed381410cfc5775da4cea6dedbd1bc72769cea9fa32a84fa69592e8d6.json b/.sqlx/query-62ba149ed381410cfc5775da4cea6dedbd1bc72769cea9fa32a84fa69592e8d6.jsonnew file mode 100644index 0000000000..5f0baf7714--- /dev/null+++ b/.sqlx/query-62ba149ed381410cfc5775da4cea6dedbd1bc72769cea9fa32a84fa69592e8d6.json@@ -0,0 +1,18 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO ai_billing_period_allowance (\n user_id, period_start, billed_users, included_cents_by_user, updated_at\n )\n VALUES ($1, $2, $3, $4, $5)\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Timestamptz",+ "TextArray",+ "Int8Array",+ "Timestamptz"+ ]+ },+ "nullable": []+ },+ "hash": "62ba149ed381410cfc5775da4cea6dedbd1bc72769cea9fa32a84fa69592e8d6"+}diff --git a/.sqlx/query-661996cd2f3a4e844049ada20eb8d736630dd247b9c2e9b1c79851da43cbeb8d.json b/.sqlx/query-661996cd2f3a4e844049ada20eb8d736630dd247b9c2e9b1c79851da43cbeb8d.jsonnew file mode 100644index 0000000000..5aaa7ecde7--- /dev/null+++ b/.sqlx/query-661996cd2f3a4e844049ada20eb8d736630dd247b9c2e9b1c79851da43cbeb8d.json@@ -0,0 +1,22 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT seat_generation FROM ai_billing_account WHERE user_id = $1",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "seat_generation",+ "type_info": "Int8"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ false+ ]+ },+ "hash": "661996cd2f3a4e844049ada20eb8d736630dd247b9c2e9b1c79851da43cbeb8d"+}diff --git a/.sqlx/query-681d961b489f1b6d5601f82b9f9ac33ce24938e41d373e2c772c1af3541c2ecc.json b/.sqlx/query-681d961b489f1b6d5601f82b9f9ac33ce24938e41d373e2c772c1af3541c2ecc.jsonnew file mode 100644index 0000000000..3b978b2008--- /dev/null+++ b/.sqlx/query-681d961b489f1b6d5601f82b9f9ac33ce24938e41d373e2c772c1af3541c2ecc.json@@ -0,0 +1,22 @@+{+ "db_name": "PostgreSQL",+ "query": "\n SELECT seat_generation\n FROM ai_billing_account\n WHERE user_id = $1\n FOR UPDATE\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "seat_generation",+ "type_info": "Int8"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ false+ ]+ },+ "hash": "681d961b489f1b6d5601f82b9f9ac33ce24938e41d373e2c772c1af3541c2ecc"+}diff --git a/.sqlx/query-7c10177cc44ad44c72239f6b01371412c5f263168f3adc145c7c5bad424c5dd1.json b/.sqlx/query-7c10177cc44ad44c72239f6b01371412c5f263168f3adc145c7c5bad424c5dd1.jsonnew file mode 100644index 0000000000..647b4740c9--- /dev/null+++ b/.sqlx/query-7c10177cc44ad44c72239f6b01371412c5f263168f3adc145c7c5bad424c5dd1.json@@ -0,0 +1,17 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO ai_billing_period_allowance (\n user_id, period_start, billed_users, included_cents_by_user\n )\n VALUES ($1, $2, $3, $4)\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Timestamptz",+ "TextArray",+ "Int8Array"+ ]+ },+ "nullable": []+ },+ "hash": "7c10177cc44ad44c72239f6b01371412c5f263168f3adc145c7c5bad424c5dd1"+}diff --git a/.sqlx/query-9fc573bd641f7b73375801ae9a45b64d212f871c4af2192a74f57bab83b4ceb5.json b/.sqlx/query-9fc573bd641f7b73375801ae9a45b64d212f871c4af2192a74f57bab83b4ceb5.jsonnew file mode 100644index 0000000000..4327b956af--- /dev/null+++ b/.sqlx/query-9fc573bd641f7b73375801ae9a45b64d212f871c4af2192a74f57bab83b4ceb5.json@@ -0,0 +1,16 @@+{+ "db_name": "PostgreSQL",+ "query": "\n UPDATE ai_billing_period_allowance AS allowance\n SET billed_users = excised.users,\n included_cents_by_user = excised.cents,\n updated_at = NOW()\n FROM (\n SELECT\n COALESCE(\n array_agg(seat.billed_user ORDER BY seat.ordinality)\n FILTER (WHERE seat.billed_user IS DISTINCT FROM $3),\n ARRAY[]::text[]\n )::text[] AS users,\n COALESCE(\n array_agg(seat.included_cents ORDER BY seat.ordinality)\n FILTER (WHERE seat.billed_user IS DISTINCT FROM $3),\n ARRAY[]::bigint[]\n )::bigint[] AS cents\n FROM ai_billing_period_allowance AS src\n CROSS JOIN LATERAL unnest(src.billed_users, src.included_cents_by_user)\n WITH ORDINALITY AS seat(billed_user, included_cents, ordinality)\n WHERE src.user_id = $1\n AND src.period_start = $2\n ) AS excised\n WHERE allowance.user_id = $1\n AND allowance.period_start = $2\n AND $3 = ANY (allowance.billed_users)\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Timestamptz",+ "Text"+ ]+ },+ "nullable": []+ },+ "hash": "9fc573bd641f7b73375801ae9a45b64d212f871c4af2192a74f57bab83b4ceb5"+}diff --git a/.sqlx/query-b9636c6455486e2f7119f04f519bf5568a3960104801b1188f502b4d2d868dfb.json b/.sqlx/query-b9636c6455486e2f7119f04f519bf5568a3960104801b1188f502b4d2d868dfb.jsonnew file mode 100644index 0000000000..4d72ce5d54--- /dev/null+++ b/.sqlx/query-b9636c6455486e2f7119f04f519bf5568a3960104801b1188f502b4d2d868dfb.json@@ -0,0 +1,14 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO ai_billing_account (user_id, seat_generation)\n VALUES ($1, 1)\n ON CONFLICT (user_id) DO UPDATE\n SET seat_generation = ai_billing_account.seat_generation + 1,\n updated_at = NOW()\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": []+ },+ "hash": "b9636c6455486e2f7119f04f519bf5568a3960104801b1188f502b4d2d868dfb"+}diff --git a/.sqlx/query-f11189d3026d8bfde974a03893017752ca96ee3a2074b59ec7b4d02e2c76ec66.json b/.sqlx/query-f11189d3026d8bfde974a03893017752ca96ee3a2074b59ec7b4d02e2c76ec66.jsonnew file mode 100644index 0000000000..d7a8119e32--- /dev/null+++ b/.sqlx/query-f11189d3026d8bfde974a03893017752ca96ee3a2074b59ec7b4d02e2c76ec66.json@@ -0,0 +1,35 @@+{+ "db_name": "PostgreSQL",+ "query": "\n SELECT billed_users AS \"billed_users!\",\n included_cents_by_user AS \"included_cents_by_user!\",\n updated_at\n FROM ai_billing_period_allowance\n WHERE user_id = $1 AND period_start = $2\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "billed_users!",+ "type_info": "TextArray"+ },+ {+ "ordinal": 1,+ "name": "included_cents_by_user!",+ "type_info": "Int8Array"+ },+ {+ "ordinal": 2,+ "name": "updated_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Text",+ "Timestamptz"+ ]+ },+ "nullable": [+ false,+ false,+ false+ ]+ },+ "hash": "f11189d3026d8bfde974a03893017752ca96ee3a2074b59ec7b4d02e2c76ec66"+}diff --git a/crates/ai_billing/src/domain.rs b/crates/ai_billing/src/domain.rsindex 951f4cf948..0d670ffed1 100644--- a/crates/ai_billing/src/domain.rs+++ b/crates/ai_billing/src/domain.rs@@ -8,11 +8,12 @@ pub mod service;pub use ledger::{SettlementPlan, SettlementPolicy, SettlementState, plan_settlement};pub use models::{- AllowanceDecision, BillingError, BillingPeriod, BillingSettings, CREDIT_PACKS_CENTS,- DenyReason, Entitlement, MIN_STRIPE_CHARGE_CENTS, OVERAGE_CHARGE_THRESHOLD_CENTS,- OVERAGE_LIMIT_MAX_CENTS, OVERAGE_LIMIT_MIN_CENTS, OverageChargeStatus, PayerScope,- PeriodAllowance, PeriodLedger, PlanTier, Result, SeatAllowance, SeatUsage,- TARGET_GROSS_MARGIN_BPS, UsageSnapshot, list_rate_cents,+ AllowanceDecision, AllowanceStore, BillingError, BillingPeriod, BillingSettings,+ CREDIT_PACKS_CENTS, DenyReason, Entitlement, MIN_STRIPE_CHARGE_CENTS,+ OVERAGE_CHARGE_THRESHOLD_CENTS, OVERAGE_LIMIT_MAX_CENTS, OVERAGE_LIMIT_MIN_CENTS,+ OpenPeriodStart, OverageChargeStatus, PayerScope, PeriodAllowance, PeriodLedger, PlanTier,+ Result, SeatAllowance, SeatGeneration, SeatUsage, TARGET_GROSS_MARGIN_BPS, UsageSnapshot,+ list_rate_cents,};pub use ports::{BillingRepo, BillingService, CreditCheckoutRequest, EntitlementSource, OverageChargeRequest,diff --git a/crates/ai_billing/src/domain/models.rs b/crates/ai_billing/src/domain/models.rsindex 48ae8928cb..89c2a1a17b 100644--- a/crates/ai_billing/src/domain/models.rs+++ b/crates/ai_billing/src/domain/models.rs@@ -179,6 +179,57 @@ impl BillingPeriod {pub fn has_ended(&self, now: DateTime<Utc>) -> bool {now >= self.end}++ /// `Some` while `now` is inside `[start, end)`.+ pub fn open_start(self, now: DateTime<Utc>) -> Option<OpenPeriodStart> {+ if self.has_ended(now) {+ None+ } else {+ Some(OpenPeriodStart(self.start))+ }+ }+}++/// Start of the period that contains `now`.+///+/// Closed periods cannot be named by this type, so open-period writers cannot+/// target them.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct OpenPeriodStart(DateTime<Utc>);++impl OpenPeriodStart {+ /// Inclusive start of the open period.+ pub const fn start(self) -> DateTime<Utc> {+ self.0+ }+}++/// Monotonic generation of a payer's open-seat roster.+///+/// A missing `ai_billing_account` row is generation zero. Releasing a seat+/// moves it forward so a roster read from before the release cannot be stored.+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]+pub struct SeatGeneration(i64);++impl SeatGeneration {+ /// The generation stored in Postgres.+ pub const fn from_raw(raw: i64) -> Self {+ Self(raw)+ }++ /// The generation stored in Postgres.+ pub const fn raw(self) -> i64 {+ self.0+ }+}++/// Outcome of a conditional open-period allowance store.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum AllowanceStore {+ /// The open-period row matches the supplied seats.+ Stored,+ /// `seat_generation` moved after it was observed. The arrays were not written.+ Conflict,}/// Who pays for a user's AI, and through what.@@ -282,7 +333,7 @@ impl Entitlement {}}-/// The payer's overage settings and Stripe period anchor.+/// The payer's overage settings, Stripe period anchor, and open-seat generation.#[derive(Debug, Clone, Default, PartialEq, Eq)]pub struct BillingSettings {/// Whether usage past allowance and credits is billed as overage.@@ -293,6 +344,8 @@ pub struct BillingSettings {pub overage_suspended_at: Option<DateTime<Utc>>,/// The subscription period last synced from Stripe.pub period_anchor: Option<(DateTime<Utc>, DateTime<Utc>)>,+ /// Generation of the payer's open-seat roster. Zero when no account row exists.+ pub seat_generation: SeatGeneration,}impl BillingSettings {diff --git a/crates/ai_billing/src/domain/ports.rs b/crates/ai_billing/src/domain/ports.rsindex cb7c3ed2cd..a08dcc6635 100644--- a/crates/ai_billing/src/domain/ports.rs+++ b/crates/ai_billing/src/domain/ports.rs@@ -3,8 +3,9 @@use super::ledger::SettlementPolicy;use super::models::{- AllowanceDecision, BillingPeriod, BillingSettings, Entitlement, OverageChargeStatus,- PeriodAllowance, PeriodLedger, Result, SeatAllowance, SeatUsage, UsageSnapshot,+ AllowanceDecision, AllowanceStore, BillingPeriod, BillingSettings, Entitlement,+ OpenPeriodStart, OverageChargeStatus, PeriodAllowance, PeriodLedger, Result, SeatAllowance,+ SeatGeneration, SeatUsage, UsageSnapshot,};use chrono::{DateTime, Utc};use macro_user_id::user_id::MacroUserIdStr;@@ -23,6 +24,14 @@ pub trait EntitlementSource: Send + Sync + 'static {&self,user: &MacroUserIdStr<'_>,) -> impl Future<Output = Result<Option<String>>> + Send;++ /// The payer for `team_id`, if the team exists.+ ///+ /// Missing teams are `Ok(None)`. The payer is the team owner.+ fn team_payer(+ &self,+ team_id: Uuid,+ ) -> impl Future<Output = Result<Option<MacroUserIdStr<'static>>>> + Send;}/// Reads recorded, metered AI usage at Macro's list rate.@@ -116,14 +125,29 @@ pub trait BillingRepo: Send + Sync + 'static {period_start: DateTime<Utc>,) -> impl Future<Output = Result<Option<PeriodAllowance>>> + Send;- /// Record each seat's live allowance against the open period. Upserts so- /// a mid-period plan or seat change is reflected until the period closes;- /// callers must only pass the current period's start.- fn remember_period_allowance(+ /// Record each seat's allowance for the open period when `observed` is still+ /// the payer's seat generation.+ ///+ /// Returns [`AllowanceStore::Conflict`] when the generation moved, without+ /// writing the arrays. An unchanged roster does not touch `updated_at`.+ fn store_open_allowance(&self,payer: &MacroUserIdStr<'_>,- period_start: DateTime<Utc>,+ period: OpenPeriodStart,seats: &[SeatAllowance],+ observed: SeatGeneration,+ ) -> impl Future<Output = Result<AllowanceStore>> + Send;++ /// Remove `member` and the paired included cents from the payer's open period.+ ///+ /// A missing allowance row, or a row that does not contain `member`, is+ /// success and does not change that row. The payer's seat generation still+ /// moves forward, including when no allowance row exists.+ fn release_open_seat(+ &self,+ payer: &MacroUserIdStr<'_>,+ period: OpenPeriodStart,+ member: &MacroUserIdStr<'_>,) -> impl Future<Output = Result<()>> + Send;/// Book a credit purchase. Returns `false` when `stripe_reference` wasdiff --git a/crates/ai_billing/src/domain/service.rs b/crates/ai_billing/src/domain/service.rsindex 4df127a583..c8562f7612 100644--- a/crates/ai_billing/src/domain/service.rs+++ b/crates/ai_billing/src/domain/service.rs@@ -6,10 +6,10 @@ mod test;use super::ledger::{SettlementPolicy, build_snapshot, decide};use super::models::{- AllowanceDecision, BillingError, BillingPeriod, BillingSettings, CREDIT_PACKS_CENTS,- Entitlement, OVERAGE_CHARGE_THRESHOLD_CENTS, OVERAGE_LIMIT_MAX_CENTS, OVERAGE_LIMIT_MIN_CENTS,- OverageChargeStatus, PeriodAllowance, PlanTier, Result, SeatAllowance, SeatUsage,- UsageSnapshot,+ AllowanceDecision, AllowanceStore, BillingError, BillingPeriod, BillingSettings,+ CREDIT_PACKS_CENTS, Entitlement, OVERAGE_CHARGE_THRESHOLD_CENTS, OVERAGE_LIMIT_MAX_CENTS,+ OVERAGE_LIMIT_MIN_CENTS, OverageChargeStatus, PayerScope, PeriodAllowance, PlanTier, Result,+ SeatAllowance, SeatUsage, UsageSnapshot,};use super::ports::{BillingRepo, BillingService, CreditCheckoutRequest, EntitlementSource, OverageChargeRequest,@@ -18,6 +18,7 @@ use super::ports::{use chrono::{DateTime, Utc};use macro_user_id::user_id::MacroUserIdStr;use macro_uuid::Uuid;+use teams::domain::open_seat_release::OpenSeatRelease;/// The billing service over its four ports.#[derive(Clone)]@@ -62,6 +63,23 @@ fn chargeable_usage_cents(seats: &[SeatAllowance], usage: &[SeatUsage]) -> i64 {.sum()}+fn same_seat_pairs(left: &[SeatAllowance], right: &[SeatAllowance]) -> bool {+ if left.len() != right.len() {+ return false;+ }+ let mut left_pairs: Vec<(&str, i64)> = left+ .iter()+ .map(|seat| (seat.user.as_ref(), seat.included_cents))+ .collect();+ let mut right_pairs: Vec<(&str, i64)> = right+ .iter()+ .map(|seat| (seat.user.as_ref(), seat.included_cents))+ .collect();+ left_pairs.sort_unstable();+ right_pairs.sort_unstable();+ left_pairs == right_pairs+}+impl<E, U, R, P> BillingServiceImpl<E, U, R, P>whereE: EntitlementSource,@@ -70,26 +88,79 @@ whereP: PaymentGateway,{async fn position(&self, user: &MacroUserIdStr<'_>, now: DateTime<Utc>) -> Result<Position> {- let entitlement = self.entitlements.entitlement(user).await?;- let settings = self.repo.settings(&entitlement.payer).await?;+ let first = self.entitlements.entitlement(user).await?;+ let settings = self.repo.settings(&first.payer).await?;let period = BillingPeriod::current(settings.period_anchor, now);- // Freeze the open period's allowance so a later plan or seat change- // cannot rewrite it after the period closes. Mid-period changes- // refresh this row while the period is still current.- if entitlement.tier.is_paid() && !entitlement.unlimited {- self.repo- .remember_period_allowance(- &entitlement.payer,- period.start,- &entitlement.seat_allowances(),- )- .await?;+ if !first.tier.is_paid() || first.unlimited {+ return Ok(Position {+ entitlement: first,+ settings,+ period,+ });+ }+ let Some(open) = period.open_start(now) else {+ return Ok(Position {+ entitlement: first,+ settings,+ period,+ });+ };+ let stored = self+ .repo+ .period_allowance(&first.payer, open.start())+ .await?;+ if stored+ .as_ref()+ .is_some_and(|allowance| same_seat_pairs(&allowance.seats, &first.seat_allowances()))+ {+ return Ok(Position {+ entitlement: first,+ settings,+ period,+ });+ }++ let entitlement = match &first.scope {+ PayerScope::Personal => first.clone(),+ PayerScope::TeamOwner { .. } | PayerScope::TeamMember { .. } => {+ self.entitlements.entitlement(user).await?+ }+ };+ if entitlement.payer.as_ref() != first.payer.as_ref() {+ // `settings.seat_generation` was read for `first.payer`.+ let settings = self.repo.settings(&entitlement.payer).await?;+ let period = BillingPeriod::current(settings.period_anchor, now);+ return Ok(Position {+ entitlement,+ settings,+ period,+ });+ }+ if !entitlement.tier.is_paid() || entitlement.unlimited {+ return Ok(Position {+ entitlement,+ settings,+ period,+ });+ }++ // A conflict means a release already wrote the row. The next observation refreshes.+ match self+ .repo+ .store_open_allowance(+ &entitlement.payer,+ open,+ &entitlement.seat_allowances(),+ settings.seat_generation,+ )+ .await?+ {+ AllowanceStore::Stored | AllowanceStore::Conflict => Ok(Position {+ entitlement,+ settings,+ period,+ }),}- Ok(Position {- entitlement,- settings,- period,- })}async fn snapshot_at(@@ -336,6 +407,32 @@ where}}+impl<E, U, R, P> OpenSeatRelease for BillingServiceImpl<E, U, R, P>+where+ E: EntitlementSource + Clone,+ U: UsageReader + Clone,+ R: BillingRepo + Clone,+ P: PaymentGateway + Clone,+{+ type Err = BillingError;++ #[tracing::instrument(skip(self), err)]+ async fn release(&self, team_id: Uuid, member: &MacroUserIdStr<'_>) -> Result<()> {+ let Some(payer) = self.entitlements.team_payer(team_id).await? else {+ return Ok(());+ };+ if payer.as_ref() == member.as_ref() {+ return Ok(());+ }+ let settings = self.repo.settings(&payer).await?;+ let now = Utc::now();+ let Some(open) = BillingPeriod::current(settings.period_anchor, now).open_start(now) else {+ return Ok(());+ };+ self.repo.release_open_seat(&payer, open, member).await+ }+}+impl<E, U, R, P> BillingService for BillingServiceImpl<E, U, R, P>whereE: EntitlementSource,diff --git a/crates/ai_billing/src/domain/service/test.rs b/crates/ai_billing/src/domain/service/test.rsindex 9321126ccd..12f4281c83 100644--- a/crates/ai_billing/src/domain/service/test.rs+++ b/crates/ai_billing/src/domain/service/test.rs@@ -1,11 +1,15 @@use super::*;use crate::domain::ledger::plan_settlement;-use crate::domain::models::{DenyReason, PayerScope, PeriodAllowance, PeriodLedger};+use crate::domain::models::{+ AllowanceStore, DenyReason, OpenPeriodStart, PayerScope, PeriodAllowance, PeriodLedger,+ SeatGeneration,+};use crate::domain::ports::SettlementOutcome;use macro_user_id::cowlike::CowLike;use macro_uuid::Uuid;use std::collections::HashMap;use std::sync::{Arc, Mutex};+use teams::domain::open_seat_release::OpenSeatRelease;fn user(email: &str) -> MacroUserIdStr<'static> {MacroUserIdStr::try_from(format!("macro|{email}")).unwrap()@@ -15,6 +19,7 @@ fn user(email: &str) -> MacroUserIdStr<'static> {struct FakeEntitlements {by_user: Arc<Mutex<HashMap<String, Entitlement>>>,customers: Arc<Mutex<HashMap<String, String>>>,+ payers: Arc<Mutex<HashMap<Uuid, MacroUserIdStr<'static>>>>,}impl FakeEntitlements {@@ -47,6 +52,10 @@ impl FakeEntitlements {.insert(u.to_string(), customer.to_string());self}+ fn payer_for_team(self, team_id: Uuid, payer: MacroUserIdStr<'static>) -> Self {+ self.payers.lock().unwrap().insert(team_id, payer);+ self+ }}impl EntitlementSource for FakeEntitlements {@@ -62,6 +71,9 @@ impl EntitlementSource for FakeEntitlements {async fn stripe_customer_id(&self, user: &MacroUserIdStr<'_>) -> Result<Option<String>> {Ok(self.customers.lock().unwrap().get(user.as_ref()).cloned())}+ async fn team_payer(&self, team_id: Uuid) -> Result<Option<MacroUserIdStr<'static>>> {+ Ok(self.payers.lock().unwrap().get(&team_id).cloned())+ }}#[derive(Clone, Default)]@@ -143,6 +155,7 @@ struct RepoState {charges: Vec<FakeCharge>,suspended: bool,allowances: HashMap<DateTime<Utc>, PeriodAllowance>,+ releases: Vec<(String, DateTime<Utc>, String)>,}impl RepoState {@@ -187,6 +200,9 @@ impl FakeRepo {.get(&period_start).cloned()}+ fn releases(&self) -> Vec<(String, DateTime<Utc>, String)> {+ self.state.lock().unwrap().releases.clone()+ }}impl BillingRepo for FakeRepo {@@ -248,18 +264,44 @@ impl BillingRepo for FakeRepo {.get(&period_start).cloned())}- async fn remember_period_allowance(+ async fn store_open_allowance(&self,_payer: &MacroUserIdStr<'_>,- period_start: DateTime<Utc>,+ period: OpenPeriodStart,seats: &[SeatAllowance],- ) -> Result<()> {- self.state.lock().unwrap().allowances.insert(- period_start,+ observed: SeatGeneration,+ ) -> Result<AllowanceStore> {+ let mut state = self.state.lock().unwrap();+ if state.settings.seat_generation != observed {+ return Ok(AllowanceStore::Conflict);+ }+ state.allowances.insert(+ period.start(),PeriodAllowance {seats: seats.to_vec(),},);+ Ok(AllowanceStore::Stored)+ }+ async fn release_open_seat(+ &self,+ payer: &MacroUserIdStr<'_>,+ period: OpenPeriodStart,+ member: &MacroUserIdStr<'_>,+ ) -> Result<()> {+ let mut state = self.state.lock().unwrap();+ let next = state.settings.seat_generation.raw().saturating_add(1);+ state.settings.seat_generation = SeatGeneration::from_raw(next);+ if let Some(allowance) = state.allowances.get_mut(&period.start()) {+ allowance+ .seats+ .retain(|seat| seat.user.as_ref() != member.as_ref());+ }+ state.releases.push((+ payer.as_ref().to_string(),+ period.start(),+ member.as_ref().to_string(),+ ));Ok(())}async fn record_credit_purchase(@@ -1114,3 +1156,267 @@ async fn current_period_uses_the_live_allowance_after_an_upgrade() {assert_eq!(snap.used_cents, 10_000);assert_eq!(snap.uncovered_cents, 0);}++fn open_anchor(now: DateTime<Utc>) -> (DateTime<Utc>, DateTime<Utc>, OpenPeriodStart) {+ let start = now - chrono::Duration::days(1);+ let end = now + chrono::Duration::days(20);+ let open = BillingPeriod::current(Some((start, end)), now)+ .open_start(now)+ .unwrap();+ (start, end, open)+}++#[tokio::test]+async fn release_targets_the_payer_open_period() {+ let now = Utc::now();+ let (start, end, open) = open_anchor(now);+ let owner = user("[email protected]");+ let member = user("[email protected]");+ let team_id = Uuid::from_u128(7);+ let repo = FakeRepo::default();+ repo.set_period(&owner, start, end).await.unwrap();+ let ents = FakeEntitlements::default().payer_for_team(team_id, owner.clone());+ let svc = BillingServiceImpl::new(+ ents,+ FakeUsage::default(),+ repo.clone(),+ FakePayments::default(),+ );++ svc.release(team_id, &member).await.unwrap();++ assert_eq!(+ repo.releases(),+ vec![(+ owner.as_ref().to_string(),+ open.start(),+ member.as_ref().to_string()+ )]+ );+ assert!(repo.allowance(open.start()).is_none());+}++#[tokio::test]+async fn release_missing_team_leaves_allowances_unchanged() {+ let member = user("[email protected]");+ let repo = FakeRepo::default();+ let period_start = Utc::now();+ repo.freeze(+ period_start,+ PeriodAllowance {+ seats: vec![SeatAllowance {+ user: member.clone(),+ included_cents: 4_000,+ }],+ },+ );+ let svc = BillingServiceImpl::new(+ FakeEntitlements::default(),+ FakeUsage::default(),+ repo.clone(),+ FakePayments::default(),+ );++ svc.release(Uuid::from_u128(8), &member).await.unwrap();++ assert!(repo.releases().is_empty());+ assert_eq!(+ repo.allowance(period_start).unwrap().seats,+ vec![SeatAllowance {+ user: member,+ included_cents: 4_000,+ }]+ );+}++#[tokio::test]+async fn release_refuses_to_remove_the_payer() {+ let now = Utc::now();+ let (start, end, open) = open_anchor(now);+ let owner = user("[email protected]");+ let team_id = Uuid::from_u128(9);+ let repo = FakeRepo::default();+ repo.set_period(&owner, start, end).await.unwrap();+ repo.freeze(+ open.start(),+ PeriodAllowance {+ seats: vec![SeatAllowance {+ user: owner.clone(),+ included_cents: 4_000,+ }],+ },+ );+ let ents = FakeEntitlements::default().payer_for_team(team_id, owner.clone());+ let svc = BillingServiceImpl::new(+ ents,+ FakeUsage::default(),+ repo.clone(),+ FakePayments::default(),+ );++ svc.release(team_id, &owner).await.unwrap();++ assert!(repo.releases().is_empty());+ assert_eq!(+ repo.allowance(open.start()).unwrap().seats,+ vec![SeatAllowance {+ user: owner,+ included_cents: 4_000,+ }]+ );+}++#[tokio::test]+async fn position_keeps_matching_pairs_in_their_stored_order() {+ let now = Utc::now();+ let (start, end, open) = open_anchor(now);+ let owner = user("[email protected]");+ let member = user("[email protected]");+ let team_id = Uuid::from_u128(10);+ let entitlement = Entitlement {+ tier: PlanTier::Premium,+ seat_tiers: vec![PlanTier::Premium, PlanTier::Max],+ unlimited: false,+ payer: owner.clone(),+ billed_users: vec![owner.clone(), member.clone()],+ scope: PayerScope::TeamOwner { team_id },+ };+ let stored = vec![+ SeatAllowance {+ user: member.clone(),+ included_cents: 20_000,+ },+ SeatAllowance {+ user: owner.clone(),+ included_cents: 4_000,+ },+ ];+ let repo = FakeRepo::default();+ repo.set_period(&owner, start, end).await.unwrap();+ repo.freeze(+ open.start(),+ PeriodAllowance {+ seats: stored.clone(),+ },+ );+ let svc = BillingServiceImpl::new(+ FakeEntitlements::default().with(entitlement),+ FakeUsage::default(),+ repo.clone(),+ FakePayments::default(),+ );++ svc.position(&owner, now).await.unwrap();++ assert_eq!(repo.allowance(open.start()).unwrap().seats, stored);+}++#[tokio::test]+async fn position_does_not_restore_a_member_released_between_entitlement_reads() {+ let now = Utc::now();+ let (start, end, open) = open_anchor(now);+ let owner = user("[email protected]");+ let member = user("[email protected]");+ let bob = user("[email protected]");+ let team_id = Uuid::from_u128(11);+ let before = Entitlement {+ tier: PlanTier::Premium,+ seat_tiers: vec![PlanTier::Premium, PlanTier::Premium],+ unlimited: false,+ payer: owner.clone(),+ billed_users: vec![owner.clone(), member.clone()],+ scope: PayerScope::TeamOwner { team_id },+ };+ let after = Entitlement {+ billed_users: vec![owner.clone()],+ seat_tiers: vec![PlanTier::Premium],+ ..before.clone()+ };+ let repo = FakeRepo::default();+ repo.set_period(&owner, start, end).await.unwrap();+ repo.freeze(+ open.start(),+ PeriodAllowance {+ seats: vec![+ SeatAllowance {+ user: owner.clone(),+ included_cents: 100,+ },+ SeatAllowance {+ user: member.clone(),+ included_cents: 100,+ },+ SeatAllowance {+ user: bob.clone(),+ included_cents: 300,+ },+ ],+ },+ );+ let ents = ReleaseOnSecondRead {+ calls: Arc::new(Mutex::new(0)),+ before,+ after: after.clone(),+ repo: repo.clone(),+ open,+ member: member.clone(),+ };+ let svc = BillingServiceImpl::new(+ ents,+ FakeUsage::default(),+ repo.clone(),+ FakePayments::default(),+ );++ let position = svc.position(&owner, now).await.unwrap();++ assert_eq!(position.entitlement.billed_users, after.billed_users);+ assert_eq!(+ repo.allowance(open.start()).unwrap().seats,+ vec![+ SeatAllowance {+ user: owner,+ included_cents: 100,+ },+ SeatAllowance {+ user: bob,+ included_cents: 300,+ },+ ]+ );+}++struct ReleaseOnSecondRead {+ calls: Arc<Mutex<u32>>,+ before: Entitlement,+ after: Entitlement,+ repo: FakeRepo,+ open: OpenPeriodStart,+ member: MacroUserIdStr<'static>,+}++impl EntitlementSource for ReleaseOnSecondRead {+ async fn entitlement(&self, _user: &MacroUserIdStr<'_>) -> Result<Entitlement> {+ let first_read = {+ let mut calls = self.calls.lock().unwrap();+ *calls += 1;+ *calls == 1+ };+ if first_read {+ Ok(self.before.clone())+ } else {+ self.repo+ .release_open_seat(&self.before.payer, self.open, &self.member)+ .await?;+ Ok(self.after.clone())+ }+ }++ async fn stripe_customer_id(&self, _user: &MacroUserIdStr<'_>) -> Result<Option<String>> {+ Ok(None)+ }++ async fn team_payer(&self, _team_id: Uuid) -> Result<Option<MacroUserIdStr<'static>>> {+ Ok(None)+ }+}diff --git a/crates/ai_billing/src/outbound/entitlement.rs b/crates/ai_billing/src/outbound/entitlement.rsindex e271257042..b0d704f2e1 100644--- a/crates/ai_billing/src/outbound/entitlement.rs+++ b/crates/ai_billing/src/outbound/entitlement.rs@@ -3,7 +3,9 @@use crate::domain::{BillingError, Entitlement, EntitlementSource, PayerScope, PlanTier, Result};use macro_user_id::cowlike::CowLike;use macro_user_id::user_id::MacroUserIdStr;+use macro_uuid::Uuid;use roles_and_permissions::domain::port::UserRolesAndPermissionsService;+use teams::domain::model::TeamError;use teams::domain::team_repo::TeamRepository;/// [`EntitlementSource`] over the roles service and the teams repository.@@ -129,6 +131,15 @@ where})}+ #[tracing::instrument(skip(self), err)]+ async fn team_payer(&self, team_id: Uuid) -> Result<Option<MacroUserIdStr<'static>>> {+ match self.teams.get_team_owner(&team_id).await {+ Ok(owner) => Ok(Some(owner)),+ Err(TeamError::TeamDoesNotExist) => Ok(None),+ Err(error) => Err(entitlement_err(error)),+ }+ }+#[tracing::instrument(skip(self), err)]async fn stripe_customer_id(&self, user: &MacroUserIdStr<'_>) -> Result<Option<String>> {Ok(selfdiff --git a/crates/ai_billing/src/outbound/pg_billing_repo.rs b/crates/ai_billing/src/outbound/pg_billing_repo.rsindex 216c434a2d..09f24301e7 100644--- a/crates/ai_billing/src/outbound/pg_billing_repo.rs+++ b/crates/ai_billing/src/outbound/pg_billing_repo.rs@@ -5,9 +5,9 @@mod test;use crate::domain::{- BillingError, BillingRepo, BillingSettings, OverageChargeStatus, PendingCharge,- PeriodAllowance, PeriodLedger, Result, SeatAllowance, SettlementOutcome, SettlementPolicy,- SettlementState, plan_settlement,+ AllowanceStore, BillingError, BillingRepo, BillingSettings, OpenPeriodStart,+ OverageChargeStatus, PendingCharge, PeriodAllowance, PeriodLedger, Result, SeatAllowance,+ SeatGeneration, SettlementOutcome, SettlementPolicy, SettlementState, plan_settlement,};use chrono::{DateTime, Utc};use macro_user_id::user_id::MacroUserIdStr;@@ -37,7 +37,7 @@ impl BillingRepo for PgBillingRepo {let row = sqlx::query!(r#"SELECT overage_enabled, overage_limit_cents, overage_suspended_at,- period_start, period_end+ period_start, period_end, seat_generationFROM ai_billing_accountWHERE user_id = $1"#,@@ -53,6 +53,7 @@ impl BillingRepo for PgBillingRepo {overage_limit_cents: r.overage_limit_cents,overage_suspended_at: r.overage_suspended_at,period_anchor: r.period_start.zip(r.period_end),+ seat_generation: SeatGeneration::from_raw(r.seat_generation),}).unwrap_or_default())}@@ -190,18 +191,51 @@ impl BillingRepo for PgBillingRepo {.transpose()}- async fn remember_period_allowance(+ async fn store_open_allowance(&self,payer: &MacroUserIdStr<'_>,- period_start: DateTime<Utc>,+ period: OpenPeriodStart,seats: &[SeatAllowance],- ) -> Result<()> {+ observed: SeatGeneration,+ ) -> Result<AllowanceStore> {let billed_users: Vec<String> = seats.iter().map(|seat| seat.user.as_ref().to_string()).collect();let included_cents_by_user: Vec<i64> =seats.iter().map(|seat| seat.included_cents).collect();+ let payer = payer.as_ref();+ let mut tx = self.pool.begin().await.map_err(storage)?;++ // Lock the payer account before the allowance row, same order as release.+ sqlx::query!(+ r#"+ INSERT INTO ai_billing_account (user_id) VALUES ($1)+ ON CONFLICT (user_id) DO NOTHING+ "#,+ payer,+ )+ .execute(&mut *tx)+ .await+ .map_err(storage)?;+ let generation = sqlx::query!(+ r#"+ SELECT seat_generation+ FROM ai_billing_account+ WHERE user_id = $1+ FOR UPDATE+ "#,+ payer,+ )+ .fetch_one(&mut *tx)+ .await+ .map_err(storage)?+ .seat_generation;+ if SeatGeneration::from_raw(generation) != observed {+ tx.rollback().await.map_err(storage)?;+ return Ok(AllowanceStore::Conflict);+ }+sqlx::query!(r#"INSERT INTO ai_billing_period_allowance (@@ -217,14 +251,78 @@ impl BillingRepo for PgBillingRepo {OR ai_billing_period_allowance.included_cents_by_userIS DISTINCT FROM EXCLUDED.included_cents_by_user"#,- payer.as_ref(),- period_start,+ payer,+ period.start(),&billed_users,&included_cents_by_user,)- .execute(&self.pool)+ .execute(&mut *tx).await.map_err(storage)?;+ tx.commit().await.map_err(storage)?;+ Ok(AllowanceStore::Stored)+ }++ async fn release_open_seat(+ &self,+ payer: &MacroUserIdStr<'_>,+ period: OpenPeriodStart,+ member: &MacroUserIdStr<'_>,+ ) -> Result<()> {+ let payer = payer.as_ref();+ let mut tx = self.pool.begin().await.map_err(storage)?;++ // Lock and bump the payer account before the allowance row, same order as store.+ sqlx::query!(+ r#"+ INSERT INTO ai_billing_account (user_id, seat_generation)+ VALUES ($1, 1)+ ON CONFLICT (user_id) DO UPDATE+ SET seat_generation = ai_billing_account.seat_generation + 1,+ updated_at = NOW()+ "#,+ payer,+ )+ .execute(&mut *tx)+ .await+ .map_err(storage)?;++ sqlx::query!(+ r#"+ UPDATE ai_billing_period_allowance AS allowance+ SET billed_users = excised.users,+ included_cents_by_user = excised.cents,+ updated_at = NOW()+ FROM (+ SELECT+ COALESCE(+ array_agg(seat.billed_user ORDER BY seat.ordinality)+ FILTER (WHERE seat.billed_user IS DISTINCT FROM $3),+ ARRAY[]::text[]+ )::text[] AS users,+ COALESCE(+ array_agg(seat.included_cents ORDER BY seat.ordinality)+ FILTER (WHERE seat.billed_user IS DISTINCT FROM $3),+ ARRAY[]::bigint[]+ )::bigint[] AS cents+ FROM ai_billing_period_allowance AS src+ CROSS JOIN LATERAL unnest(src.billed_users, src.included_cents_by_user)+ WITH ORDINALITY AS seat(billed_user, included_cents, ordinality)+ WHERE src.user_id = $1+ AND src.period_start = $2+ ) AS excised+ WHERE allowance.user_id = $1+ AND allowance.period_start = $2+ AND $3 = ANY (allowance.billed_users)+ "#,+ payer,+ period.start(),+ member.as_ref(),+ )+ .execute(&mut *tx)+ .await+ .map_err(storage)?;+ tx.commit().await.map_err(storage)?;Ok(())}diff --git a/crates/ai_billing/src/outbound/pg_billing_repo/test.rs b/crates/ai_billing/src/outbound/pg_billing_repo/test.rsindex 6c51a6000b..68934a21e9 100644--- a/crates/ai_billing/src/outbound/pg_billing_repo/test.rs+++ b/crates/ai_billing/src/outbound/pg_billing_repo/test.rs@@ -1,5 +1,5 @@use super::*;-use crate::domain::OVERAGE_CHARGE_THRESHOLD_CENTS;+use crate::domain::{BillingPeriod, OVERAGE_CHARGE_THRESHOLD_CENTS};use chrono::DurationRound;use macro_db_migrator::MACRO_DB_MIGRATIONS;@@ -429,61 +429,84 @@ async fn settlement_uses_stored_overage_policy_and_flushes_at_period_end(pool: P#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]async fn period_allowance_roundtrips_and_upserts_per_period(pool: PgPool) {- let repo = PgBillingRepo::new(pool);- let start = Utc::now()+ let repo = PgBillingRepo::new(pool.clone());+ let payer = payer();+ let now = Utc::now().duration_trunc(chrono::Duration::microseconds(1)).unwrap();- let earlier = start - chrono::Duration::days(30);+ let period = BillingPeriod {+ start: now,+ end: now + chrono::Duration::days(30),+ };+ let open = period.open_start(now).unwrap();+ let earlier = open.start() - chrono::Duration::days(30);let member = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();let seats = vec![SeatAllowance {- user: payer(),+ user: payer.clone(),included_cents: 4_000,},SeatAllowance {- user: member,+ user: member.clone(),included_cents: 20_000,},];assert!(- repo.period_allowance(&payer(), start)+ repo.period_allowance(&payer, open.start()).await.unwrap().is_none());- repo.remember_period_allowance(&payer(), start, &seats)- .await- .unwrap();+ assert_eq!(+ repo.store_open_allowance(&payer, open, &seats, SeatGeneration::from_raw(0))+ .await+ .unwrap(),+ AllowanceStore::Stored+ );let frozen = repo- .period_allowance(&payer(), start)+ .period_allowance(&payer, open.start()).await.unwrap().unwrap();assert_eq!(frozen.seats, seats);- // A later observation of the same (open) period refreshes.+ // A later observation of the same open period refreshes.let max_payer = vec![SeatAllowance {- user: payer(),+ user: payer.clone(),included_cents: 20_000,}];- repo.remember_period_allowance(&payer(), start, &max_payer)- .await- .unwrap();+ assert_eq!(+ repo.store_open_allowance(&payer, open, &max_payer, SeatGeneration::from_raw(0))+ .await+ .unwrap(),+ AllowanceStore::Stored+ );let frozen = repo- .period_allowance(&payer(), start)+ .period_allowance(&payer, open.start()).await.unwrap().unwrap();assert_eq!(frozen.seats, max_payer);- // A different period is independent.- repo.remember_period_allowance(&payer(), earlier, &seats)- .await- .unwrap();+ sqlx::query!(+ r#"+ INSERT INTO ai_billing_period_allowance (+ user_id, period_start, billed_users, included_cents_by_user+ )+ VALUES ($1, $2, $3, $4)+ "#,+ payer.as_ref(),+ earlier,+ &vec![payer.as_ref().to_string(), member.as_ref().to_string()],+ &vec![4_000_i64, 20_000_i64],+ )+ .execute(&pool)+ .await+ .unwrap();assert_eq!(- repo.period_allowance(&payer(), start)+ repo.period_allowance(&payer, open.start()).await.unwrap().unwrap()@@ -491,7 +514,7 @@ async fn period_allowance_roundtrips_and_upserts_per_period(pool: PgPool) {max_payer);assert_eq!(- repo.period_allowance(&payer(), earlier)+ repo.period_allowance(&payer, earlier).await.unwrap().unwrap()@@ -499,3 +522,283 @@ async fn period_allowance_roundtrips_and_upserts_per_period(pool: PgPool) {seats);}++struct RawAllowance {+ billed_users: Vec<String>,+ included_cents_by_user: Vec<i64>,+ updated_at: chrono::DateTime<Utc>,+}++async fn raw_allowance(+ pool: &PgPool,+ payer: &str,+ period_start: chrono::DateTime<Utc>,+) -> Option<RawAllowance> {+ sqlx::query!(+ r#"+ SELECT billed_users AS "billed_users!",+ included_cents_by_user AS "included_cents_by_user!",+ updated_at+ FROM ai_billing_period_allowance+ WHERE user_id = $1 AND period_start = $2+ "#,+ payer,+ period_start,+ )+ .fetch_optional(pool)+ .await+ .unwrap()+ .map(|row| RawAllowance {+ billed_users: row.billed_users,+ included_cents_by_user: row.included_cents_by_user,+ updated_at: row.updated_at,+ })+}++async fn seat_generation(pool: &PgPool, payer: &str) -> Option<i64> {+ sqlx::query_scalar!(+ r#"SELECT seat_generation FROM ai_billing_account WHERE user_id = $1"#,+ payer,+ )+ .fetch_optional(pool)+ .await+ .unwrap()+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn release_open_seat_removes_the_middle_pair_and_leaves_the_closed_row(pool: PgPool) {+ let repo = PgBillingRepo::new(pool.clone());+ let payer = payer();+ let now = Utc::now();+ let open_start = (now - chrono::Duration::days(1))+ .duration_trunc(chrono::Duration::microseconds(1))+ .unwrap();+ let open = BillingPeriod {+ start: open_start,+ end: now + chrono::Duration::days(20),+ }+ .open_start(now)+ .unwrap();+ let closed_start = open_start - chrono::Duration::days(60);+ let alice = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();+ let bob = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();+ let users = vec![+ payer.as_ref().to_string(),+ alice.as_ref().to_string(),+ bob.as_ref().to_string(),+ ];+ let open_cents = vec![100_i64, 100, 300];+ let closed_cents = vec![4_000_i64, 20_000, 4_000];+ let seeded_at = open_start - chrono::Duration::days(2);+ sqlx::query!(+ r#"+ INSERT INTO ai_billing_period_allowance (+ user_id, period_start, billed_users, included_cents_by_user, updated_at+ )+ VALUES ($1, $2, $3, $4, $5)+ "#,+ payer.as_ref(),+ open.start(),+ &users,+ &open_cents,+ seeded_at,+ )+ .execute(&pool)+ .await+ .unwrap();+ sqlx::query!(+ r#"+ INSERT INTO ai_billing_period_allowance (+ user_id, period_start, billed_users, included_cents_by_user, updated_at+ )+ VALUES ($1, $2, $3, $4, $5)+ "#,+ payer.as_ref(),+ closed_start,+ &users,+ &closed_cents,+ seeded_at,+ )+ .execute(&pool)+ .await+ .unwrap();++ repo.release_open_seat(&payer, open, &alice).await.unwrap();++ let open_row = raw_allowance(&pool, payer.as_ref(), open.start())+ .await+ .unwrap();+ assert_eq!(+ open_row.billed_users,+ vec![payer.as_ref().to_string(), bob.as_ref().to_string()]+ );+ assert_eq!(open_row.included_cents_by_user, vec![100, 300]);+ assert_ne!(open_row.updated_at, seeded_at);+ let closed_row = raw_allowance(&pool, payer.as_ref(), closed_start)+ .await+ .unwrap();+ assert_eq!(closed_row.billed_users, users);+ assert_eq!(closed_row.included_cents_by_user, closed_cents);+ assert_eq!(closed_row.updated_at, seeded_at);+ assert_eq!(seat_generation(&pool, payer.as_ref()).await, Some(1));++ repo.release_open_seat(&payer, open, &alice).await.unwrap();++ let retried = raw_allowance(&pool, payer.as_ref(), open.start())+ .await+ .unwrap();+ assert_eq!(retried.billed_users, open_row.billed_users);+ assert_eq!(+ retried.included_cents_by_user,+ open_row.included_cents_by_user+ );+ assert_eq!(retried.updated_at, open_row.updated_at);+ assert_eq!(+ raw_allowance(&pool, payer.as_ref(), closed_start)+ .await+ .unwrap()+ .updated_at,+ seeded_at+ );+ assert_eq!(seat_generation(&pool, payer.as_ref()).await, Some(2));++ let outsider = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();+ repo.release_open_seat(&payer, open, &outsider)+ .await+ .unwrap();+ let untouched = raw_allowance(&pool, payer.as_ref(), open.start())+ .await+ .unwrap();+ assert_eq!(untouched.billed_users, open_row.billed_users);+ assert_eq!(+ untouched.included_cents_by_user,+ open_row.included_cents_by_user+ );+ assert_eq!(untouched.updated_at, open_row.updated_at);+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn store_open_allowance_does_not_write_a_stale_generation(pool: PgPool) {+ let repo = PgBillingRepo::new(pool.clone());+ let now = Utc::now();+ let open = BillingPeriod {+ start: (now - chrono::Duration::days(1))+ .duration_trunc(chrono::Duration::microseconds(1))+ .unwrap(),+ end: now + chrono::Duration::days(20),+ }+ .open_start(now)+ .unwrap();+ let alice = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();+ let bob = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();+ let before = vec![+ SeatAllowance {+ user: payer(),+ included_cents: 100,+ },+ SeatAllowance {+ user: alice.clone(),+ included_cents: 100,+ },+ SeatAllowance {+ user: bob.clone(),+ included_cents: 300,+ },+ ];+ let after = vec![+ SeatAllowance {+ user: payer(),+ included_cents: 100,+ },+ SeatAllowance {+ user: bob,+ included_cents: 300,+ },+ ];+ assert_eq!(+ repo.store_open_allowance(&payer(), open, &before, SeatGeneration::from_raw(0))+ .await+ .unwrap(),+ AllowanceStore::Stored+ );+ repo.release_open_seat(&payer(), open, &alice)+ .await+ .unwrap();++ assert_eq!(+ repo.store_open_allowance(&payer(), open, &before, SeatGeneration::from_raw(0))+ .await+ .unwrap(),+ AllowanceStore::Conflict+ );+ assert_eq!(+ repo.period_allowance(&payer(), open.start())+ .await+ .unwrap()+ .unwrap()+ .seats,+ after+ );++ assert_eq!(+ repo.store_open_allowance(&payer(), open, &after, SeatGeneration::from_raw(1))+ .await+ .unwrap(),+ AllowanceStore::Stored+ );+ assert_eq!(+ repo.period_allowance(&payer(), open.start())+ .await+ .unwrap()+ .unwrap()+ .seats,+ after+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn release_open_seat_without_an_allowance_row_bumps_generation(pool: PgPool) {+ let repo = PgBillingRepo::new(pool.clone());+ let now = Utc::now();+ let open = BillingPeriod {+ start: (now - chrono::Duration::days(1))+ .duration_trunc(chrono::Duration::microseconds(1))+ .unwrap(),+ end: now + chrono::Duration::days(20),+ }+ .open_start(now)+ .unwrap();+ let member = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();++ repo.release_open_seat(&payer(), open, &member)+ .await+ .unwrap();++ assert!(+ repo.period_allowance(&payer(), open.start())+ .await+ .unwrap()+ .is_none()+ );+ assert_eq!(seat_generation(&pool, payer().as_ref()).await, Some(1));+ assert_eq!(+ repo.store_open_allowance(+ &payer(),+ open,+ &[SeatAllowance {+ user: member.clone(),+ included_cents: 4_000,+ }],+ SeatGeneration::from_raw(0),+ )+ .await+ .unwrap(),+ AllowanceStore::Conflict+ );+ assert!(+ repo.period_allowance(&payer(), open.start())+ .await+ .unwrap()+ .is_none()+ );+}diff --git a/crates/macro_db_client/migrations/20260924180536_ai_billing_seat_generation.sql b/crates/macro_db_client/migrations/20260924180536_ai_billing_seat_generation.sqlnew file mode 100644index 0000000000..38d4102ccc--- /dev/null+++ b/crates/macro_db_client/migrations/20260924180536_ai_billing_seat_generation.sql@@ -0,0 +1,7 @@+-- Monotonic generation of a payer's open-seat roster.+--+-- Removal bumps this even when the open allowance row does not exist yet, so a+-- roster read from before the bump cannot be stored. Deployed writers omit the+-- column; the default keeps this migration compatible with them.+ALTER TABLE ai_billing_account+ ADD COLUMN seat_generation BIGINT NOT NULL DEFAULT 0;diff --git a/crates/teams/src/domain.rs b/crates/teams/src/domain.rsindex c73b69f9e2..9f575607fe 100644--- a/crates/teams/src/domain.rs+++ b/crates/teams/src/domain.rs@@ -3,6 +3,7 @@ pub mod crm_enqueuer;pub mod customer_repo;pub mod events;pub mod model;+pub mod open_seat_release;pub mod team_analytics;pub mod team_crm_settings_repo;pub mod team_repo;diff --git a/crates/teams/src/domain/model.rs b/crates/teams/src/domain/model.rsindex 2e6621ddd4..c160aa197e 100644--- a/crates/teams/src/domain/model.rs+++ b/crates/teams/src/domain/model.rs@@ -688,6 +688,9 @@ pub enum RemoveUserFromTeamError {/// Remove roles from user error#[error("Remove roles from user error")]RemoveRolesFromUserError(#[from] UserRolesAndPermissionsError),+ /// The removed member's open seat could not be released, and the removal was rolled back.+ #[error("failed to release the removed member's open seat")]+ OpenSeatRelease(#[source] Box<dyn std::error::Error + Send + Sync>),}/// Arguments for creating a subscriptiondiff --git a/crates/teams/src/domain/open_seat_release.rs b/crates/teams/src/domain/open_seat_release.rsnew file mode 100644index 0000000000..896e686be3--- /dev/null+++ b/crates/teams/src/domain/open_seat_release.rs@@ -0,0 +1,36 @@+//! Outbound port for releasing a member's open seat when they leave a team.+//!+//! The teams service uses this port to release that seat without depending on+//! a particular storage implementation.++use macro_user_id::user_id::MacroUserIdStr;+use std::convert::Infallible;++/// Releases a member's open seat for a team.+pub trait OpenSeatRelease: Clone + Send + Sync + 'static {+ /// Error returned when releasing an open seat fails.+ type Err: std::error::Error + Send + Sync + 'static;++ /// Releases the open seat held by `member` on `team_id`.+ fn release(+ &self,+ team_id: uuid::Uuid,+ member: &MacroUserIdStr<'_>,+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;+}++/// No-op open-seat release for callers that do not release seats.+#[derive(Clone, Debug)]+pub struct NoOpOpenSeatRelease;++impl OpenSeatRelease for NoOpOpenSeatRelease {+ type Err = Infallible;++ async fn release(+ &self,+ _team_id: uuid::Uuid,+ _member: &MacroUserIdStr<'_>,+ ) -> Result<(), Self::Err> {+ Ok(())+ }+}diff --git a/crates/teams/src/domain/team_repo.rs b/crates/teams/src/domain/team_repo.rsindex 84ac210da5..8ab99b290a 100644--- a/crates/teams/src/domain/team_repo.rs+++ b/crates/teams/src/domain/team_repo.rs@@ -48,6 +48,14 @@ pub trait TeamRepository: Clone + Send + Sync + 'static {team_id: &uuid::Uuid,) -> impl Future<Output = Result<bool, TeamError>> + Send;+ /// Gets the owner of a team.+ ///+ /// Every team has exactly one owner.+ fn get_team_owner(+ &self,+ team_id: &uuid::Uuid,+ ) -> impl Future<Output = Result<MacroUserIdStr<'static>, TeamError>> + Send;+/// Creates a new team with the provided normalized slug. `subscription_id` is `None` for/// free teams. Membership is not capped by team size. `owner_plan` is the plan the owner's/// own seat is already billed at.diff --git a/crates/teams/src/domain/team_service.rs b/crates/teams/src/domain/team_service.rsindex 9aebf57e07..47b4cd0702 100644--- a/crates/teams/src/domain/team_service.rs+++ b/crates/teams/src/domain/team_service.rs@@ -50,6 +50,7 @@ use crate::domain::{ToggleAutoJoinDomainError, TryJoinTeamByDomainError, is_generic_email_domain,team_slug_from_name,},+ open_seat_release::{NoOpOpenSeatRelease, OpenSeatRelease},team_analytics::{NoOpTeamAnalytics, TeamAnalytics, TeamAnalyticsEvent},team_crm_settings_repo::TeamCrmSettingsRepository,team_repo::{TeamMembersService, TeamRepository, TeamService},@@ -105,6 +106,7 @@ pub struct TeamServiceImpl<TA = NoOpTeamAnalytics,CNE = NoOpContactsEnqueuer,EB = NoopMacroEventBroker,+ OSR = NoOpOpenSeatRelease,> whereTR: TeamRepository,CR: CustomerRepository,@@ -116,6 +118,7 @@ pub struct TeamServiceImpl<TA: TeamAnalytics,CNE: ContactsEnqueuer,EB: MacroEventBroker,+ OSR: OpenSeatRelease,{/// The underlying team repositoryteam_repository: TR,@@ -140,14 +143,16 @@ pub struct TeamServiceImpl<contacts_enqueuer: CNE,/// Outbound port for best-effort team events.event_broker: EB,+ /// Outbound port that releases a removed member's open seat.+ open_seat_release: OSR,}fn channel_error_to_team_error(error: ChannelMutationErr) -> TeamError {TeamError::StorageLayerError(error.into())}-impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> Clone- for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR> Clone+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR>whereTR: TeamRepository,CR: CustomerRepository,@@ -159,6 +164,7 @@ whereTA: TeamAnalytics,CNE: ContactsEnqueuer,EB: MacroEventBroker + Clone,+ OSR: OpenSeatRelease,{fn clone(&self) -> Self {Self {@@ -172,6 +178,7 @@ whereteam_analytics: self.team_analytics.clone(),contacts_enqueuer: self.contacts_enqueuer.clone(),event_broker: self.event_broker.clone(),+ open_seat_release: self.open_seat_release.clone(),}}}@@ -188,6 +195,7 @@ impl<TR, CR, CS, URPS, NI, CE, TCRMS>NoOpTeamAnalytics,NoOpContactsEnqueuer,NoopMacroEventBroker,+ NoOpOpenSeatRelease,>whereTR: TeamRepository,@@ -222,7 +230,19 @@ where}impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA>- TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, NoOpContactsEnqueuer, NoopMacroEventBroker>+ TeamServiceImpl<+ TR,+ CR,+ CS,+ URPS,+ NI,+ CE,+ TCRMS,+ TA,+ NoOpContactsEnqueuer,+ NoopMacroEventBroker,+ NoOpOpenSeatRelease,+ >whereTR: TeamRepository,CR: CustomerRepository,@@ -259,12 +279,13 @@ whereteam_analytics,contacts_enqueuer: NoOpContactsEnqueuer,event_broker: NoopMacroEventBroker,+ open_seat_release: NoOpOpenSeatRelease,}}}-impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>- TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR>+ TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR>whereTR: TeamRepository,CR: CustomerRepository,@@ -276,12 +297,13 @@ whereTA: TeamAnalytics,CNE: ContactsEnqueuer,EB: MacroEventBroker,+ OSR: OpenSeatRelease,{/// Replaces the contacts enqueuer while preserving every other service dependency.pub fn with_contacts_enqueuer<CNE2>(self,contacts_enqueuer: CNE2,- ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE2, EB>+ ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE2, EB, OSR>whereCNE2: ContactsEnqueuer,{@@ -296,6 +318,7 @@ whereteam_analytics: self.team_analytics,contacts_enqueuer,event_broker: self.event_broker,+ open_seat_release: self.open_seat_release,}}@@ -303,7 +326,7 @@ wherepub fn with_event_broker<EB2>(self,event_broker: EB2,- ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB2>+ ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB2, OSR>whereEB2: MacroEventBroker,{@@ -318,9 +341,78 @@ whereteam_analytics: self.team_analytics,contacts_enqueuer: self.contacts_enqueuer,event_broker,+ open_seat_release: self.open_seat_release,}}+ /// Replaces the open-seat release while preserving every other service dependency.+ pub fn with_open_seat_release<OSR2>(+ self,+ open_seat_release: OSR2,+ ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR2>+ where+ OSR2: OpenSeatRelease,+ {+ TeamServiceImpl {+ team_repository: self.team_repository,+ customer_repository: self.customer_repository,+ channel_service: self.channel_service,+ user_roles_and_permissions_service: self.user_roles_and_permissions_service,+ notification_ingress: self.notification_ingress,+ crm_enqueuer: self.crm_enqueuer,+ team_crm_settings_repository: self.team_crm_settings_repository,+ team_analytics: self.team_analytics,+ contacts_enqueuer: self.contacts_enqueuer,+ event_broker: self.event_broker,+ open_seat_release,+ }+ }++ async fn restore_after_channels_left(+ &self,+ removed_member: &TeamMember<'_>,+ subscription_id: Option<&stripe::SubscriptionId>,+ user_id: &MacroUserIdStr<'_>,+ left_channel_ids: &[uuid::Uuid],+ failed_step: &'static str,+ ) {+ self.channel_service+ .restore_by_channel_ids(user_id, left_channel_ids)+ .await+ .inspect_err(|rollback_err| {+ tracing::error!(+ error = ?rollback_err,+ failed_step,+ "unable to rollback team channel membership after {failed_step} failed"+ );+ })+ .ok();+ if let Some(subscription_id) = subscription_id {+ self.customer_repository+ .increment_seat_count(subscription_id, removed_member.plan, 1)+ .await+ .inspect_err(|rollback_err| {+ tracing::error!(+ error = ?rollback_err,+ failed_step,+ "unable to rollback customer seat count after {failed_step} failed"+ );+ })+ .ok();+ }+ self.team_repository+ .rollback_remove_user_from_team(removed_member)+ .await+ .inspect_err(|rollback_err| {+ tracing::error!(+ error = ?rollback_err,+ failed_step,+ "unable to rollback removed team member after {failed_step} failed"+ );+ })+ .ok();+ }+#[allow(dead_code,reason = "team mutations publish events in follow-up changes"@@ -554,8 +646,8 @@ impl GetTeamSubscriptionError {}}-impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamMembersService- for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR> TeamMembersService+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR>whereTR: TeamRepository,CR: CustomerRepository,@@ -567,6 +659,7 @@ whereTA: TeamAnalytics,CNE: ContactsEnqueuer,EB: MacroEventBroker + Clone,+ OSR: OpenSeatRelease,{#[tracing::instrument(skip(self), err)]async fn list_team_members(@@ -583,8 +676,8 @@ where}}-impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamService- for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR> TeamService+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB, OSR>whereTR: TeamRepository,CR: CustomerRepository,@@ -596,6 +689,7 @@ whereTA: TeamAnalytics,CNE: ContactsEnqueuer,EB: MacroEventBroker + Clone,+ OSR: OpenSeatRelease,{#[tracing::instrument(skip(self), err)]async fn create_team(@@ -866,10 +960,32 @@ where.get_team_enterprise_status(&team_id).await?;- let removed_member = self+ let roles_to_remove = team_member_roles_to_remove();+ let current_roles = self+ .user_roles_and_permissions_service+ .get_user_roles(user_id)+ .await+ .map_err(RemoveUserFromTeamError::RemoveRolesFromUserError)?;+ let roles_to_restore: Vec<RoleId> = roles_to_remove+ .iter()+ .filter(|role| current_roles.contains(*role))+ .cloned()+ .collect();++ let removed_member = match self.team_repository.remove_user_from_team(&team_id, user_id)- .await?;+ .await+ {+ Ok(removed_member) => removed_member,+ Err(RemoveUserFromTeamError::UserNotInTeam) => {+ if let Err(error) = self.open_seat_release.release(team_id, user_id).await {+ return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));+ }+ return Err(RemoveUserFromTeamError::UserNotInTeam);+ }+ Err(error) => return Err(error),+ };let subscription_id = if enterprise {None@@ -951,7 +1067,6 @@ where}};- let roles_to_remove = team_member_roles_to_remove();let roles = non_empty::NonEmpty::new(roles_to_remove.as_slice()).unwrap();if let Err(e) = self@@ -959,39 +1074,39 @@ where.dangerous_remove_roles_from_user(user_id, &roles).await{- self.channel_service- .restore_by_channel_ids(user_id, &left_channel_ids)- .await- .inspect_err(|rollback_err| {- tracing::error!(- error=?rollback_err,- "unable to rollback team channel membership after removing team member roles failed"- );- })- .ok();- if let Some(subscription_id) = subscription_id.as_ref() {- self.customer_repository- .increment_seat_count(subscription_id, removed_member.plan, 1)+ self.restore_after_channels_left(+ &removed_member,+ subscription_id.as_ref(),+ user_id,+ &left_channel_ids,+ "removing team member roles",+ )+ .await;+ return Err(RemoveUserFromTeamError::RemoveRolesFromUserError(e));+ }++ if let Err(error) = self.open_seat_release.release(team_id, user_id).await {+ if let Ok(restore) = non_empty::NonEmpty::new(roles_to_restore.as_slice()) {+ self.user_roles_and_permissions_service+ .dangerous_upsert_roles_for_user(user_id, restore).await.inspect_err(|rollback_err| {tracing::error!(- error=?rollback_err,- "unable to rollback customer seat count after removing team member roles failed"+ error = ?rollback_err,+ "unable to restore member roles after releasing the open seat failed");}).ok();}- self.team_repository- .rollback_remove_user_from_team(&removed_member)- .await- .inspect_err(|rollback_err| {- tracing::error!(- error=?rollback_err,- "unable to rollback removed team member after removing team member roles failed"- );- })- .ok();- return Err(RemoveUserFromTeamError::RemoveRolesFromUserError(e));+ self.restore_after_channels_left(+ &removed_member,+ subscription_id.as_ref(),+ user_id,+ &left_channel_ids,+ "releasing the open seat",+ )+ .await;+ return Err(RemoveUserFromTeamError::OpenSeatRelease(Box::new(error)));}// Best-effort: ask the email service to tear down CRM rowsdiff --git a/crates/teams/src/domain/team_service/test.rs b/crates/teams/src/domain/team_service/test.rsindex 4fd4d35bbe..d6e7207e3f 100644--- a/crates/teams/src/domain/team_service/test.rs+++ b/crates/teams/src/domain/team_service/test.rs@@ -39,6 +39,7 @@ use crate::domain::{contacts_enqueuer::ContactsEnqueuer,crm_enqueuer::{CrmEnqueuer, NoOpCrmEnqueuer},events::TeamCreatedMetadata,+ open_seat_release::OpenSeatRelease,team_analytics::{TeamAnalytics, TeamAnalyticsEvent},team_crm_settings_repo::NoOpTeamCrmSettingsRepository,};@@ -132,6 +133,7 @@ struct MockTeamRepository {fail_delete_team: bool,fail_get_all_team_members: bool,team_ids: Vec<uuid::Uuid>,+ reject_owner: bool,}impl MockTeamRepository {@@ -208,6 +210,7 @@ impl MockTeamRepository {fail_delete_team: false,fail_get_all_team_members: false,team_ids: Vec::new(),+ reject_owner: false,}}@@ -306,6 +309,23 @@ impl TeamRepository for MockTeamRepository {}}+ fn get_team_owner(+ &self,+ _: &uuid::Uuid,+ ) -> impl Future<Output = Result<MacroUserIdStr<'static>, TeamError>> + Send {+ let owner_id = self+ .team_for_get_by_id+ .as_ref()+ .unwrap_or(&self.created_team)+ .owner_id()+ .to_string();+ async move {+ MacroUserIdStr::parse_from_str(&owner_id)+ .map(|owner| owner.into_owned())+ .map_err(|error| TeamError::StorageLayerError(error.into()))+ }+ }+fn has_user_trialed(&self,_: &MacroUserIdStr<'_>,@@ -412,8 +432,15 @@ impl TeamRepository for MockTeamRepository {_: &MacroUserIdStr<'_>,) -> impl Future<Output = Result<TeamMember<'static>, RemoveUserFromTeamError>> + Send {*self.remove_user_calls.lock().unwrap() += 1;+ let reject_owner = self.reject_owner;let removed_member = self.removed_member.clone();- async move { removed_member.ok_or(RemoveUserFromTeamError::UserNotInTeam) }+ async move {+ if reject_owner {+ Err(RemoveUserFromTeamError::CannotRemoveOwner)+ } else {+ removed_member.ok_or(RemoveUserFromTeamError::UserNotInTeam)+ }+ }}fn get_team_invite_by_id(@@ -1154,8 +1181,10 @@ impl ChannelService for RecordingChannelService {struct MockUserRolesAndPermissionsService {upsert_calls: Arc<Mutex<Vec<(String, Vec<RoleId>)>>>,remove_calls: Arc<Mutex<Vec<(String, Vec<RoleId>)>>>,+ roles: Arc<Mutex<HashSet<RoleId>>>,fail_upsert: bool,fail_remove: bool,+ fail_get_roles: bool,}impl UserRolesAndPermissionsService for MockUserRolesAndPermissionsService {@@ -1163,7 +1192,17 @@ impl UserRolesAndPermissionsService for MockUserRolesAndPermissionsService {&self,_: &MacroUserIdStr<'_>,) -> impl Future<Output = Result<HashSet<RoleId>, UserRolesAndPermissionsError>> + Send {- async { Ok(HashSet::new()) }+ let fail = self.fail_get_roles;+ let roles = self.roles.lock().unwrap().clone();+ async move {+ if fail {+ Err(UserRolesAndPermissionsError::StorageLayerError(+ anyhow::anyhow!("get roles failed"),+ ))+ } else {+ Ok(roles)+ }+ }}fn get_user_permissions(@@ -1336,6 +1375,10 @@ impl RecordingEventBroker {fn events(&self) -> Vec<PublishedTeamEvent> {self.events.lock().unwrap().clone()}++ fn recorded_events(&self) -> Arc<Mutex<Vec<PublishedTeamEvent>>> {+ self.events.clone()+ }}impl MacroEventBroker for RecordingEventBroker {@@ -1393,6 +1436,53 @@ impl ContactsEnqueuer for RecordingContactsEnqueuer {}}+#[derive(Clone, Default)]+struct RecordingOpenSeatRelease {+ releases: Arc<Mutex<Vec<(uuid::Uuid, MacroUserIdStr<'static>)>>>,+ published_before: Arc<Mutex<Vec<usize>>>,+ published: Arc<Mutex<Vec<PublishedTeamEvent>>>,+ fail: bool,+}++impl RecordingOpenSeatRelease {+ fn failing() -> Self {+ Self {+ fail: true,+ ..Self::default()+ }+ }++ fn releases(&self) -> Vec<(uuid::Uuid, MacroUserIdStr<'static>)> {+ self.releases.lock().unwrap().clone()+ }++ fn published_before(&self) -> Vec<usize> {+ self.published_before.lock().unwrap().clone()+ }+}++impl OpenSeatRelease for RecordingOpenSeatRelease {+ type Err = std::io::Error;++ async fn release(+ &self,+ team_id: uuid::Uuid,+ member: &MacroUserIdStr<'_>,+ ) -> Result<(), Self::Err> {+ let published_before = self.published.lock().unwrap().len();+ self.published_before.lock().unwrap().push(published_before);+ self.releases+ .lock()+ .unwrap()+ .push((team_id, member.clone().into_owned()));+ if self.fail {+ Err(std::io::Error::other("open seat release failed"))+ } else {+ Ok(())+ }+ }+}+// -- Helpers --fn make_invite(email: &str, invite_id: uuid::Uuid, team_id: uuid::Uuid) -> TeamInvite<'static> {@@ -4603,6 +4693,450 @@ async fn test_remove_user_from_team_decrements_customer_seat_count() {assert!(ensure_dms_calls.lock().unwrap().is_empty());}+#[tokio::test]+async fn remove_user_from_team_releases_open_seat_before_returning() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let subscription_id: stripe::SubscriptionId = "sub_test".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(), "Test Team", mark_sent_calls);+ team_repo.removed_member = Some(TeamMember {+ team_id,+ user_id: member_id.clone().into_owned(),+ role: TeamRole::Member,+ plan: SeatPlan::Premium,+ });+ team_repo.team_subscription_id = Some(subscription_id.clone());+ let rollback_remove_calls = team_repo.rollback_remove_calls.clone();++ let customer_repo = MockCustomerRepository {+ subscription_id: subscription_id.clone(),+ ..Default::default()+ };+ let increment_calls = customer_repo.increment_calls.clone();+ let decrement_calls = customer_repo.decrement_calls.clone();++ let channels_repo = RecordingChannelService::default();+ let remove_channel_calls = channels_repo.leave_calls.clone();+ let ensure_dms_calls = channels_repo.ensure_dms_calls.clone();+ let roles_service = MockUserRolesAndPermissionsService::default();+ let event_broker = RecordingEventBroker::default();+ let open_seat_release = RecordingOpenSeatRelease {+ published: event_broker.recorded_events(),+ ..Default::default()+ };++ let service = TeamServiceImpl::new(+ team_repo,+ customer_repo,+ channels_repo,+ roles_service.clone(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_event_broker(event_broker.clone())+ .with_open_seat_release(open_seat_release.clone());++ service+ .remove_user_from_team(+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),+ &member_id,+ )+ .await+ .unwrap();++ assert_eq!(+ open_seat_release.releases(),+ vec![(team_id, member_id.clone().into_owned())]+ );+ assert_eq!(open_seat_release.published_before(), vec![0]);+ let published = event_broker.events();+ assert_eq!(published.len(), 1);+ assert_eq!(published[0].envelope["event_type"], "team.member_removed");+ assert_eq!(+ published[0].envelope["metadata"]["member_id"],+ member_id.as_ref()+ );+ assert_eq!(+ published[0].envelope["metadata"]["team_id"],+ team_id.to_string()+ );+ assert_eq!(+ *decrement_calls.lock().unwrap(),+ vec![(subscription_id.to_string(), 1)]+ );+ assert!(increment_calls.lock().unwrap().is_empty());+ assert_eq!(*rollback_remove_calls.lock().unwrap(), 0);+ assert_eq!(+ *remove_channel_calls.lock().unwrap(),+ vec![(team_id, member_id.as_ref().to_string())]+ );+ assert_eq!(+ *roles_service.remove_calls.lock().unwrap(),+ vec![(+ member_id.as_ref().to_string(),+ vec![RoleId::TeamSubscriber, RoleId::SubOpus, RoleId::SubMax]+ )]+ );+ assert!(roles_service.upsert_calls.lock().unwrap().is_empty());+ assert!(ensure_dms_calls.lock().unwrap().is_empty());+}++#[tokio::test]+async fn remove_user_from_team_restores_snapshotted_roles_when_release_fails() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let subscription_id: stripe::SubscriptionId = "sub_test".parse().unwrap();+ let left_channel_ids = vec![uuid::Uuid::from_u128(42), uuid::Uuid::from_u128(43)];+ 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);+ team_repo.removed_member = Some(TeamMember {+ team_id,+ user_id: member_id.clone().into_owned(),+ role: TeamRole::Member,+ plan: SeatPlan::Premium,+ });+ team_repo.team_subscription_id = Some(subscription_id.clone());+ let rollback_remove_calls = team_repo.rollback_remove_calls.clone();++ let customer_repo = MockCustomerRepository {+ subscription_id: subscription_id.clone(),+ ..Default::default()+ };+ let channels_repo = RecordingChannelService {+ leave_channel_ids: left_channel_ids.clone(),+ ..Default::default()+ };+ let roles_service = MockUserRolesAndPermissionsService::default();+ roles_service.roles.lock().unwrap().extend([+ RoleId::TeamSubscriber,+ RoleId::SubMax,+ RoleId::EmailTool,+ ]);+ let event_broker = RecordingEventBroker::default();+ let open_seat_release = RecordingOpenSeatRelease::failing();++ let service = TeamServiceImpl::new(+ team_repo,+ customer_repo.clone(),+ channels_repo.clone(),+ roles_service.clone(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_event_broker(event_broker.clone())+ .with_open_seat_release(open_seat_release.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::OpenSeatRelease(_)));+ assert_eq!(+ std::error::Error::source(&error).unwrap().to_string(),+ "open seat release failed"+ );+ assert_eq!(+ open_seat_release.releases(),+ vec![(team_id, member_id.clone().into_owned())]+ );+ assert_eq!(+ *roles_service.remove_calls.lock().unwrap(),+ vec![(+ member_id.as_ref().to_string(),+ vec![RoleId::TeamSubscriber, RoleId::SubOpus, RoleId::SubMax]+ )]+ );+ assert_eq!(+ *roles_service.upsert_calls.lock().unwrap(),+ vec![(+ member_id.as_ref().to_string(),+ vec![RoleId::TeamSubscriber, RoleId::SubMax]+ )]+ );+ assert_eq!(+ *channels_repo.restore_calls.lock().unwrap(),+ vec![(member_id.as_ref().to_string(), left_channel_ids)]+ );+ assert_eq!(+ *customer_repo.seat_plan_calls.lock().unwrap(),+ vec![+ (subscription_id.to_string(), SeatPlan::Premium, 1),+ (subscription_id.to_string(), SeatPlan::Premium, 1),+ ]+ );+ assert_eq!(+ *customer_repo.increment_calls.lock().unwrap(),+ vec![(subscription_id.to_string(), 1)]+ );+ assert_eq!(*rollback_remove_calls.lock().unwrap(), 1);+ assert!(event_broker.events().is_empty());+}++#[tokio::test]+async fn remove_user_from_team_does_not_release_seat_when_role_removal_fails() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let subscription_id: stripe::SubscriptionId = "sub_test".parse().unwrap();+ let left_channel_ids = vec![uuid::Uuid::from_u128(11)];+ 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);+ team_repo.removed_member = Some(TeamMember {+ team_id,+ user_id: member_id.clone().into_owned(),+ role: TeamRole::Member,+ plan: SeatPlan::Premium,+ });+ team_repo.team_subscription_id = Some(subscription_id.clone());+ let rollback_remove_calls = team_repo.rollback_remove_calls.clone();++ let customer_repo = MockCustomerRepository {+ subscription_id: subscription_id.clone(),+ ..Default::default()+ };+ let channels_repo = RecordingChannelService {+ leave_channel_ids: left_channel_ids.clone(),+ ..Default::default()+ };+ let roles_service = MockUserRolesAndPermissionsService {+ fail_remove: true,+ ..Default::default()+ };+ roles_service+ .roles+ .lock()+ .unwrap()+ .insert(RoleId::TeamSubscriber);+ let open_seat_release = RecordingOpenSeatRelease::default();+ let event_broker = RecordingEventBroker::default();++ let service = TeamServiceImpl::new(+ team_repo,+ customer_repo.clone(),+ channels_repo.clone(),+ roles_service.clone(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_event_broker(event_broker.clone())+ .with_open_seat_release(open_seat_release.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!(+ *roles_service.remove_calls.lock().unwrap(),+ vec![(+ member_id.as_ref().to_string(),+ vec![RoleId::TeamSubscriber, RoleId::SubOpus, RoleId::SubMax]+ )]+ );+ assert!(open_seat_release.releases().is_empty());+ assert!(roles_service.upsert_calls.lock().unwrap().is_empty());+ assert_eq!(+ *channels_repo.restore_calls.lock().unwrap(),+ vec![(member_id.as_ref().to_string(), left_channel_ids)]+ );+ assert_eq!(+ *customer_repo.increment_calls.lock().unwrap(),+ vec![(subscription_id.to_string(), 1)]+ );+ assert_eq!(*rollback_remove_calls.lock().unwrap(), 1);+ assert!(event_broker.events().is_empty());+}++#[tokio::test]+async fn remove_user_from_team_user_not_in_team_releases_seat_and_keeps_the_error() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ 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 rollback_remove_calls = team_repo.rollback_remove_calls.clone();+ let customer_repo = MockCustomerRepository::default();+ let channels_repo = RecordingChannelService::default();+ let roles_service = MockUserRolesAndPermissionsService::default();+ let open_seat_release = RecordingOpenSeatRelease::default();++ let service = TeamServiceImpl::new(+ team_repo,+ customer_repo.clone(),+ channels_repo.clone(),+ roles_service.clone(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_open_seat_release(open_seat_release.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::UserNotInTeam));+ assert_eq!(+ open_seat_release.releases(),+ vec![(team_id, member_id.clone().into_owned())]+ );+ assert!(customer_repo.decrement_calls.lock().unwrap().is_empty());+ assert!(channels_repo.leave_calls.lock().unwrap().is_empty());+ assert!(roles_service.remove_calls.lock().unwrap().is_empty());+ assert_eq!(*rollback_remove_calls.lock().unwrap(), 0);+}++#[tokio::test]+async fn remove_user_from_team_user_not_in_team_returns_release_error_when_healing_fails() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ 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 open_seat_release = RecordingOpenSeatRelease::failing();++ let service = TeamServiceImpl::new(+ team_repo,+ MockCustomerRepository::default(),+ RecordingChannelService::default(),+ MockUserRolesAndPermissionsService::default(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_open_seat_release(open_seat_release.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::OpenSeatRelease(_)));+ assert_eq!(+ std::error::Error::source(&error).unwrap().to_string(),+ "open seat release failed"+ );+ assert_eq!(+ open_seat_release.releases(),+ vec![(team_id, member_id.into_owned())]+ );+}++#[tokio::test]+async fn remove_user_from_team_owner_rejection_does_not_release_seat() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").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(), "Test Team", mark_sent_calls);+ team_repo.reject_owner = true;+ let open_seat_release = RecordingOpenSeatRelease::default();+ let customer_repo = MockCustomerRepository::default();++ let service = TeamServiceImpl::new(+ team_repo,+ customer_repo.clone(),+ RecordingChannelService::default(),+ MockUserRolesAndPermissionsService::default(),+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_open_seat_release(open_seat_release.clone());++ let error = service+ .remove_user_from_team(+ test_team_receipt::<AdminTeamRole>(team_id, &owner_id),+ &owner_id,+ )+ .await+ .unwrap_err();++ assert!(matches!(error, RemoveUserFromTeamError::CannotRemoveOwner));+ assert!(open_seat_release.releases().is_empty());+ assert!(customer_repo.decrement_calls.lock().unwrap().is_empty());+}++#[tokio::test]+async fn remove_user_from_team_role_read_failure_leaves_membership_unchanged() {+ let team_id = uuid::Uuid::from_u128(1);+ let owner_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let member_id = MacroUserIdStr::parse_from_str("macro|[email protected]").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(), "Test Team", mark_sent_calls);+ team_repo.removed_member = Some(TeamMember {+ team_id,+ user_id: member_id.clone().into_owned(),+ role: TeamRole::Member,+ plan: SeatPlan::Premium,+ });+ let remove_user_calls = team_repo.remove_user_calls.clone();+ let roles_service = MockUserRolesAndPermissionsService {+ fail_get_roles: true,+ ..Default::default()+ };+ let open_seat_release = RecordingOpenSeatRelease::default();++ let service = TeamServiceImpl::new(+ team_repo,+ MockCustomerRepository::default(),+ RecordingChannelService::default(),+ roles_service,+ Arc::new(MockNotificationIngress::new(HashSet::new())),+ NoOpCrmEnqueuer,+ NoOpTeamCrmSettingsRepository,+ )+ .with_open_seat_release(open_seat_release.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!(error.to_string(), "Remove roles from user error");+ assert!(+ std::error::Error::source(&error)+ .unwrap()+ .to_string()+ .contains("get roles failed")+ );+ assert_eq!(*remove_user_calls.lock().unwrap(), 0);+ assert!(open_seat_release.releases().is_empty());+}+#[tokio::test]async fn team_analytics_remove_user_from_team_emits_left_event_with_team_id() {let team_id = uuid::Uuid::from_u128(331);diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rsindex cb6eba169e..00155c1e06 100644--- a/crates/teams/src/inbound/axum_router/test.rs+++ b/crates/teams/src/inbound/axum_router/test.rs@@ -146,6 +146,20 @@ async fn remove_team_invite_not_found_response_is_preserved() {assert_eq!(body_text, r#"{"message":"team invite does not exist"}"#);}+#[tokio::test]+async fn remove_user_from_team_open_seat_release_error_stays_generic() {+ let error = RemoveUserFromTeamError::OpenSeatRelease(Box::new(std::io::Error::other(+ "open seat release failed",+ )));+ let (status, body_text, _) = response_parts(error).await;++ assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);+ assert_eq!(+ body_text,+ r#"{"message":"unable to remove user from team"}"#+ );+}+#[tokio::test]async fn remove_team_owner_validation_response_is_preserved() {let (status, body_text, _) = response_parts(RemoveUserFromTeamError::CannotRemoveOwner).await;diff --git a/crates/teams/src/outbound/team_repo.rs b/crates/teams/src/outbound/team_repo.rsindex aa47bb665e..015eeae53b 100644--- a/crates/teams/src/outbound/team_repo.rs+++ b/crates/teams/src/outbound/team_repo.rs@@ -65,27 +65,6 @@ impl TeamRepositoryImpl {Ok(())}- /// Gets the owner of a team- #[tracing::instrument(skip(self), err)]- async fn get_team_owner(- &self,- team_id: &uuid::Uuid,- ) -> Result<MacroUserIdStr<'_>, anyhow::Error> {- let owner_id = sqlx::query!(- r#"- SELECT owner_id- FROM team- WHERE id = $1- "#,- team_id,- )- .map(|row| row.owner_id)- .fetch_one(&self.pool)- .await?;-- Ok(MacroUserIdStr::parse_from_str(owner_id.as_str()).map(|id| id.into_owned())?)- }-#[tracing::instrument(skip(self), err)]async fn create_team_inner(&self,@@ -332,6 +311,28 @@ impl TeamRepository for TeamRepositoryImpl {Ok(enterprise)}+ #[tracing::instrument(skip(self), err)]+ async fn get_team_owner(+ &self,+ team_id: &uuid::Uuid,+ ) -> Result<MacroUserIdStr<'static>, TeamError> {+ let owner_id = sqlx::query!(+ r#"+ SELECT owner_id+ FROM team+ WHERE id = $1+ "#,+ team_id,+ )+ .map(|row| row.owner_id)+ .fetch_one(&self.pool)+ .await?;++ MacroUserIdStr::parse_from_str(owner_id.as_str())+ .map(|id| id.into_owned())+ .map_err(|error| TeamError::StorageLayerError(error.into()))+ }+#[tracing::instrument(skip(self), err)]async fn create_team(&self,diff --git a/services/authentication_service/src/api/context.rs b/services/authentication_service/src/api/context.rsindex e16b899c96..fd926bda83 100644--- a/services/authentication_service/src/api/context.rs+++ b/services/authentication_service/src/api/context.rs@@ -75,6 +75,18 @@ pub(crate) type ChannelServiceType = ChannelServiceImpl<PgChannelReferenceSharePermissions<EntityAccessServiceType>,>;+/// The AI billing service: plan allowances, prepaid credits, and overage,+/// resolved through roles + teams and collected through Stripe.+pub(crate) type AiBillingServiceType = ai_billing::domain::BillingServiceImpl<+ ai_billing::outbound::RolesTeamsEntitlementSource<+ UserRolesAndPermissionsServiceImpl<MacroDB, MacroDB>,+ teams::outbound::team_repo::TeamRepositoryImpl,+ >,+ ai_billing::outbound::PgUsageReader,+ ai_billing::outbound::PgBillingRepo,+ ai_billing::outbound::StripePaymentGateway,+>;+pub(crate) type TeamsServiceType = teams::domain::team_service::TeamServiceImpl<teams::outbound::team_repo::TeamRepositoryImpl,teams::outbound::customer_repo::CustomerRepositoryImpl,@@ -88,6 +100,7 @@ pub(crate) type TeamsServiceType = teams::domain::team_service::TeamServiceImpl<SqsContactsIngress<SqsContactsQueue>,>,AuthenticationEventBroker,+ AiBillingServiceType,>;pub(crate) type RateLimiter = RateLimitServiceImpl<RedisRateLimitAdapter<redis::Client>>;@@ -115,18 +128,6 @@ pub(crate) type FavoritesServiceType = favorites::domain::service::FavoritesServpub(crate) type AuthorizationService = MacroAuthorizationServiceImpl<MacroAuthJwtValidator>;-/// The AI billing service: plan allowances, prepaid credits, and overage,-/// resolved through roles + teams and collected through Stripe.-pub(crate) type AiBillingServiceType = ai_billing::domain::BillingServiceImpl<- ai_billing::outbound::RolesTeamsEntitlementSource<- UserRolesAndPermissionsServiceImpl<MacroDB, MacroDB>,- teams::outbound::team_repo::TeamRepositoryImpl,- >,- ai_billing::outbound::PgUsageReader,- ai_billing::outbound::PgBillingRepo,- ai_billing::outbound::StripePaymentGateway,->;-#[derive(Clone, FromRef)]pub(crate) struct ApiContext {pub db: PgPool,diff --git a/services/authentication_service/src/main.rs b/services/authentication_service/src/main.rsindex 7b4e514c09..183f2f7a0d 100644--- a/services/authentication_service/src/main.rs+++ b/services/authentication_service/src/main.rs@@ -442,19 +442,6 @@ async fn main() -> anyhow::Result<()> {),);- let teams_service_impl = TeamServiceImpl::new_with_analytics(- teams_repo_impl.clone(),- customer_repo_impl,- channel_service.clone(),- user_roles_and_permissions_service.clone(),- notification_ingress_service.clone(),- crm_enqueuer,- team_crm_settings_repo_impl,- team_analytics,- )- .with_contacts_enqueuer(contacts_enqueuer)- .with_event_broker(macro_event_broker);-let foreign_entity_service =ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone()));@@ -517,6 +504,19 @@ async fn main() -> anyhow::Result<()> {ai_billing::outbound::PgBillingRepo::new(db.clone()),ai_billing::outbound::StripePaymentGateway::new(stripe_client.clone()),));+ let teams_service_impl = TeamServiceImpl::new_with_analytics(+ teams_repo_impl.clone(),+ customer_repo_impl,+ channel_service.clone(),+ user_roles_and_permissions_service.clone(),+ notification_ingress_service.clone(),+ crm_enqueuer,+ team_crm_settings_repo_impl,+ team_analytics,+ )+ .with_contacts_enqueuer(contacts_enqueuer)+ .with_event_broker(macro_event_broker)+ .with_open_seat_release((*ai_billing_service).clone());let document_storage_service_client = Arc::new(document_storage_service_client);let user_deletion = Arc::new(authentication_service::outbound::user_deletion::UserDeletionAdapter::new(